diff options
Diffstat (limited to 'content/test/test_render_view_host.h')
| -rw-r--r-- | content/test/test_render_view_host.h | 386 |
1 files changed, 386 insertions, 0 deletions
diff --git a/content/test/test_render_view_host.h b/content/test/test_render_view_host.h new file mode 100644 index 0000000..fd44b5c --- /dev/null +++ b/content/test/test_render_view_host.h @@ -0,0 +1,386 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_TEST_TEST_RENDER_VIEW_HOST_H_ +#define CONTENT_TEST_TEST_RENDER_VIEW_HOST_H_ + +#include <string> +#include <vector> + +#include "base/basictypes.h" +#include "base/gtest_prod_util.h" +#include "build/build_config.h" +#include "content/browser/renderer_host/render_view_host_impl.h" +#include "content/browser/renderer_host/render_widget_host_view_base.h" +#include "content/public/common/page_transition_types.h" +#include "content/public/test/test_renderer_host.h" +#include "ui/base/layout.h" +#include "ui/gfx/vector2d_f.h" + +// This file provides a testing framework for mocking out the RenderProcessHost +// layer. It allows you to test RenderViewHost, WebContentsImpl, +// NavigationController, and other layers above that without running an actual +// renderer process. +// +// To use, derive your test base class from RenderViewHostImplTestHarness. + +struct ViewHostMsg_FrameNavigate_Params; + +namespace gfx { +class Rect; +} + +namespace content { + +class SiteInstance; +class TestWebContents; + +// Utility function to initialize ViewHostMsg_NavigateParams_Params +// with given |page_id|, |url| and |transition_type|. +void InitNavigateParams(ViewHostMsg_FrameNavigate_Params* params, + int page_id, + const GURL& url, + PageTransition transition_type); + +// TestRenderViewHostView ------------------------------------------------------ + +// Subclass the RenderViewHost's view so that we can call Show(), etc., +// without having side-effects. +class TestRenderWidgetHostView : public RenderWidgetHostViewBase { + public: + explicit TestRenderWidgetHostView(RenderWidgetHost* rwh); + virtual ~TestRenderWidgetHostView(); + + // RenderWidgetHostView implementation. + virtual void InitAsChild(gfx::NativeView parent_view) OVERRIDE {} + virtual RenderWidgetHost* GetRenderWidgetHost() const OVERRIDE; + virtual void SetSize(const gfx::Size& size) OVERRIDE {} + virtual void SetBounds(const gfx::Rect& rect) OVERRIDE {} + virtual gfx::NativeView GetNativeView() const OVERRIDE; + virtual gfx::NativeViewId GetNativeViewId() const OVERRIDE; + virtual gfx::NativeViewAccessible GetNativeViewAccessible() OVERRIDE; + virtual bool HasFocus() const OVERRIDE; + virtual bool IsSurfaceAvailableForCopy() const OVERRIDE; + virtual void Show() OVERRIDE; + virtual void Hide() OVERRIDE; + virtual bool IsShowing() OVERRIDE; + virtual gfx::Rect GetViewBounds() const OVERRIDE; +#if defined(OS_MACOSX) + virtual void SetActive(bool active) OVERRIDE; + virtual void SetTakesFocusOnlyOnMouseDown(bool flag) OVERRIDE {} + virtual void SetWindowVisibility(bool visible) OVERRIDE {} + virtual void WindowFrameChanged() OVERRIDE {} + virtual void ShowDefinitionForSelection() OVERRIDE {} + virtual bool SupportsSpeech() const OVERRIDE; + virtual void SpeakSelection() OVERRIDE; + virtual bool IsSpeaking() const OVERRIDE; + virtual void StopSpeaking() OVERRIDE; +#endif // defined(OS_MACOSX) +#if defined(TOOLKIT_GTK) + virtual GdkEventButton* GetLastMouseDown() OVERRIDE; + virtual gfx::NativeView BuildInputMethodsGtkMenu() OVERRIDE; +#endif // defined(TOOLKIT_GTK) + virtual void OnSwapCompositorFrame( + uint32 output_surface_id, + scoped_ptr<cc::CompositorFrame> frame) OVERRIDE; + + // RenderWidgetHostViewPort implementation. + virtual void InitAsPopup(RenderWidgetHostView* parent_host_view, + const gfx::Rect& pos) OVERRIDE {} + virtual void InitAsFullscreen( + RenderWidgetHostView* reference_host_view) OVERRIDE {} + virtual void WasShown() OVERRIDE {} + virtual void WasHidden() OVERRIDE {} + virtual void MovePluginWindows( + const gfx::Vector2d& scroll_offset, + const std::vector<WebPluginGeometry>& moves) OVERRIDE {} + virtual void Focus() OVERRIDE {} + virtual void Blur() OVERRIDE {} + virtual void SetIsLoading(bool is_loading) OVERRIDE {} + virtual void UpdateCursor(const WebCursor& cursor) OVERRIDE {} + virtual void TextInputTypeChanged(ui::TextInputType type, + ui::TextInputMode input_mode, + bool can_compose_inline) OVERRIDE {} + virtual void ImeCancelComposition() OVERRIDE {} +#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA) + virtual void ImeCompositionRangeChanged( + const gfx::Range& range, + const std::vector<gfx::Rect>& character_bounds) OVERRIDE {} +#endif + virtual void DidUpdateBackingStore( + const gfx::Rect& scroll_rect, + const gfx::Vector2d& scroll_delta, + const std::vector<gfx::Rect>& rects, + const ui::LatencyInfo& latency_info) OVERRIDE {} + virtual void RenderProcessGone(base::TerminationStatus status, + int error_code) OVERRIDE; + virtual void WillDestroyRenderWidget(RenderWidgetHost* rwh) { } + virtual void Destroy() OVERRIDE; + virtual void SetTooltipText(const base::string16& tooltip_text) OVERRIDE {} + virtual void SelectionBoundsChanged( + const ViewHostMsg_SelectionBounds_Params& params) OVERRIDE {} + virtual void ScrollOffsetChanged() OVERRIDE {} + virtual BackingStore* AllocBackingStore(const gfx::Size& size) OVERRIDE; + virtual void CopyFromCompositingSurface( + const gfx::Rect& src_subrect, + const gfx::Size& dst_size, + const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE; + virtual void CopyFromCompositingSurfaceToVideoFrame( + const gfx::Rect& src_subrect, + const scoped_refptr<media::VideoFrame>& target, + const base::Callback<void(bool)>& callback) OVERRIDE; + virtual bool CanCopyToVideoFrame() const OVERRIDE; + virtual void OnAcceleratedCompositingStateChange() OVERRIDE; + virtual void AcceleratedSurfaceInitialized(int host_id, + int route_id) OVERRIDE; + virtual void AcceleratedSurfaceBuffersSwapped( + const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params, + int gpu_host_id) OVERRIDE; + virtual void AcceleratedSurfacePostSubBuffer( + const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params, + int gpu_host_id) OVERRIDE; + virtual void AcceleratedSurfaceSuspend() OVERRIDE; + virtual void AcceleratedSurfaceRelease() OVERRIDE {} + virtual bool HasAcceleratedSurface(const gfx::Size& desired_size) OVERRIDE; +#if defined(OS_MACOSX) + virtual void AboutToWaitForBackingStoreMsg() OVERRIDE; + virtual bool PostProcessEventForPluginIme( + const NativeWebKeyboardEvent& event) OVERRIDE; +#elif defined(OS_ANDROID) + virtual void ShowDisambiguationPopup( + const gfx::Rect& target_rect, + const SkBitmap& zoomed_bitmap) OVERRIDE {} + virtual void HasTouchEventHandlers(bool need_touch_events) OVERRIDE {} +#elif defined(OS_WIN) && !defined(USE_AURA) + virtual void WillWmDestroy() OVERRIDE; +#endif + virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE {} + virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE; + virtual void SetHasHorizontalScrollbar( + bool has_horizontal_scrollbar) OVERRIDE { } + virtual void SetScrollOffsetPinning( + bool is_pinned_to_left, bool is_pinned_to_right) OVERRIDE { } + virtual void OnAccessibilityEvents( + const std::vector<AccessibilityHostMsg_EventParams>& params) OVERRIDE {} + virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE; +#if defined(OS_WIN) && !defined(USE_AURA) + virtual void SetClickthroughRegion(SkRegion* region) OVERRIDE; +#endif + virtual bool LockMouse() OVERRIDE; + virtual void UnlockMouse() OVERRIDE; +#if defined(OS_WIN) && defined(USE_AURA) + virtual void SetParentNativeViewAccessible( + gfx::NativeViewAccessible accessible_parent) OVERRIDE; + virtual gfx::NativeViewId GetParentForWindowlessPlugin() const OVERRIDE; +#endif + + bool is_showing() const { return is_showing_; } + bool did_swap_compositor_frame() const { return did_swap_compositor_frame_; } + + protected: + RenderWidgetHostImpl* rwh_; + + private: + bool is_showing_; + bool did_swap_compositor_frame_; +}; + +#if defined(COMPILER_MSVC) +// See comment for same warning on RenderViewHostImpl. +#pragma warning(push) +#pragma warning(disable: 4250) +#endif + +// TestRenderViewHost ---------------------------------------------------------- + +// TODO(brettw) this should use a TestWebContents which should be generalized +// from the WebContentsImpl test. We will probably also need that class' version +// of CreateRenderViewForRenderManager when more complicated tests start using +// this. +// +// Note that users outside of content must use this class by getting +// the separate RenderViewHostTester interface via +// RenderViewHostTester::For(rvh) on the RenderViewHost they want to +// drive tests on. +// +// Users within content may directly static_cast from a +// RenderViewHost* to a TestRenderViewHost*. +// +// The reasons we do it this way rather than extending the parallel +// inheritance hierarchy we have for RenderWidgetHost/RenderViewHost +// vs. RenderWidgetHostImpl/RenderViewHostImpl are: +// +// a) Extending the parallel class hierarchy further would require +// more classes to use virtual inheritance. This is a complexity that +// is better to avoid, especially when it would be introduced in the +// production code solely to facilitate testing code. +// +// b) While users outside of content only need to drive tests on a +// RenderViewHost, content needs a test version of the full +// RenderViewHostImpl so that it can test all methods on that concrete +// class (e.g. overriding a method such as +// RenderViewHostImpl::CreateRenderView). This would have complicated +// the dual class hierarchy even further. +// +// The reason we do it this way instead of using composition is +// similar to (b) above, essentially it gets very tricky. By using +// the split interface we avoid complexity within content and maintain +// reasonable utility for embedders. +class TestRenderViewHost + : public RenderViewHostImpl, + public RenderViewHostTester { + public: + TestRenderViewHost(SiteInstance* instance, + RenderViewHostDelegate* delegate, + RenderFrameHostDelegate* frame_delegate, + RenderWidgetHostDelegate* widget_delegate, + int routing_id, + int main_frame_routing_id, + bool swapped_out); + virtual ~TestRenderViewHost(); + + // RenderViewHostTester implementation. Note that CreateRenderView + // is not specified since it is synonymous with the one from + // RenderViewHostImpl, see below. + virtual void SendNavigate(int page_id, const GURL& url) OVERRIDE; + virtual void SendFailedNavigate(int page_id, const GURL& url) OVERRIDE; + virtual void SendNavigateWithTransition(int page_id, const GURL& url, + PageTransition transition) OVERRIDE; + virtual void SendShouldCloseACK(bool proceed) OVERRIDE; + virtual void SetContentsMimeType(const std::string& mime_type) OVERRIDE; + virtual void SimulateSwapOutACK() OVERRIDE; + virtual void SimulateWasHidden() OVERRIDE; + virtual void SimulateWasShown() OVERRIDE; + + // Calls OnNavigate on the RenderViewHost with the given information, + // including a custom original request URL. Sets the rest of the + // parameters in the message to the "typical" values. This is a helper + // function for simulating the most common types of loads. + void SendNavigateWithOriginalRequestURL( + int page_id, const GURL& url, const GURL& original_request_url); + + void SendNavigateWithFile( + int page_id, const GURL& url, const base::FilePath& file_path); + + void TestOnUpdateStateWithFile( + int process_id, const base::FilePath& file_path); + + void TestOnStartDragging(const DropData& drop_data); + + // If set, *delete_counter is incremented when this object destructs. + void set_delete_counter(int* delete_counter) { + delete_counter_ = delete_counter; + } + + // Sets whether the RenderView currently exists or not. This controls the + // return value from IsRenderViewLive, which the rest of the system uses to + // check whether the RenderView has crashed or not. + void set_render_view_created(bool created) { + render_view_created_ = created; + } + + // Returns whether the RenderViewHost is currently waiting to hear the result + // of a before unload handler from the renderer. + bool is_waiting_for_beforeunload_ack() const { + return is_waiting_for_beforeunload_ack_; + } + + // Returns whether the RenderViewHost is currently waiting to hear the result + // of an unload handler from the renderer. + bool is_waiting_for_unload_ack() const { + return is_waiting_for_unload_ack_; + } + + // Sets whether the RenderViewHost is currently swapped out, and thus + // filtering messages from the renderer. + void set_is_swapped_out(bool is_swapped_out) { + is_swapped_out_ = is_swapped_out; + } + + // If set, navigations will appear to have loaded through a proxy + // (ViewHostMsg_FrameNavigte_Params::was_fetched_via_proxy). + // False by default. + void set_simulate_fetch_via_proxy(bool proxy); + + // If set, navigations will appear to have cleared the history list in the + // RenderView (ViewHostMsg_FrameNavigate_Params::history_list_was_cleared). + // False by default. + void set_simulate_history_list_was_cleared(bool cleared); + + // The opener route id passed to CreateRenderView(). + int opener_route_id() const { return opener_route_id_; } + + // RenderViewHost overrides -------------------------------------------------- + + virtual bool CreateRenderView(const base::string16& frame_name, + int opener_route_id, + int32 max_page_id) OVERRIDE; + virtual bool IsRenderViewLive() const OVERRIDE; + + private: + FRIEND_TEST_ALL_PREFIXES(RenderViewHostTest, FilterNavigate); + + void SendNavigateWithTransitionAndResponseCode(int page_id, + const GURL& url, + PageTransition transition, + int response_code); + + // Calls OnNavigate on the RenderViewHost with the given information. + // Sets the rest of the parameters in the message to the "typical" values. + // This is a helper function for simulating the most common types of loads. + void SendNavigateWithParameters( + int page_id, + const GURL& url, + PageTransition transition, + const GURL& original_request_url, + int response_code, + const base::FilePath* file_path_for_history_item); + + // Tracks if the caller thinks if it created the RenderView. This is so we can + // respond to IsRenderViewLive appropriately. + bool render_view_created_; + + // See set_delete_counter() above. May be NULL. + int* delete_counter_; + + // See set_simulate_fetch_via_proxy() above. + bool simulate_fetch_via_proxy_; + + // See set_simulate_history_list_was_cleared() above. + bool simulate_history_list_was_cleared_; + + // See SetContentsMimeType() above. + std::string contents_mime_type_; + + // See opener_route_id() above. + int opener_route_id_; + + DISALLOW_COPY_AND_ASSIGN(TestRenderViewHost); +}; + +#if defined(COMPILER_MSVC) +#pragma warning(pop) +#endif + +// Adds methods to get straight at the impl classes. +class RenderViewHostImplTestHarness : public RenderViewHostTestHarness { + public: + RenderViewHostImplTestHarness(); + virtual ~RenderViewHostImplTestHarness(); + + TestRenderViewHost* test_rvh(); + TestRenderViewHost* pending_test_rvh(); + TestRenderViewHost* active_test_rvh(); + TestWebContents* contents(); + + private: + typedef scoped_ptr<ui::test::ScopedSetSupportedScaleFactors> + ScopedSetSupportedScaleFactors; + ScopedSetSupportedScaleFactors scoped_set_supported_scale_factors_; + DISALLOW_COPY_AND_ASSIGN(RenderViewHostImplTestHarness); +}; + +} // namespace content + +#endif // CONTENT_TEST_TEST_RENDER_VIEW_HOST_H_ |