Test for BrowserPlugin-based WebView Focus

content/public/test/browser_test_utils.cc

Index: content/public/test/browser_test_utils.cc
diff --git a/content/public/test/browser_test_utils.cc b/content/public/test/browser_test_utils.cc
index 0de234dae34df88f010a4c3216cb70616e108045..f373a5c5123c43fd71057d3eb936bbdec4faee62 100644
--- a/content/public/test/browser_test_utils.cc
+++ b/content/public/test/browser_test_utils.cc
@@ -25,8 +25,10 @@
 #include "content/browser/accessibility/accessibility_mode_helper.h"
 #include "content/browser/accessibility/browser_accessibility.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
+#include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/browser/frame_host/render_widget_host_view_child_frame.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
@@ -1003,6 +1005,62 @@ ui::AXTreeUpdate GetAccessibilityTreeSnapshot(WebContents* web_contents) {
   return manager->SnapshotAXTreeForTesting();
 }
 
+bool IsWebContentsBrowserPluginFocused(content::WebContents* web_contents) {
+  WebContentsImpl* web_contents_impl =
+      static_cast<WebContentsImpl*>(web_contents);
+  BrowserPluginGuest* browser_plugin_guest =
+      web_contents_impl->GetBrowserPluginGuest();
+  return browser_plugin_guest ? browser_plugin_guest->focused() : false;
+}
+
+#if defined(USE_AURA)
+void SendRoutedTouchTapSequence(content::WebContents* web_contents,
+                                gfx::Point point) {
+  RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
+      web_contents->GetRenderWidgetHostView());
+  ui::TouchEvent touch_start(ui::ET_TOUCH_PRESSED, point, 0,
+                             base::TimeTicks::Now());
+  rwhva->OnTouchEvent(&touch_start);
+  ui::TouchEvent touch_end(ui::ET_TOUCH_RELEASED, point, 0,
+                           base::TimeTicks::Now());
+  rwhva->OnTouchEvent(&touch_end);
+}
+
+void SendRoutedGestureTapSequence(content::WebContents* web_contents,
+                                  gfx::Point point) {
+  RenderWidgetHostViewAura* rwhva = static_cast<RenderWidgetHostViewAura*>(
+      web_contents->GetRenderWidgetHostView());
+  ui::GestureEventDetails gesture_tap_down_details(ui::ET_GESTURE_TAP_DOWN);
+  gesture_tap_down_details.set_device_type(
+      ui::GestureDeviceType::DEVICE_TOUCHSCREEN);
+  ui::GestureEvent gesture_tap_down(point.x(), point.y(), 0,
+                                    base::TimeTicks::Now(),
+                                    gesture_tap_down_details);
+  rwhva->OnGestureEvent(&gesture_tap_down);
+  ui::GestureEventDetails gesture_tap_details(ui::ET_GESTURE_TAP);
+  gesture_tap_details.set_device_type(
+      ui::GestureDeviceType::DEVICE_TOUCHSCREEN);
+  gesture_tap_details.set_tap_count(1);
+  ui::GestureEvent gesture_tap(point.x(), point.y(), 0, base::TimeTicks::Now(),
+                               gesture_tap_details);
+  rwhva->OnGestureEvent(&gesture_tap);
+}
+#endif
+
+void WaitForSurfaceReady(content::WebContents* web_contents) {

[kenrb, 2016/07/05 14:30:57]

I know we talked about this earlier, but I don't remember if you looked into
whether SurfaceHitTestReadyNotifier can be moved to somewhere in
content/public/test, to make it available here and avoid having a parallel
mechanism for doing that. If it works correctly, your frame_count_ method is
simpler than how I was previously doing that, although it doesn't obviate the
need for a busy loop.

[wjmaclean, 2016/07/05 15:04:22]

Moving the SurfaceHitTestReady relies on a cc DEP which is currently not
exported to all browser tests, and it looks either like (i) a lot of work to
change that, or (possibly) *impossible* to do in our current setup. So I felt
this was simpler.

We *could* add a RenderWidgetHostViewBaseObserver callback to avoid the
wait-loop, but that seemed to me like a lot of overhead on every frame draw
(though we could just notify on the first frame draw for a given surface?) ...
there's also the problem of being sure to get the observer registered before the
frame gets incremented for the first time, so it would likely lead to a racy
test. This seemed a bit simpler, if not as elegant.

[kenrb, 2016/07/05 15:32:01]

If we change SurfaceHitTestReady to use surface_frame_count_ and work the same
as WaitForSurfaceReady, then could we get rid of the cc dependency and move it
to public? If that would work, it might be something for a later CL because we
would have to change all of the current sites where SurfaceHitTestReadyNotifier
is used.
Yes I've thought about this before, and I haven't found anything very clean for
doing that.

+  RenderWidgetHostViewChildFrame* child_view =
+      static_cast<RenderWidgetHostViewChildFrame*>(
+          web_contents->GetRenderWidgetHostView());
+  while (true) {
+    base::RunLoop run_loop;
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(), TestTimeouts::tiny_timeout());
+    run_loop.Run();
+    if (child_view->frame_count() > 0)
+      break;
+  }
+}
+
 TitleWatcher::TitleWatcher(WebContents* web_contents,
                            const base::string16& expected_title)
     : WebContentsObserver(web_contents),