Making EventSender talk to the right WebWidget (for OOPIF support).

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"
@@ skipping 23 matching lines @@
 #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/WebInputEvent.h"
+#include "third_party/WebKit/public/platform/WebRect.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/platform/scheduler/test/renderer_scheduler_test_support.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebView.h"
+#include "ui/events/blink/blink_event_util.h"
 #include "ui/gfx/icc_profile.h"
 
 #if defined(OS_MACOSX)
 #include "content/browser/frame_host/popup_menu_helper_mac.h"
 #elif defined(OS_WIN)
 #include "content/child/font_warmup_win.h"
 #include "third_party/WebKit/public/web/win/WebFontRendering.h"
 #include "third_party/skia/include/ports/SkFontMgr.h"
 #include "third_party/skia/include/ports/SkTypeface_win.h"
 #include "ui/gfx/win/direct_write.h"
@@ skipping 68 matching lines @@
 
 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;
 }
 
+float GetWindowToViewportScale(RenderWidget* render_widget) {
+  blink::WebFloatRect rect(0, 0, 1.0f, 0.0);
+  render_widget->convertWindowToViewport(&rect);
+  return rect.width;
+}
+
 #if defined(OS_WIN)
 // DirectWrite only has access to %WINDIR%\Fonts by default. For developer
 // side-loading, support kRegisterFontFiles to allow access to additional fonts.
 void RegisterSideloadedTypefaces(SkFontMgr* fontmgr) {
   std::vector<std::string> files = switches::GetSideloadFontFiles();
   for (std::vector<std::string>::const_iterator i(files.begin());
        i != files.end();
        ++i) {
     SkTypeface* typeface = fontmgr->createFromFile(i->c_str());
     blink::WebFontRendering::addSideloadedFontForTesting(typeface);
@@ skipping 10 matching lines @@
   return static_cast<test_runner::WebViewTestProxyBase*>(render_view_proxy);
 }
 
 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);
 }
 
+test_runner::WebWidgetTestProxyBase* GetWebWidgetTestProxyBase(
+    blink::WebLocalFrame* frame) {
+  DCHECK(frame);
+  RenderFrame* local_root = RenderFrame::FromWebFrame(frame->localRoot());
+  DCHECK(local_root);
+  // TODO(lfg): Simplify once RenderView no longer inherits from RenderWidget.
+  if (local_root->IsMainFrame()) {
+    test_runner::WebViewTestProxyBase* web_view_test_proxy_base =
+        GetWebViewTestProxyBase(local_root->GetRenderView());
+    auto* web_widget_test_proxy_base =
+        static_cast<test_runner::WebWidgetTestProxyBase*>(
+            web_view_test_proxy_base);
+    DCHECK(web_widget_test_proxy_base->web_widget()->isWebView());
+    return web_widget_test_proxy_base;
+  } else {
+    RenderWidget* render_widget =
+        static_cast<RenderFrameImpl*>(local_root)->GetRenderWidget();
+    DCHECK(render_widget);
+    WebWidgetTestProxyType* render_widget_proxy =
+        static_cast<WebWidgetTestProxyType*>(render_widget);
+    auto* web_widget_test_proxy_base =
+        static_cast<test_runner::WebWidgetTestProxyBase*>(render_widget_proxy);
+    DCHECK(web_widget_test_proxy_base->web_widget()->isWebFrameWidget());
+    return web_widget_test_proxy_base;
+  }
+}
+
+RenderWidget* GetRenderWidget(
+    test_runner::WebWidgetTestProxyBase* web_widget_test_proxy_base) {
+  DCHECK(web_widget_test_proxy_base);
+
+  blink::WebWidget* widget = web_widget_test_proxy_base->web_widget();
+  // TODO(lfg): Simplify once RenderView no longer inherits from RenderWidget.
+  if (widget->isWebView()) {
+    WebViewTestProxyType* render_view_proxy =
+        static_cast<WebViewTestProxyType*>(web_widget_test_proxy_base);
+    RenderViewImpl* render_view_impl =
+        static_cast<RenderViewImpl*>(render_view_proxy);
+    return render_view_impl;
+  } else if (widget->isWebFrameWidget()) {
+    WebWidgetTestProxyType* render_widget_proxy =
+        static_cast<WebWidgetTestProxyType*>(web_widget_test_proxy_base);
+    return static_cast<RenderWidget*>(render_widget_proxy);
+  } else {
+    NOTREACHED();
+    return nullptr;
+  }
+}
+
 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,
                                   RenderWidgetInitialized);
@@ skipping 208 matching lines @@
   RenderViewImpl* render_view_impl = static_cast<RenderViewImpl*>(render_view);
   render_view_impl->ForceResizeForTesting(new_size);
 }
 
 void SetDeviceScaleFactor(RenderView* render_view, float factor) {
   static_cast<RenderViewImpl*>(render_view)->
       SetDeviceScaleFactorForTesting(factor);
 }
 
 float GetWindowToViewportScale(RenderView* render_view) {
-  blink::WebFloatRect rect(0, 0, 1.0f, 0.0);
-  static_cast<RenderViewImpl*>(render_view)->convertWindowToViewport(&rect);
-  return rect.width;
+  return GetWindowToViewportScale(
+      static_cast<RenderViewImpl*>(render_view)->GetWidget());
+}
+
+std::unique_ptr<blink::WebInputEvent> TransformScreenToWidgetCoordinates(
+    test_runner::WebWidgetTestProxyBase* web_widget_test_proxy_base,
+    const blink::WebInputEvent& event) {
+  DCHECK(web_widget_test_proxy_base);
+  RenderWidget* render_widget = GetRenderWidget(web_widget_test_proxy_base);
+
+  blink::WebRect window_rect = render_widget->windowRect();
+  float scale = GetWindowToViewportScale(render_widget);
+  return ui::TranslateAndScaleWebInputEvent(event, -window_rect.x,
+                                            -window_rect.y, scale);
 }
 
 gfx::ICCProfile GetTestingICCProfile(const std::string& name) {
   const unsigned char rgb_profile_data[] = {
     0x00, 0x00, 0x07, 0xd8, 0x61, 0x70, 0x70, 0x6c, 0x02, 0x20, 0x00, 0x00,
     0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
     0x07, 0xd9, 0x00, 0x02, 0x00, 0x19, 0x00, 0x0b, 0x00, 0x1a, 0x00, 0x0b,
     0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4c, 0x00, 0x00, 0x00, 0x00,
     0x61, 0x70, 0x70, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
@@ skipping 626 matching lines @@
   return result;
 }
 
 void SchedulerRunIdleTasks(const base::Closure& callback) {
   blink::scheduler::RendererScheduler* scheduler =
       content::RenderThreadImpl::current()->GetRendererScheduler();
   blink::scheduler::RunIdleTasksForTesting(scheduler, callback);
 }
 
 }  // namespace content