content/test/test_render_view_host.h

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