1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_TEST_TEST_RENDER_VIEW_HOST_H_ 6 #define CONTENT_TEST_TEST_RENDER_VIEW_HOST_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/basictypes.h" 12 #include "base/gtest_prod_util.h" 13 #include "build/build_config.h" 14 #include "content/browser/renderer_host/render_view_host_impl.h" 15 #include "content/browser/renderer_host/render_widget_host_view_base.h" 16 #include "content/public/test/test_renderer_host.h" 17 #include "ui/base/ime/dummy_text_input_client.h" 18 #include "ui/base/layout.h" 19 #include "ui/base/page_transition_types.h" 20 #include "ui/gfx/vector2d_f.h" 21 22 // This file provides a testing framework for mocking out the RenderProcessHost 23 // layer. It allows you to test RenderViewHost, WebContentsImpl, 24 // NavigationController, and other layers above that without running an actual 25 // renderer process. 26 // 27 // To use, derive your test base class from RenderViewHostImplTestHarness. 28 29 struct FrameHostMsg_DidCommitProvisionalLoad_Params; 30 31 namespace gfx { 32 class Rect; 33 } 34 35 namespace content { 36 37 class SiteInstance; 38 class TestRenderFrameHost; 39 class TestWebContents; 40 41 // Utility function to initialize ViewHostMsg_NavigateParams_Params 42 // with given |page_id|, |url| and |transition_type|. 43 void InitNavigateParams(FrameHostMsg_DidCommitProvisionalLoad_Params* params, 44 int page_id, 45 const GURL& url, 46 ui::PageTransition transition_type); 47 48 // TestRenderViewHostView ------------------------------------------------------ 49 50 // Subclass the RenderViewHost's view so that we can call Show(), etc., 51 // without having side-effects. 52 class TestRenderWidgetHostView : public RenderWidgetHostViewBase { 53 public: 54 explicit TestRenderWidgetHostView(RenderWidgetHost* rwh); 55 virtual ~TestRenderWidgetHostView(); 56 57 // RenderWidgetHostView implementation. 58 virtual void InitAsChild(gfx::NativeView parent_view) OVERRIDE {} 59 virtual RenderWidgetHost* GetRenderWidgetHost() const OVERRIDE; 60 virtual void SetSize(const gfx::Size& size) OVERRIDE {} 61 virtual void SetBounds(const gfx::Rect& rect) OVERRIDE {} 62 virtual gfx::Vector2dF GetLastScrollOffset() const OVERRIDE; 63 virtual gfx::NativeView GetNativeView() const OVERRIDE; 64 virtual gfx::NativeViewId GetNativeViewId() const OVERRIDE; 65 virtual gfx::NativeViewAccessible GetNativeViewAccessible() OVERRIDE; 66 virtual ui::TextInputClient* GetTextInputClient() OVERRIDE; 67 virtual bool HasFocus() const OVERRIDE; 68 virtual bool IsSurfaceAvailableForCopy() const OVERRIDE; 69 virtual void Show() OVERRIDE; 70 virtual void Hide() OVERRIDE; 71 virtual bool IsShowing() OVERRIDE; 72 virtual gfx::Rect GetViewBounds() const OVERRIDE; 73 #if defined(OS_MACOSX) 74 virtual void SetActive(bool active) OVERRIDE; 75 virtual void SetTakesFocusOnlyOnMouseDown(bool flag) OVERRIDE {} 76 virtual void SetWindowVisibility(bool visible) OVERRIDE {} 77 virtual void WindowFrameChanged() OVERRIDE {} 78 virtual void ShowDefinitionForSelection() OVERRIDE {} 79 virtual bool SupportsSpeech() const OVERRIDE; 80 virtual void SpeakSelection() OVERRIDE; 81 virtual bool IsSpeaking() const OVERRIDE; 82 virtual void StopSpeaking() OVERRIDE; 83 #endif // defined(OS_MACOSX) 84 virtual void OnSwapCompositorFrame( 85 uint32 output_surface_id, 86 scoped_ptr<cc::CompositorFrame> frame) OVERRIDE; 87 88 // RenderWidgetHostViewBase implementation. 89 virtual void InitAsPopup(RenderWidgetHostView* parent_host_view, 90 const gfx::Rect& pos) OVERRIDE {} 91 virtual void InitAsFullscreen( 92 RenderWidgetHostView* reference_host_view) OVERRIDE {} 93 virtual void WasShown() OVERRIDE {} 94 virtual void WasHidden() OVERRIDE {} 95 virtual void MovePluginWindows( 96 const std::vector<WebPluginGeometry>& moves) OVERRIDE {} 97 virtual void Focus() OVERRIDE {} 98 virtual void Blur() OVERRIDE {} 99 virtual void SetIsLoading(bool is_loading) OVERRIDE {} 100 virtual void UpdateCursor(const WebCursor& cursor) OVERRIDE {} 101 virtual void TextInputTypeChanged(ui::TextInputType type, 102 ui::TextInputMode input_mode, 103 bool can_compose_inline) OVERRIDE {} 104 virtual void ImeCancelComposition() OVERRIDE {} 105 #if defined(OS_MACOSX) || defined(USE_AURA) 106 virtual void ImeCompositionRangeChanged( 107 const gfx::Range& range, 108 const std::vector<gfx::Rect>& character_bounds) OVERRIDE {} 109 #endif 110 virtual void RenderProcessGone(base::TerminationStatus status, 111 int error_code) OVERRIDE; 112 virtual void Destroy() OVERRIDE; 113 virtual void SetTooltipText(const base::string16& tooltip_text) OVERRIDE {} 114 virtual void SelectionBoundsChanged( 115 const ViewHostMsg_SelectionBounds_Params& params) OVERRIDE {} 116 virtual void CopyFromCompositingSurface( 117 const gfx::Rect& src_subrect, 118 const gfx::Size& dst_size, 119 CopyFromCompositingSurfaceCallback& callback, 120 const SkColorType color_type) OVERRIDE; 121 virtual void CopyFromCompositingSurfaceToVideoFrame( 122 const gfx::Rect& src_subrect, 123 const scoped_refptr<media::VideoFrame>& target, 124 const base::Callback<void(bool)>& callback) OVERRIDE; 125 virtual bool CanCopyToVideoFrame() const OVERRIDE; 126 virtual void AcceleratedSurfaceInitialized(int host_id, 127 int route_id) OVERRIDE; 128 virtual void AcceleratedSurfaceBuffersSwapped( 129 const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params, 130 int gpu_host_id) OVERRIDE; 131 virtual void AcceleratedSurfacePostSubBuffer( 132 const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params, 133 int gpu_host_id) OVERRIDE; 134 virtual void AcceleratedSurfaceSuspend() OVERRIDE; 135 virtual void AcceleratedSurfaceRelease() OVERRIDE {} 136 virtual bool HasAcceleratedSurface(const gfx::Size& desired_size) OVERRIDE; 137 #if defined(OS_MACOSX) 138 virtual bool PostProcessEventForPluginIme( 139 const NativeWebKeyboardEvent& event) OVERRIDE; 140 #endif 141 #if defined(OS_ANDROID) || defined(TOOLKIT_VIEWS) || defined(USE_AURA) 142 virtual void ShowDisambiguationPopup( 143 const gfx::Rect& rect_pixels, 144 const SkBitmap& zoomed_bitmap) OVERRIDE {} 145 #endif 146 #if defined(OS_ANDROID) 147 virtual void LockCompositingSurface() OVERRIDE {} 148 virtual void UnlockCompositingSurface() OVERRIDE {} 149 #endif 150 virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE {} 151 virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE; 152 virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE; 153 virtual bool LockMouse() OVERRIDE; 154 virtual void UnlockMouse() OVERRIDE; 155 #if defined(OS_WIN) 156 virtual void SetParentNativeViewAccessible( 157 gfx::NativeViewAccessible accessible_parent) OVERRIDE; 158 virtual gfx::NativeViewId GetParentForWindowlessPlugin() const OVERRIDE; 159 #endif 160 161 bool is_showing() const { return is_showing_; } 162 bool did_swap_compositor_frame() const { return did_swap_compositor_frame_; } 163 164 protected: 165 RenderWidgetHostImpl* rwh_; 166 167 private: 168 bool is_showing_; 169 bool did_swap_compositor_frame_; 170 ui::DummyTextInputClient text_input_client_; 171 }; 172 173 #if defined(COMPILER_MSVC) 174 // See comment for same warning on RenderViewHostImpl. 175 #pragma warning(push) 176 #pragma warning(disable: 4250) 177 #endif 178 179 // TestRenderViewHost ---------------------------------------------------------- 180 181 // TODO(brettw) this should use a TestWebContents which should be generalized 182 // from the WebContentsImpl test. We will probably also need that class' version 183 // of CreateRenderViewForRenderManager when more complicated tests start using 184 // this. 185 // 186 // Note that users outside of content must use this class by getting 187 // the separate RenderViewHostTester interface via 188 // RenderViewHostTester::For(rvh) on the RenderViewHost they want to 189 // drive tests on. 190 // 191 // Users within content may directly static_cast from a 192 // RenderViewHost* to a TestRenderViewHost*. 193 // 194 // The reasons we do it this way rather than extending the parallel 195 // inheritance hierarchy we have for RenderWidgetHost/RenderViewHost 196 // vs. RenderWidgetHostImpl/RenderViewHostImpl are: 197 // 198 // a) Extending the parallel class hierarchy further would require 199 // more classes to use virtual inheritance. This is a complexity that 200 // is better to avoid, especially when it would be introduced in the 201 // production code solely to facilitate testing code. 202 // 203 // b) While users outside of content only need to drive tests on a 204 // RenderViewHost, content needs a test version of the full 205 // RenderViewHostImpl so that it can test all methods on that concrete 206 // class (e.g. overriding a method such as 207 // RenderViewHostImpl::CreateRenderView). This would have complicated 208 // the dual class hierarchy even further. 209 // 210 // The reason we do it this way instead of using composition is 211 // similar to (b) above, essentially it gets very tricky. By using 212 // the split interface we avoid complexity within content and maintain 213 // reasonable utility for embedders. 214 class TestRenderViewHost 215 : public RenderViewHostImpl, 216 public RenderViewHostTester { 217 public: 218 TestRenderViewHost(SiteInstance* instance, 219 RenderViewHostDelegate* delegate, 220 RenderWidgetHostDelegate* widget_delegate, 221 int routing_id, 222 int main_frame_routing_id, 223 bool swapped_out); 224 virtual ~TestRenderViewHost(); 225 226 // RenderViewHostTester implementation. Note that CreateRenderView 227 // is not specified since it is synonymous with the one from 228 // RenderViewHostImpl, see below. 229 virtual void SendBeforeUnloadACK(bool proceed) OVERRIDE; 230 virtual void SetContentsMimeType(const std::string& mime_type) OVERRIDE; 231 virtual void SimulateSwapOutACK() OVERRIDE; 232 virtual void SimulateWasHidden() OVERRIDE; 233 virtual void SimulateWasShown() OVERRIDE; 234 235 // NOTE: These methods are deprecated and the equivalents in 236 // TestRenderFrameHost should be used. 237 virtual void SendNavigate(int page_id, const GURL& url) OVERRIDE; 238 virtual void SendFailedNavigate(int page_id, const GURL& url) OVERRIDE; 239 virtual void SendNavigateWithTransition( 240 int page_id, 241 const GURL& url, 242 ui::PageTransition transition) OVERRIDE; 243 244 // Calls OnNavigate on the RenderViewHost with the given information, 245 // including a custom original request URL. Sets the rest of the 246 // parameters in the message to the "typical" values. This is a helper 247 // function for simulating the most common types of loads. 248 void SendNavigateWithOriginalRequestURL( 249 int page_id, const GURL& url, const GURL& original_request_url); 250 251 void SendNavigateWithFile( 252 int page_id, const GURL& url, const base::FilePath& file_path); 253 254 void SendNavigateWithParams( 255 FrameHostMsg_DidCommitProvisionalLoad_Params* params); 256 257 void TestOnUpdateStateWithFile( 258 int page_id, const base::FilePath& file_path); 259 260 void TestOnStartDragging(const DropData& drop_data); 261 262 // If set, *delete_counter is incremented when this object destructs. 263 void set_delete_counter(int* delete_counter) { 264 delete_counter_ = delete_counter; 265 } 266 267 // Sets whether the RenderView currently exists or not. This controls the 268 // return value from IsRenderViewLive, which the rest of the system uses to 269 // check whether the RenderView has crashed or not. 270 void set_render_view_created(bool created) { 271 render_view_created_ = created; 272 } 273 274 // Returns whether the RenderViewHost is currently waiting to hear the result 275 // of a before unload handler from the renderer. 276 bool is_waiting_for_beforeunload_ack() const { 277 return is_waiting_for_beforeunload_ack_; 278 } 279 280 // Sets whether the RenderViewHost is currently swapped out, and thus 281 // filtering messages from the renderer. 282 void set_rvh_state(RenderViewHostImplState rvh_state) { 283 rvh_state_ = rvh_state; 284 } 285 286 // If set, navigations will appear to have loaded through a proxy 287 // (ViewHostMsg_FrameNavigte_Params::was_fetched_via_proxy). 288 // False by default. 289 void set_simulate_fetch_via_proxy(bool proxy); 290 291 // If set, navigations will appear to have cleared the history list in the 292 // RenderView 293 // (FrameHostMsg_DidCommitProvisionalLoad_Params::history_list_was_cleared). 294 // False by default. 295 void set_simulate_history_list_was_cleared(bool cleared); 296 297 // The opener route id passed to CreateRenderView(). 298 int opener_route_id() const { return opener_route_id_; } 299 300 // TODO(creis): Remove the need for these methods. 301 TestRenderFrameHost* main_render_frame_host() const { 302 return main_render_frame_host_; 303 } 304 void set_main_render_frame_host(TestRenderFrameHost* rfh) { 305 main_render_frame_host_ = rfh; 306 } 307 308 // RenderViewHost overrides -------------------------------------------------- 309 310 virtual bool CreateRenderView(const base::string16& frame_name, 311 int opener_route_id, 312 int proxy_route_id, 313 int32 max_page_id, 314 bool window_was_created_with_opener) OVERRIDE; 315 virtual bool IsRenderViewLive() const OVERRIDE; 316 virtual bool IsFullscreen() const OVERRIDE; 317 318 private: 319 FRIEND_TEST_ALL_PREFIXES(RenderViewHostTest, FilterNavigate); 320 321 void SendNavigateWithTransitionAndResponseCode(int page_id, 322 const GURL& url, 323 ui::PageTransition transition, 324 int response_code); 325 326 // Calls OnNavigate on the RenderViewHost with the given information. 327 // Sets the rest of the parameters in the message to the "typical" values. 328 // This is a helper function for simulating the most common types of loads. 329 void SendNavigateWithParameters( 330 int page_id, 331 const GURL& url, 332 ui::PageTransition transition, 333 const GURL& original_request_url, 334 int response_code, 335 const base::FilePath* file_path_for_history_item); 336 337 // Tracks if the caller thinks if it created the RenderView. This is so we can 338 // respond to IsRenderViewLive appropriately. 339 bool render_view_created_; 340 341 // See set_delete_counter() above. May be NULL. 342 int* delete_counter_; 343 344 // See set_simulate_fetch_via_proxy() above. 345 bool simulate_fetch_via_proxy_; 346 347 // See set_simulate_history_list_was_cleared() above. 348 bool simulate_history_list_was_cleared_; 349 350 // See SetContentsMimeType() above. 351 std::string contents_mime_type_; 352 353 // See opener_route_id() above. 354 int opener_route_id_; 355 356 TestRenderFrameHost* main_render_frame_host_; 357 358 DISALLOW_COPY_AND_ASSIGN(TestRenderViewHost); 359 }; 360 361 #if defined(COMPILER_MSVC) 362 #pragma warning(pop) 363 #endif 364 365 // Adds methods to get straight at the impl classes. 366 class RenderViewHostImplTestHarness : public RenderViewHostTestHarness { 367 public: 368 RenderViewHostImplTestHarness(); 369 virtual ~RenderViewHostImplTestHarness(); 370 371 // contents() is equivalent to static_cast<TestWebContents*>(web_contents()) 372 TestWebContents* contents(); 373 374 // RVH/RFH getters are shorthand for oft-used bits of web_contents(). 375 376 // test_rvh() is equivalent to any of the following: 377 // contents()->GetMainFrame()->GetRenderViewHost() 378 // contents()->GetRenderViewHost() 379 // static_cast<TestRenderViewHost*>(rvh()) 380 // 381 // Since most functionality will eventually shift from RVH to RFH, you may 382 // prefer to use the GetMainFrame() method in tests. 383 TestRenderViewHost* test_rvh(); 384 385 // pending_test_rvh() is equivalent to all of the following: 386 // contents()->GetPendingMainFrame()->GetRenderViewHost() [if frame exists] 387 // contents()->GetPendingRenderViewHost() 388 // static_cast<TestRenderViewHost*>(pending_rvh()) 389 // 390 // Since most functionality will eventually shift from RVH to RFH, you may 391 // prefer to use the GetPendingMainFrame() method in tests. 392 TestRenderViewHost* pending_test_rvh(); 393 394 // active_test_rvh() is equivalent to: 395 // contents()->GetPendingRenderViewHost() ? 396 // contents()->GetPendingRenderViewHost() : 397 // contents()->GetRenderViewHost(); 398 TestRenderViewHost* active_test_rvh(); 399 400 // main_test_rfh() is equivalent to contents()->GetMainFrame() 401 // TODO(nick): Replace all uses with contents()->GetMainFrame() 402 TestRenderFrameHost* main_test_rfh(); 403 404 private: 405 typedef scoped_ptr<ui::test::ScopedSetSupportedScaleFactors> 406 ScopedSetSupportedScaleFactors; 407 ScopedSetSupportedScaleFactors scoped_set_supported_scale_factors_; 408 DISALLOW_COPY_AND_ASSIGN(RenderViewHostImplTestHarness); 409 }; 410 411 } // namespace content 412 413 #endif // CONTENT_TEST_TEST_RENDER_VIEW_HOST_H_ 414