Force a GuestView's embedder to be focused on TouchStart.

content/public/test/browser_test_utils.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/browser_test_utils.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 29 matching lines @@
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/test/python_utils.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
+#include "ui/events/latency_info.h"
 #include "ui/resources/grit/webui_resources.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/test/window_event_dispatcher_test_api.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #endif  // USE_AURA
 
 namespace content {
@@ skipping 364 matching lines @@
   blink::WebGestureEvent tap;
   tap.type = blink::WebGestureEvent::GestureTap;
   tap.x = point.x();
   tap.y = point.y();
   tap.modifiers = modifiers;
   RenderWidgetHostImpl* widget_host =
       RenderWidgetHostImpl::From(web_contents->GetRenderViewHost());
   widget_host->ForwardGestureEvent(tap);
 }
 
+void SimulateTouchPressAt(WebContents* web_contents, const gfx::Point& point) {
+  SyntheticWebTouchEvent touch;
+  touch.PressPoint(point.x(), point.y());
+  RenderWidgetHostImpl* widget_host =
+      RenderWidgetHostImpl::From(web_contents->GetRenderViewHost());

[nasko, 2015/06/22 08:40:53]

Why do a lookup when it can be retrieved directly. Wouldn't
web_contents->GetRenderWidgetHostView()->GetRenderWidgetHost() work? The same
pattern is present in a few places in this file.

[wjmaclean, 2015/06/22 13:39:44]

Everywhere else in this file when a RenderWidgetHostViewImpl is retrieved, it is
done using the same method I'm employing. In fact, I ran git gs on the entire
codebase and only found one instance of what you propose
(render_widget_host_view_browsertest.cc:99); it looks like

RenderWidgetHostImpl* const rwh = RenderWidgetHostImpl::From(
         shell()->web_contents()->GetRenderWidgetHostView()->                
             GetRenderWidgetHost());

Note: GetRenderWidgetHost() returns RenderWidgetHostView*, which still requires
conversion.

I can still change it if you like.

[nasko, 2015/06/22 14:05:49]

You mean RenderWidgetHost, not RenderWidgetHostView, correct? Just the public
interface, not the impl, which will require a cast, as you pointed in the code
snippet above.
 
No, it is fine, especially since the rest of the file uses the same pattern.

+  widget_host->ForwardTouchEventWithLatencyInfo(touch, ui::LatencyInfo());
+}
+
 void SimulateKeyPress(WebContents* web_contents,
                       ui::KeyboardCode key_code,
                       bool control,
                       bool shift,
                       bool alt,
                       bool command) {
   SimulateKeyPressWithCode(
       web_contents, key_code, NULL, control, shift, alt, command);
 }
 
@@ skipping 510 matching lines @@
 }
 
 bool WebContentsAddedObserver::RenderViewCreatedCalled() {
   if (child_observer_) {
     return child_observer_->render_view_created_called_ &&
            child_observer_->main_frame_created_called_;
   }
   return false;
 }
 
+bool RequestFrame(WebContents* web_contents) {
+  DCHECK(web_contents);
+  return RenderWidgetHostImpl::From(web_contents->GetRenderViewHost())
+      ->ScheduleComposite();
+}
+
 FrameWatcher::FrameWatcher()
     : BrowserMessageFilter(ViewMsgStart), frames_to_wait_(0) {
 }
 
 FrameWatcher::~FrameWatcher() {
 }
 
 void FrameWatcher::ReceivedFrameSwap() {
   --frames_to_wait_;
   if (frames_to_wait_ == 0)
     quit_.Run();
 }
 
 bool FrameWatcher::OnMessageReceived(const IPC::Message& message) {
   if (message.type() == ViewHostMsg_SwapCompositorFrame::ID) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&FrameWatcher::ReceivedFrameSwap, this));
   }
   return false;
 }
 
+void FrameWatcher::AttachTo(WebContents* web_contents) {
+  DCHECK(web_contents);
+  RenderWidgetHostImpl* widget_host =
+      RenderWidgetHostImpl::From(web_contents->GetRenderViewHost());
+  widget_host->GetProcess()->AddFilter(this);
+}
+
 void FrameWatcher::WaitFrames(int frames_to_wait) {
   if (frames_to_wait <= 0)
     return;
   base::RunLoop run_loop;
   base::AutoReset<base::Closure> reset_quit(&quit_, run_loop.QuitClosure());
   base::AutoReset<int> reset_frames_to_wait(&frames_to_wait_, frames_to_wait);
   run_loop.Run();
 }
 
 }  // namespace content