Plumb firing passive event listeners.

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 <stddef.h>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/process/kill.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/values.h"
 #include "build/build_config.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"
 #include "content/common/input/synthetic_web_input_event_builders.h"
+#include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/histogram_fetcher.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 1028 matching lines @@
       ->ScheduleComposite();
 }
 
 FrameWatcher::FrameWatcher()
     : BrowserMessageFilter(ViewMsgStart), frames_to_wait_(0) {
 }
 
 FrameWatcher::~FrameWatcher() {
 }
 
-void FrameWatcher::ReceivedFrameSwap() {
+void FrameWatcher::ReceivedFrameSwap(cc::CompositorFrameMetadata metadata) {
   --frames_to_wait_;
+  last_metadata_ = metadata;
   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));
+    ViewHostMsg_SwapCompositorFrame::Param param;
+    if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
+      return false;
+    scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+    base::get<1>(param).AssignTo(frame.get());
+
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&FrameWatcher::ReceivedFrameSwap, this, frame->metadata));
   }
   return false;
 }
 
 void FrameWatcher::AttachTo(WebContents* web_contents) {
   DCHECK(web_contents);
   RenderWidgetHostImpl* widget_host = RenderWidgetHostImpl::From(
       web_contents->GetRenderViewHost()->GetWidget());
   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();
 }
 
+const cc::CompositorFrameMetadata& FrameWatcher::LastMetadata() {
+  return last_metadata_;
+}
+
 MainThreadFrameObserver::MainThreadFrameObserver(
     RenderWidgetHost* render_widget_host)
     : render_widget_host_(render_widget_host),
       routing_id_(render_widget_host_->GetProcess()->GetNextRoutingID()) {
   // TODO(lfg): We should look into adding a way to observe RenderWidgetHost
   // messages similarly to what WebContentsObserver can do with RFH and RVW.
   render_widget_host_->GetProcess()->AddRoute(routing_id_, this);
 }
 
 MainThreadFrameObserver::~MainThreadFrameObserver() {
@@ skipping 17 matching lines @@
 bool MainThreadFrameObserver::OnMessageReceived(const IPC::Message& msg) {
   if (msg.type() == ViewHostMsg_WaitForNextFrameForTests_ACK::ID &&
       msg.routing_id() == routing_id_) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&MainThreadFrameObserver::Quit, base::Unretained(this)));
   }
   return true;
 }
 
+InputMsgWatcher::InputMsgWatcher(RenderWidgetHost* render_widget_host,
+                                 blink::WebInputEvent::Type type)
+    : BrowserMessageFilter(InputMsgStart),
+      wait_for_type_(type),
+      ack_result_(INPUT_EVENT_ACK_STATE_UNKNOWN) {
+  render_widget_host->GetProcess()->AddFilter(this);
+}
+
+InputMsgWatcher::~InputMsgWatcher() {}
+
+void InputMsgWatcher::ReceivedAck(blink::WebInputEvent::Type ack_type,

[Charlie Reis, 2016/02/16 22:25:22]

Can you add some DCHECKs for which threads you expect these various methods to
run on?  The PostTask indicates that it's non-obvious.

[dtapuska, 2016/02/17 03:34:57]

Done.

+                                  uint32_t ack_state) {
+  if (wait_for_type_ == ack_type) {
+    ack_result_ = ack_state;
+    if (!quit_.is_null())
+      quit_.Run();
+  }
+}
+
+bool InputMsgWatcher::OnMessageReceived(const IPC::Message& message) {
+  if (message.type() == InputHostMsg_HandleInputEvent_ACK::ID) {
+    InputHostMsg_HandleInputEvent_ACK::Param params;
+    InputHostMsg_HandleInputEvent_ACK::Read(&message, &params);
+    blink::WebInputEvent::Type ack_type = base::get<0>(params).type;
+    InputEventAckState ack_state = base::get<0>(params).state;
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&InputMsgWatcher::ReceivedAck, this, ack_type, ack_state));
+  }
+  return false;
+}
+
+uint32_t InputMsgWatcher::WaitForAck() {
+  if (ack_result_ != INPUT_EVENT_ACK_STATE_UNKNOWN)
+    return ack_result_;
+  base::RunLoop run_loop;
+  base::AutoReset<base::Closure> reset_quit(&quit_, run_loop.QuitClosure());
+  run_loop.Run();
+  return ack_result_;
+}
+
 }  // namespace content