Add WebWidgetTestProxy.

content/test/layouttest_support.cc

Index: content/test/layouttest_support.cc
diff --git a/content/test/layouttest_support.cc b/content/test/layouttest_support.cc
index 7e2a5beb5701ccc01fd3b6d3b5f7b94693b22212..79e7a9a8bacd4149339d2bcbcc443acfa16a247b 100644
--- a/content/test/layouttest_support.cc
+++ b/content/test/layouttest_support.cc
@@ -19,6 +19,7 @@
 #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"
@@ -34,6 +35,7 @@
 #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"
@@ -68,6 +70,9 @@ 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;
 
@@ -75,6 +80,14 @@ 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&>;
@@ -89,6 +102,27 @@ RenderViewImpl* CreateWebViewTestProxy(CompositorDependencies* compositor_deps,
   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);
+  return render_widget_proxy;
+}
+
+void RenderWidgetCreated(RenderWidget* render_widget) {
+  WebWidgetTestProxyType* render_widget_proxy =
+      static_cast<WebWidgetTestProxyType*>(render_widget);
+  if (!(g_widget_test_proxy_callback == 0)) {

[Łukasz Anforowicz, 2016/08/11 17:19:28]

nit: I found the code for this condition a bit weird.  OTOH, now I realize that
LazyInstance only exposes ==, so one has to write |!(x != 0)| and cannot write
|x != 0| or |x|.  Still, let me propose 2 alternatives:

Alternative #1: !(g_widget_test_proxy_callback == nullptr)

Alternative #2: !g_widget_test_proxy_callback.Get().is_null()  // This "creates"
the LazyInstance, but checks if the callback it wraps was "set".

[lfg, 2016/08/11 19:49:39]

I agree that this isn't very nice. Looking at this code, I can't see any reason
to be using base::Callback/base::LazyInstance here. I switched to regular
function pointers, which simplifies the code and makes it more readable.

[jam, 2016/08/15 20:07:44]

if (!g_widget_test_proxy_callback.Get().is_null()))?

seems fine.

base::Callback is the standard way of holding on to method calls, so switching
to C function pointers seems unnecessary

+    g_widget_test_proxy_callback.Get().Run(render_widget->webwidget(),
+                                           render_widget_proxy);
+  }
+}
+
 RenderFrameImpl* CreateWebFrameTestProxy(
     const RenderFrameImpl::CreateParams& params) {
   WebFrameTestProxyType* render_frame_proxy = new WebFrameTestProxyType(params);
@@ -130,10 +164,14 @@ test_runner::WebFrameTestProxyBase* GetWebFrameTestProxyBase(
 
 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,
+                                  RenderWidgetCreated);
   RenderFrameImpl::InstallCreateHook(CreateWebFrameTestProxy);
 }