Add WebWidgetTestProxy.

content/test/layouttest_support.cc

 // 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.
 
 #include "content/public/test/layouttest_support.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/test/pixel_test_output_surface.h"
 #include "cc/test/test_delegating_output_surface.h"
 #include "components/scheduler/test/renderer_scheduler_test_support.h"
 #include "components/test_runner/test_common.h"
 #include "components/test_runner/web_frame_test_proxy.h"
 #include "components/test_runner/web_view_test_proxy.h"
+#include "components/test_runner/web_widget_test_proxy.h"
 #include "content/browser/bluetooth/bluetooth_device_chooser_controller.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/public/common/page_state.h"
 #include "content/public/renderer/renderer_gamepad_provider.h"
 #include "content/renderer/fetchers/manifest_fetcher.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/history_entry.h"
 #include "content/renderer/history_serialization.h"
 #include "content/renderer/layout_test_dependencies.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
+#include "content/renderer/render_widget.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "content/shell/common/shell_switches.h"
 #include "gpu/ipc/service/image_transport_surface.h"
 #include "third_party/WebKit/public/platform/WebFloatRect.h"
 #include "third_party/WebKit/public/platform/WebGamepads.h"
 #include "third_party/WebKit/public/platform/modules/device_orientation/WebDeviceMotionData.h"
 #include "third_party/WebKit/public/platform/modules/device_orientation/WebDeviceOrientationData.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
@@ skipping 14 matching lines @@
 using blink::WebRect;
 using blink::WebSize;
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<ViewProxyCreationCallback>::Leaky
     g_view_test_proxy_callback = LAZY_INSTANCE_INITIALIZER;
 
+base::LazyInstance<WidgetProxyCreationCallback>::Leaky
+    g_widget_test_proxy_callback = LAZY_INSTANCE_INITIALIZER;
+
 base::LazyInstance<FrameProxyCreationCallback>::Leaky
     g_frame_test_proxy_callback = LAZY_INSTANCE_INITIALIZER;
 
 using WebViewTestProxyType =
     test_runner::WebViewTestProxy<RenderViewImpl,
                                   CompositorDependencies*,
                                   const ViewMsg_New_Params&>;
+using WebWidgetTestProxyType =
+    test_runner::WebWidgetTestProxy<RenderWidget,
+                                    CompositorDependencies*,
+                                    blink::WebPopupType,
+                                    const blink::WebScreenInfo&,
+                                    bool,
+                                    bool,
+                                    bool>;
 using WebFrameTestProxyType =
     test_runner::WebFrameTestProxy<RenderFrameImpl,
                                    const RenderFrameImpl::CreateParams&>;
 
 RenderViewImpl* CreateWebViewTestProxy(CompositorDependencies* compositor_deps,
                                        const ViewMsg_New_Params& params) {
   WebViewTestProxyType* render_view_proxy =
       new WebViewTestProxyType(compositor_deps, params);
   if (g_view_test_proxy_callback == 0)
     return render_view_proxy;
   g_view_test_proxy_callback.Get().Run(render_view_proxy, render_view_proxy);
   return render_view_proxy;
 }
 
+RenderWidget* CreateWebWidgetTestProxy(CompositorDependencies* compositor_deps,
+                                       blink::WebPopupType popup_type,
+                                       const blink::WebScreenInfo& screen_info,
+                                       bool swapped_out,
+                                       bool hidden,
+                                       bool never_visible) {
+  WebWidgetTestProxyType* render_widget_proxy =
+      new WebWidgetTestProxyType(compositor_deps, popup_type, screen_info,
+                                 swapped_out, hidden, never_visible);
+  if (g_widget_test_proxy_callback == 0)
+    return render_widget_proxy;
+  g_widget_test_proxy_callback.Get().Run(render_widget_proxy->web_widget(),
+                                         render_widget_proxy);
+  return render_widget_proxy;
+}
+
 RenderFrameImpl* CreateWebFrameTestProxy(
     const RenderFrameImpl::CreateParams& params) {
   WebFrameTestProxyType* render_frame_proxy = new WebFrameTestProxyType(params);
   if (g_frame_test_proxy_callback == 0)
     return render_frame_proxy;
   g_frame_test_proxy_callback.Get().Run(render_frame_proxy, render_frame_proxy);
   return render_frame_proxy;
 }
 
 #if defined(OS_WIN)
@@ skipping 21 matching lines @@
 
 test_runner::WebFrameTestProxyBase* GetWebFrameTestProxyBase(
     RenderFrame* render_frame) {
   WebFrameTestProxyType* render_frame_proxy =
       static_cast<WebFrameTestProxyType*>(render_frame);
   return static_cast<test_runner::WebFrameTestProxyBase*>(render_frame_proxy);
 }
 
 void EnableWebTestProxyCreation(
     const ViewProxyCreationCallback& view_proxy_creation_callback,
+    const WidgetProxyCreationCallback& widget_proxy_creation_callback,
     const FrameProxyCreationCallback& frame_proxy_creation_callback) {
   g_view_test_proxy_callback.Get() = view_proxy_creation_callback;
+  g_widget_test_proxy_callback.Get() = widget_proxy_creation_callback;
   g_frame_test_proxy_callback.Get() = frame_proxy_creation_callback;
   RenderViewImpl::InstallCreateHook(CreateWebViewTestProxy);
+  RenderWidget::InstallCreateHook(CreateWebWidgetTestProxy);
   RenderFrameImpl::InstallCreateHook(CreateWebFrameTestProxy);
 }
 
 void FetchManifestDoneCallback(std::unique_ptr<ManifestFetcher> fetcher,
                                const FetchManifestCallback& callback,
                                const blink::WebURLResponse& response,
                                const std::string& data) {
   // |fetcher| will be autodeleted here as it is going out of scope.
   callback.Run(response, data);
 }
@@ skipping 422 matching lines @@
   return result;
 }
 
 void SchedulerRunIdleTasks(const base::Closure& callback) {
     scheduler::RendererScheduler* scheduler =
         content::RenderThreadImpl::current()->GetRendererScheduler();
     scheduler::RunIdleTasksForTesting(scheduler, callback);
 }
 
 }  // namespace content