Log First User Interaction in Page Load Metrics

content/browser/renderer_host/render_widget_host_impl.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/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 
 #include <set>
 #include <utility>
@@ skipping 93 matching lines @@
 using RoutingIDWidgetMap =
     base::hash_map<RenderWidgetHostID, RenderWidgetHostImpl*>;
 base::LazyInstance<RoutingIDWidgetMap> g_routing_id_widget_map =
     LAZY_INSTANCE_INITIALIZER;
 
 // Implements the RenderWidgetHostIterator interface. It keeps a list of
 // RenderWidgetHosts, and makes sure it returns a live RenderWidgetHost at each
 // iteration (or NULL if there isn't any left).
 class RenderWidgetHostIteratorImpl : public RenderWidgetHostIterator {
  public:
-  RenderWidgetHostIteratorImpl()
-      : current_index_(0) {
-  }
+  RenderWidgetHostIteratorImpl() : current_index_(0) {}
 
   ~RenderWidgetHostIteratorImpl() override {}
 
   void Add(RenderWidgetHost* host) {
-    hosts_.push_back(RenderWidgetHostID(host->GetProcess()->GetID(),
-                                        host->GetRoutingID()));
+    hosts_.push_back(
+        RenderWidgetHostID(host->GetProcess()->GetID(), host->GetRoutingID()));
   }
 
   // RenderWidgetHostIterator:
   RenderWidgetHost* GetNextHost() override {
     RenderWidgetHost* host = NULL;
     while (current_index_ < hosts_.size() && !host) {
       RenderWidgetHostID id = hosts_[current_index_];
       host = RenderWidgetHost::FromID(id.first, id.second);
       ++current_index_;
     }
@@ skipping 89 matching lines @@
   CHECK(result.second) << "Inserting a duplicate item!";
   process_->AddRoute(routing_id_, this);
 
   // If we're initially visible, tell the process host that we're alive.
   // Otherwise we'll notify the process host when we are first shown.
   if (!hidden)
     process_->WidgetRestored();
 
   latency_tracker_.Initialize(routing_id_, GetProcess()->GetID());
 
-  input_router_.reset(new InputRouterImpl(
-      process_->GetImmediateSender(), this, this, routing_id_,
-      GetInputRouterConfigForPlatform()));
+  input_router_.reset(new InputRouterImpl(process_, this, this, routing_id_,
+                                          GetInputRouterConfigForPlatform()));
 
   touch_emulator_.reset();
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHangMonitor)) {
     hang_monitor_timeout_.reset(new TimeoutMonitor(
         base::Bind(&RenderWidgetHostImpl::RendererIsUnresponsive,
                    weak_factory_.GetWeakPtr())));
   }
 
   new_content_rendering_timeout_.reset(new TimeoutMonitor(
       base::Bind(&RenderWidgetHostImpl::ClearDisplayedGraphics,
                  weak_factory_.GetWeakPtr())));
 
   delegate_->RenderWidgetCreated(this);
 }
 
 RenderWidgetHostImpl::~RenderWidgetHostImpl() {
   if (!destroyed_)
     Destroy(false);
 }
 
 // static
-RenderWidgetHost* RenderWidgetHost::FromID(
-    int32_t process_id,
-    int32_t routing_id) {
+RenderWidgetHost* RenderWidgetHost::FromID(int32_t process_id,
+                                           int32_t routing_id) {
   return RenderWidgetHostImpl::FromID(process_id, routing_id);
 }
 
 // static
-RenderWidgetHostImpl* RenderWidgetHostImpl::FromID(
-    int32_t process_id,
-    int32_t routing_id) {
+RenderWidgetHostImpl* RenderWidgetHostImpl::FromID(int32_t process_id,
+                                                   int32_t routing_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer();
-  RoutingIDWidgetMap::iterator it = widgets->find(
-      RenderWidgetHostID(process_id, routing_id));
+  RoutingIDWidgetMap::iterator it =
+      widgets->find(RenderWidgetHostID(process_id, routing_id));
   return it == widgets->end() ? NULL : it->second;
 }
 
 // static
 std::unique_ptr<RenderWidgetHostIterator>
 RenderWidgetHost::GetRenderWidgetHosts() {
   std::unique_ptr<RenderWidgetHostIteratorImpl> hosts(
       new RenderWidgetHostIteratorImpl());
   for (auto& it : g_routing_id_widget_map.Get()) {
     RenderWidgetHost* widget = it.second;
@@ skipping 52 matching lines @@
   return routing_id_;
 }
 
 RenderWidgetHostViewBase* RenderWidgetHostImpl::GetView() const {
   return view_.get();
 }
 
 void RenderWidgetHostImpl::ResetSizeAndRepaintPendingFlags() {
   resize_ack_pending_ = false;
   if (repaint_ack_pending_) {
-    TRACE_EVENT_ASYNC_END0(
-        "renderer_host", "RenderWidgetHostImpl::repaint_ack_pending_", this);
+    TRACE_EVENT_ASYNC_END0("renderer_host",
+                           "RenderWidgetHostImpl::repaint_ack_pending_", this);
   }
   repaint_ack_pending_ = false;
   if (old_resize_params_)
     old_resize_params_->new_size = gfx::Size();
 }
 
 void RenderWidgetHostImpl::SendScreenRects() {
   if (!renderer_initialized_ || waiting_for_screen_rects_ack_)
     return;
 
   if (is_hidden_) {
     // On GTK, this comes in for backgrounded tabs. Ignore, to match what
     // happens on Win & Mac, and when the view is shown it'll call this again.
     return;
   }
 
   if (!view_)
     return;
 
   last_view_screen_rect_ = view_->GetViewBounds();
   last_window_screen_rect_ = view_->GetBoundsInRootWindow();
-  Send(new ViewMsg_UpdateScreenRects(
-      GetRoutingID(), last_view_screen_rect_, last_window_screen_rect_));
+  Send(new ViewMsg_UpdateScreenRects(GetRoutingID(), last_view_screen_rect_,
+                                     last_window_screen_rect_));
   waiting_for_screen_rects_ack_ = true;
 }
 
 void RenderWidgetHostImpl::SuppressNextCharEvents() {
   suppress_next_char_events_ = true;
 }
 
 void RenderWidgetHostImpl::FlushInput() {
   input_router_->RequestNotificationWhenFlushed();
   if (synthetic_gesture_controller_)
@@ skipping 38 matching lines @@
     DCHECK(rv);
   }
 
   Destroy(also_delete);
 }
 
 bool RenderWidgetHostImpl::IsLoading() const {
   return is_loading_;
 }
 
-bool RenderWidgetHostImpl::OnMessageReceived(const IPC::Message &msg) {
+bool RenderWidgetHostImpl::OnMessageReceived(const IPC::Message& msg) {
   // Only process messages if the RenderWidget is alive.
   if (!renderer_initialized())
     return false;
 
   if (owner_delegate_ && owner_delegate_->OnMessageReceived(msg))
     return true;
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostImpl, msg)
     IPC_MESSAGE_HANDLER(FrameHostMsg_RenderProcessGone, OnRenderProcessGone)
@@ skipping 67 matching lines @@
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   Send(new ViewMsg_WasHidden(routing_id_));
 
   // Tell the RenderProcessHost we were hidden.
   process_->WidgetHidden();
 
   bool is_visible = false;
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      Source<RenderWidgetHost>(this),
-      Details<bool>(&is_visible));
+      Source<RenderWidgetHost>(this), Details<bool>(&is_visible));
 }
 
 void RenderWidgetHostImpl::WasShown(const ui::LatencyInfo& latency_info) {
   if (!is_hidden_)
     return;
 
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::WasShown");
   is_hidden_ = false;
 
   SendScreenRects();
 
   // When hidden, timeout monitoring for input events is disabled. Restore it
   // now to ensure consistent hang detection.
   if (in_flight_event_count_)
     RestartHangMonitorTimeout();
 
   // Always repaint on restore.
   bool needs_repainting = true;
   needs_repainting_on_restore_ = false;
   Send(new ViewMsg_WasShown(routing_id_, needs_repainting, latency_info));
 
   process_->WidgetRestored();
 
   bool is_visible = true;
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      Source<RenderWidgetHost>(this),
-      Details<bool>(&is_visible));
+      Source<RenderWidgetHost>(this), Details<bool>(&is_visible));
 
   // It's possible for our size to be out of sync with the renderer. The
   // following is one case that leads to this:
   // 1. WasResized -> Send ViewMsg_Resize to render
   // 2. WasResized -> do nothing as resize_ack_pending_ is true
   // 3. WasHidden
   // 4. OnUpdateRect from (1) processed. Does NOT invoke WasResized as view
   //    is hidden. Now renderer/browser out of sync with what they think size
   //    is.
   // By invoking WasResized the renderer is updated as necessary. WasResized
@@ skipping 27 matching lines @@
     resize_params->top_controls_shrink_blink_size =
         view_->DoTopControlsShrinkBlinkSize();
     resize_params->visible_viewport_size = view_->GetVisibleViewportSize();
   }
 
   const bool size_changed =
       !old_resize_params_ ||
       old_resize_params_->new_size != resize_params->new_size ||
       (old_resize_params_->physical_backing_size.IsEmpty() &&
        !resize_params->physical_backing_size.IsEmpty());
-  bool dirty = size_changed ||
+  bool dirty =
+      size_changed ||
       old_resize_params_->screen_info != resize_params->screen_info ||
       old_resize_params_->physical_backing_size !=
           resize_params->physical_backing_size ||
       old_resize_params_->is_fullscreen_granted !=
           resize_params->is_fullscreen_granted ||
       old_resize_params_->display_mode != resize_params->display_mode ||
       old_resize_params_->top_controls_height !=
           resize_params->top_controls_height ||
       old_resize_params_->top_controls_shrink_blink_size !=
           resize_params->top_controls_shrink_blink_size ||
@@ skipping 39 matching lines @@
     resize_ack_pending_ = params->needs_resize_ack;
     old_resize_params_.swap(params);
   }
 
   if (delegate_)
     delegate_->RenderWidgetWasResized(this, width_changed);
 }
 
 void RenderWidgetHostImpl::DispatchColorProfile() {
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
-  static bool image_profiles = base::CommandLine::ForCurrentProcess()->
-     HasSwitch(switches::kEnableImageColorProfiles);
+  static bool image_profiles =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableImageColorProfiles);
   if (!image_profiles)
     return;
 #if defined(OS_WIN)
   // Windows will read disk to get the color profile data if needed, so
   // dispatch the SendColorProfile() work off the UI thread.
   BrowserThread::PostBlockingPoolTask(
-      FROM_HERE,
-      base::Bind(&RenderWidgetHostImpl::SendColorProfile,
-                 weak_factory_.GetWeakPtr()));
+      FROM_HERE, base::Bind(&RenderWidgetHostImpl::SendColorProfile,
+                            weak_factory_.GetWeakPtr()));
 #elif !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
   // Only support desktop Mac and Linux at this time.
   SendColorProfile();
 #endif
 #endif
 }
 
 void RenderWidgetHostImpl::SendColorProfile() {
   if (!view_ || !delegate_)
     return;
@@ skipping 83 matching lines @@
   // eliminate this function if so.
   SetView(NULL);
 }
 
 void RenderWidgetHostImpl::CopyFromBackingStore(
     const gfx::Rect& src_subrect,
     const gfx::Size& accelerated_dst_size,
     const ReadbackRequestCallback& callback,
     const SkColorType preferred_color_type) {
   if (view_) {
-    TRACE_EVENT0("browser",
+    TRACE_EVENT0(
+        "browser",
         "RenderWidgetHostImpl::CopyFromBackingStore::FromCompositingSurface");
-    gfx::Rect accelerated_copy_rect = src_subrect.IsEmpty() ?
-        gfx::Rect(view_->GetViewBounds().size()) : src_subrect;
+    gfx::Rect accelerated_copy_rect =
+        src_subrect.IsEmpty() ? gfx::Rect(view_->GetViewBounds().size())
+                              : src_subrect;
     view_->CopyFromCompositingSurface(accelerated_copy_rect,
                                       accelerated_dst_size, callback,
                                       preferred_color_type);
     return;
   }
 
   callback.Run(SkBitmap(), content::READBACK_FAILED);
 }
 
 bool RenderWidgetHostImpl::CanCopyFromBackingStore() {
   if (view_)
     return view_->IsSurfaceAvailableForCopy();
   return false;
 }
 
 void RenderWidgetHostImpl::LockBackingStore() {
   if (view_)
     view_->LockCompositingSurface();
 }
 
 void RenderWidgetHostImpl::UnlockBackingStore() {
   if (view_)
     view_->UnlockCompositingSurface();
 }
 
 #if defined(OS_MACOSX)
 void RenderWidgetHostImpl::PauseForPendingResizeOrRepaints() {
   TRACE_EVENT0("browser",
-      "RenderWidgetHostImpl::PauseForPendingResizeOrRepaints");
+               "RenderWidgetHostImpl::PauseForPendingResizeOrRepaints");
 
   if (!CanPauseForPendingResizeOrRepaints())
     return;
 
   WaitForSurface();
 }
 
 bool RenderWidgetHostImpl::CanPauseForPendingResizeOrRepaints() {
   // Do not pause if the view is hidden.
   if (is_hidden())
@@ skipping 20 matching lines @@
   // UpdateRect messages.)
   gfx::Size view_size = current_size_;
   if (!auto_resize_enabled_) {
     // Get the desired size from the current view bounds.
     gfx::Rect view_rect = view_->GetViewBounds();
     if (view_rect.IsEmpty())
       return;
     view_size = view_rect.size();
   }
 
-  TRACE_EVENT2("renderer_host",
-               "RenderWidgetHostImpl::WaitForSurface",
-               "width",
-               base::IntToString(view_size.width()),
-               "height",
+  TRACE_EVENT2("renderer_host", "RenderWidgetHostImpl::WaitForSurface", "width",
+               base::IntToString(view_size.width()), "height",
                base::IntToString(view_size.height()));
 
   // We should not be asked to paint while we are hidden.  If we are hidden,
   // then it means that our consumer failed to call WasShown.
   DCHECK(!is_hidden_) << "WaitForSurface called while hidden!";
 
   // We should never be called recursively; this can theoretically lead to
   // infinite recursion and almost certainly leads to lower performance.
   DCHECK(!in_get_backing_store_) << "WaitForSurface called recursively!";
-  base::AutoReset<bool> auto_reset_in_get_backing_store(
-      &in_get_backing_store_, true);
+  base::AutoReset<bool> auto_reset_in_get_backing_store(&in_get_backing_store_,
+                                                        true);
 
   // We might have a surface that we can use already.
   if (view_->HasAcceleratedSurface(view_size))
     return;
 
   // Request that the renderer produce a frame of the right size, if it
   // hasn't been requested already.
   if (!repaint_ack_pending_ && !resize_ack_pending_) {
     repaint_start_time_ = TimeTicks::Now();
     repaint_ack_pending_ = true;
@@ skipping 28 matching lines @@
 
 bool RenderWidgetHostImpl::ScheduleComposite() {
   if (is_hidden_ || current_size_.IsEmpty() || repaint_ack_pending_ ||
       resize_ack_pending_) {
     return false;
   }
 
   // Send out a request to the renderer to paint the view if required.
   repaint_start_time_ = TimeTicks::Now();
   repaint_ack_pending_ = true;
-  TRACE_EVENT_ASYNC_BEGIN0(
-      "renderer_host", "RenderWidgetHostImpl::repaint_ack_pending_", this);
+  TRACE_EVENT_ASYNC_BEGIN0("renderer_host",
+                           "RenderWidgetHostImpl::repaint_ack_pending_", this);
   Send(new ViewMsg_Repaint(routing_id_, current_size_));
   return true;
 }
 
 void RenderWidgetHostImpl::StartHangMonitorTimeout(base::TimeDelta delay) {
   if (hang_monitor_timeout_)
     hang_monitor_timeout_->Start(delay);
 }
 
 void RenderWidgetHostImpl::RestartHangMonitorTimeout() {
@@ skipping 35 matching lines @@
     delegate_->OnFirstPaintAfterLoad(this);
 }
 
 void RenderWidgetHostImpl::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
   ForwardMouseEventWithLatencyInfo(mouse_event, ui::LatencyInfo());
   if (owner_delegate_)
     owner_delegate_->RenderWidgetDidForwardMouseEvent(mouse_event);
 }
 
 void RenderWidgetHostImpl::ForwardMouseEventWithLatencyInfo(
-      const blink::WebMouseEvent& mouse_event,
-      const ui::LatencyInfo& ui_latency) {
-  TRACE_EVENT2("input", "RenderWidgetHostImpl::ForwardMouseEvent",
-               "x", mouse_event.x, "y", mouse_event.y);
+    const blink::WebMouseEvent& mouse_event,
+    const ui::LatencyInfo& ui_latency) {
+  TRACE_EVENT2("input", "RenderWidgetHostImpl::ForwardMouseEvent", "x",
+               mouse_event.x, "y", mouse_event.y);
 
   for (size_t i = 0; i < mouse_event_callbacks_.size(); ++i) {
     if (mouse_event_callbacks_[i].Run(mouse_event))
       return;
   }
 
   if (ShouldDropInputEvents())
     return;
 
   if (touch_emulator_ && touch_emulator_->HandleMouseEvent(mouse_event))
     return;
 
   MouseEventWithLatencyInfo mouse_with_latency(mouse_event, ui_latency);
   latency_tracker_.OnInputEvent(mouse_event, &mouse_with_latency.latency);
   input_router_->SendMouseEvent(mouse_with_latency);
+  FOR_EACH_OBSERVER(InputEventObserver, input_event_observers_,
+                    OnInputEvent(mouse_event));
 }
 
 void RenderWidgetHostImpl::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   ForwardWheelEventWithLatencyInfo(wheel_event, ui::LatencyInfo());
 }
 
 void RenderWidgetHostImpl::ForwardWheelEventWithLatencyInfo(
-      const blink::WebMouseWheelEvent& wheel_event,
-      const ui::LatencyInfo& ui_latency) {
-  TRACE_EVENT2("input", "RenderWidgetHostImpl::ForwardWheelEvent",
-               "dx", wheel_event.deltaX, "dy", wheel_event.deltaY);
+    const blink::WebMouseWheelEvent& wheel_event,
+    const ui::LatencyInfo& ui_latency) {
+  TRACE_EVENT2("input", "RenderWidgetHostImpl::ForwardWheelEvent", "dx",
+               wheel_event.deltaX, "dy", wheel_event.deltaY);
 
   if (ShouldDropInputEvents())
     return;
 
   if (touch_emulator_ && touch_emulator_->HandleMouseWheelEvent(wheel_event))
     return;
 
   MouseWheelEventWithLatencyInfo wheel_with_latency(wheel_event, ui_latency);
   latency_tracker_.OnInputEvent(wheel_event, &wheel_with_latency.latency);
   input_router_->SendWheelEvent(wheel_with_latency);
+  FOR_EACH_OBSERVER(InputEventObserver, input_event_observers_,
+                    OnInputEvent(wheel_event));
 }
 
 void RenderWidgetHostImpl::ForwardEmulatedGestureEvent(
     const blink::WebGestureEvent& gesture_event) {
   ForwardGestureEvent(gesture_event);
 }
 
 void RenderWidgetHostImpl::ForwardGestureEvent(
     const blink::WebGestureEvent& gesture_event) {
   ForwardGestureEventWithLatencyInfo(gesture_event, ui::LatencyInfo());
@@ skipping 36 matching lines @@
         CreateScrollBeginForWrapping(gesture_event), ui::LatencyInfo());
   }
 
   // Delegate must be non-null, due to |ShouldDropInputEvents()| test.
   if (delegate_->PreHandleGestureEvent(gesture_event))
     return;
 
   GestureEventWithLatencyInfo gesture_with_latency(gesture_event, ui_latency);
   latency_tracker_.OnInputEvent(gesture_event, &gesture_with_latency.latency);
   input_router_->SendGestureEvent(gesture_with_latency);
+  FOR_EACH_OBSERVER(InputEventObserver, input_event_observers_,
+                    OnInputEvent(gesture_event));
 
   if (scroll_update_needs_wrapping) {
     ForwardGestureEventWithLatencyInfo(
         CreateScrollEndForWrapping(gesture_event), ui::LatencyInfo());
   }
 }
 
 void RenderWidgetHostImpl::ForwardEmulatedTouchEvent(
-      const blink::WebTouchEvent& touch_event) {
+    const blink::WebTouchEvent& touch_event) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardEmulatedTouchEvent");
 
   TouchEventWithLatencyInfo touch_with_latency(touch_event);
   latency_tracker_.OnInputEvent(touch_event, &touch_with_latency.latency);
   input_router_->SendTouchEvent(touch_with_latency);
+  FOR_EACH_OBSERVER(InputEventObserver, input_event_observers_,
+                    OnInputEvent(touch_event));
 }
 
 void RenderWidgetHostImpl::ForwardTouchEventWithLatencyInfo(
-      const blink::WebTouchEvent& touch_event,
-      const ui::LatencyInfo& ui_latency) {
+    const blink::WebTouchEvent& touch_event,
+    const ui::LatencyInfo& ui_latency) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardTouchEvent");
 
   // Always forward TouchEvents for touch stream consistency. They will be
   // ignored if appropriate in FilterInputEvent().
 
   TouchEventWithLatencyInfo touch_with_latency(touch_event, ui_latency);
   if (touch_emulator_ &&
       touch_emulator_->HandleTouchEvent(touch_with_latency.event)) {
     if (view_) {
-      view_->ProcessAckedTouchEvent(
-          touch_with_latency, INPUT_EVENT_ACK_STATE_CONSUMED);
+      view_->ProcessAckedTouchEvent(touch_with_latency,
+                                    INPUT_EVENT_ACK_STATE_CONSUMED);
     }
     return;
   }
 
   latency_tracker_.OnInputEvent(touch_event, &touch_with_latency.latency);
   input_router_->SendTouchEvent(touch_with_latency);
+  FOR_EACH_OBSERVER(InputEventObserver, input_event_observers_,
+                    OnInputEvent(touch_event));
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardKeyboardEvent");
   if (owner_delegate_ &&
       !owner_delegate_->MayRenderWidgetForwardKeyboardEvent(key_event)) {
     return;
   }
 
@@ skipping 49 matching lines @@
       suppress_next_char_events_ = false;
   }
 
   if (touch_emulator_ && touch_emulator_->HandleKeyboardEvent(key_event))
     return;
 
   NativeWebKeyboardEventWithLatencyInfo key_event_with_latency(key_event);
   key_event_with_latency.event.isBrowserShortcut = is_shortcut;
   latency_tracker_.OnInputEvent(key_event, &key_event_with_latency.latency);
   input_router_->SendKeyboardEvent(key_event_with_latency);
+  FOR_EACH_OBSERVER(InputEventObserver, input_event_observers_,
+                    OnInputEvent(key_event));
 }
 
 void RenderWidgetHostImpl::QueueSyntheticGesture(
     std::unique_ptr<SyntheticGesture> synthetic_gesture,
     const base::Callback<void(SyntheticGesture::Result)>& on_complete) {
   if (!synthetic_gesture_controller_ && view_) {
     synthetic_gesture_controller_.reset(
         new SyntheticGestureController(view_->CreateSyntheticGestureTarget()));
   }
   if (synthetic_gesture_controller_) {
     synthetic_gesture_controller_->QueueSyntheticGesture(
         std::move(synthetic_gesture), on_complete);
   }
 }
 
 void RenderWidgetHostImpl::SetCursor(const WebCursor& cursor) {
   if (!view_)
     return;
   view_->UpdateCursor(cursor);
 }
 
 void RenderWidgetHostImpl::ShowContextMenuAtPoint(const gfx::Point& point) {
-  Send(new ViewMsg_ShowContextMenu(
-      GetRoutingID(), ui::MENU_SOURCE_MOUSE, point));
+  Send(new ViewMsg_ShowContextMenu(GetRoutingID(), ui::MENU_SOURCE_MOUSE,
+                                   point));
 }
 
 void RenderWidgetHostImpl::SendCursorVisibilityState(bool is_visible) {
   Send(new InputMsg_CursorVisibilityChange(GetRoutingID(), is_visible));
 }
 
 int64_t RenderWidgetHostImpl::GetLatencyComponentId() const {
   return latency_tracker_.latency_component_id();
 }
 
 // static
 void RenderWidgetHostImpl::DisableResizeAckCheckForTesting() {
   g_check_for_pending_resize_ack = false;
 }
 
 void RenderWidgetHostImpl::AddKeyPressEventCallback(
     const KeyPressEventCallback& callback) {
   key_press_event_callbacks_.push_back(callback);
 }
 
 void RenderWidgetHostImpl::RemoveKeyPressEventCallback(
     const KeyPressEventCallback& callback) {
   for (size_t i = 0; i < key_press_event_callbacks_.size(); ++i) {
     if (key_press_event_callbacks_[i].Equals(callback)) {
-      key_press_event_callbacks_.erase(
-          key_press_event_callbacks_.begin() + i);
+      key_press_event_callbacks_.erase(key_press_event_callbacks_.begin() + i);
       return;
     }
   }
 }
 
 void RenderWidgetHostImpl::AddMouseEventCallback(
     const MouseEventCallback& callback) {
   mouse_event_callbacks_.push_back(callback);
 }
 
 void RenderWidgetHostImpl::RemoveMouseEventCallback(
     const MouseEventCallback& callback) {
   for (size_t i = 0; i < mouse_event_callbacks_.size(); ++i) {
     if (mouse_event_callbacks_[i].Equals(callback)) {
       mouse_event_callbacks_.erase(mouse_event_callbacks_.begin() + i);
       return;
     }
   }
 }
 
+void RenderWidgetHostImpl::AddInputEventObserver(
+    RenderWidgetHost::InputEventObserver* observer) {
+  input_event_observers_.AddObserver(observer);
+}
+
+void RenderWidgetHostImpl::RemoveInputEventObserver(
+    RenderWidgetHost::InputEventObserver* observer) {
+  input_event_observers_.RemoveObserver(observer);
+}
+
 void RenderWidgetHostImpl::GetWebScreenInfo(blink::WebScreenInfo* result) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::GetWebScreenInfo");
   if (view_)
     view_->GetScreenInfo(result);
   else
     RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
   // TODO(sievers): find a way to make this done another way so the method
   // can be const.
   latency_tracker_.set_device_scale_factor(result->deviceScaleFactor);
   if (IsUseZoomForDSFEnabled())
@@ skipping 26 matching lines @@
   WasResized();
 }
 
 void RenderWidgetHostImpl::GetSnapshotFromBrowser(
     const GetSnapshotFromBrowserCallback& callback) {
   int id = next_browser_snapshot_id_++;
   pending_browser_snapshots_.insert(std::make_pair(id, callback));
   Send(new ViewMsg_ForceRedraw(GetRoutingID(), id));
 }
 
-const NativeWebKeyboardEvent*
-    RenderWidgetHostImpl::GetLastKeyboardEvent() const {
+const NativeWebKeyboardEvent* RenderWidgetHostImpl::GetLastKeyboardEvent()
+    const {
   return input_router_->GetLastKeyboardEvent();
 }
 
 void RenderWidgetHostImpl::OnSelectionChanged(const base::string16& text,
                                               uint32_t offset,
                                               const gfx::Range& range) {
   if (view_)
     view_->SelectionChanged(text, static_cast<size_t>(offset), range);
 }
 
@@ skipping 52 matching lines @@
 
   if (view_) {
     view_->RenderProcessGone(status, exit_code);
     view_.reset();  // The View should be deleted by RenderProcessGone.
   }
 
   // Reconstruct the input router to ensure that it has fresh state for a new
   // renderer. Otherwise it may be stuck waiting for the old renderer to ack an
   // event. (In particular, the above call to view_->RenderProcessGone will
   // destroy the aura window, which may dispatch a synthetic mouse move.)
-  input_router_.reset(new InputRouterImpl(
-      process_->GetImmediateSender(), this, this, routing_id_,
-      GetInputRouterConfigForPlatform()));
+  input_router_.reset(new InputRouterImpl(process_, this, this, routing_id_,
+                                          GetInputRouterConfigForPlatform()));
 
   synthetic_gesture_controller_.reset();
 }
 
 void RenderWidgetHostImpl::UpdateTextDirection(WebTextDirection direction) {
   text_direction_updated_ = true;
   text_direction_ = direction;
 }
 
 void RenderWidgetHostImpl::CancelUpdateTextDirection() {
   if (text_direction_updated_)
     text_direction_canceled_ = true;
 }
 
 void RenderWidgetHostImpl::NotifyTextDirection() {
   if (text_direction_updated_) {
     if (!text_direction_canceled_)
       Send(new ViewMsg_SetTextDirection(GetRoutingID(), text_direction_));
     text_direction_updated_ = false;
     text_direction_canceled_ = false;
   }
 }
 
 void RenderWidgetHostImpl::ImeSetComposition(
     const base::string16& text,
     const std::vector<blink::WebCompositionUnderline>& underlines,
     const gfx::Range& replacement_range,
     int selection_start,
     int selection_end) {
-  Send(new InputMsg_ImeSetComposition(
-            GetRoutingID(), text, underlines, replacement_range,
-            selection_start, selection_end));
+  Send(new InputMsg_ImeSetComposition(GetRoutingID(), text, underlines,
+                                      replacement_range, selection_start,
+                                      selection_end));
 }
 
 void RenderWidgetHostImpl::ImeConfirmComposition(
     const base::string16& text,
     const gfx::Range& replacement_range,
     bool keep_selection) {
-  Send(new InputMsg_ImeConfirmComposition(
-        GetRoutingID(), text, replacement_range, keep_selection));
+  Send(new InputMsg_ImeConfirmComposition(GetRoutingID(), text,
+                                          replacement_range, keep_selection));
 }
 
 void RenderWidgetHostImpl::ImeCancelComposition() {
-  Send(new InputMsg_ImeSetComposition(GetRoutingID(), base::string16(),
-            std::vector<blink::WebCompositionUnderline>(),
-            gfx::Range::InvalidRange(), 0, 0));
+  Send(new InputMsg_ImeSetComposition(
+      GetRoutingID(), base::string16(),
+      std::vector<blink::WebCompositionUnderline>(), gfx::Range::InvalidRange(),
+      0, 0));
 }
 
 void RenderWidgetHostImpl::RejectMouseLockOrUnlockIfNecessary() {
   DCHECK(!pending_mouse_lock_request_ || !IsMouseLocked());
   if (pending_mouse_lock_request_) {
     pending_mouse_lock_request_ = false;
     Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
   } else if (IsMouseLocked()) {
     view_->UnlockMouse();
   }
@@ skipping 35 matching lines @@
   if (delegate_)
     delegate_->RenderWidgetDeleted(this);
 
   if (also_delete) {
     CHECK(!owner_delegate_);
     delete this;
   }
 }
 
 void RenderWidgetHostImpl::RendererIsUnresponsive() {
-  NotificationService::current()->Notify(
-      NOTIFICATION_RENDER_WIDGET_HOST_HANG,
-      Source<RenderWidgetHost>(this),
-      NotificationService::NoDetails());
+  NotificationService::current()->Notify(NOTIFICATION_RENDER_WIDGET_HOST_HANG,
+                                         Source<RenderWidgetHost>(this),
+                                         NotificationService::NoDetails());
   is_unresponsive_ = true;
   if (delegate_)
     delegate_->RendererUnresponsive(this);
 }
 
 void RenderWidgetHostImpl::RendererIsResponsive() {
   if (is_unresponsive_) {
     is_unresponsive_ = false;
     if (delegate_)
       delegate_->RendererResponsive(this);
@@ skipping 74 matching lines @@
   SendScreenRects();
 }
 
 void RenderWidgetHostImpl::OnRequestMove(const gfx::Rect& pos) {
   if (view_) {
     view_->SetBounds(pos);
     Send(new ViewMsg_Move_ACK(routing_id_));
   }
 }
 
-bool RenderWidgetHostImpl::OnSwapCompositorFrame(
-    const IPC::Message& message) {
+bool RenderWidgetHostImpl::OnSwapCompositorFrame(const IPC::Message& message) {
   // This trace event is used in
   // chrome/browser/extensions/api/cast_streaming/performance_test.cc
   TRACE_EVENT0("test_fps,benchmark", "OnSwapCompositorFrame");
 
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return false;
   std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   uint32_t output_surface_id = base::get<0>(param);
   base::get<1>(param).AssignTo(frame.get());
@@ skipping 15 matching lines @@
   if (view_) {
     view_->OnSwapCompositorFrame(output_surface_id, std::move(frame));
     view_->DidReceiveRendererFrame();
   } else {
     cc::CompositorFrameAck ack;
     if (frame->gl_frame_data) {
       ack.gl_frame_data = std::move(frame->gl_frame_data);
       ack.gl_frame_data->sync_token.Clear();
     } else if (frame->delegated_frame_data) {
       cc::TransferableResource::ReturnResources(
-          frame->delegated_frame_data->resource_list,
-          &ack.resources);
+          frame->delegated_frame_data->resource_list, &ack.resources);
     }
     SendSwapCompositorFrameAck(routing_id_, output_surface_id,
                                process_->GetID(), ack);
   }
 
   RenderProcessHost* rph = GetProcess();
   for (std::vector<IPC::Message>::const_iterator i =
            messages_to_deliver_with_frame.begin();
-       i != messages_to_deliver_with_frame.end();
-       ++i) {
+       i != messages_to_deliver_with_frame.end(); ++i) {
     rph->OnMessageReceived(*i);
     if (i->dispatch_error())
       rph->OnBadMessageReceived(*i);
   }
   messages_to_deliver_with_frame.clear();
 
   return true;
 }
 
 void RenderWidgetHostImpl::OnUpdateRect(
@@ skipping 11 matching lines @@
   // that will end up reaching GetBackingStore.
   if (is_resize_ack) {
     DCHECK(!g_check_for_pending_resize_ack || resize_ack_pending_);
     resize_ack_pending_ = false;
   }
 
   bool is_repaint_ack =
       ViewHostMsg_UpdateRect_Flags::is_repaint_ack(params.flags);
   if (is_repaint_ack) {
     DCHECK(repaint_ack_pending_);
-    TRACE_EVENT_ASYNC_END0(
-        "renderer_host", "RenderWidgetHostImpl::repaint_ack_pending_", this);
+    TRACE_EVENT_ASYNC_END0("renderer_host",
+                           "RenderWidgetHostImpl::repaint_ack_pending_", this);
     repaint_ack_pending_ = false;
     TimeDelta delta = TimeTicks::Now() - repaint_start_time_;
     UMA_HISTOGRAM_TIMES("MPArch.RWH_RepaintDelta", delta);
   }
 
   DCHECK(!params.view_size.IsEmpty());
 
   DidUpdateBackingStore(params, paint_start);
 
   if (auto_resize_enabled_) {
@@ skipping 14 matching lines @@
 }
 
 void RenderWidgetHostImpl::DidUpdateBackingStore(
     const ViewHostMsg_UpdateRect_Params& params,
     const TimeTicks& paint_start) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::DidUpdateBackingStore");
   TimeTicks update_start = TimeTicks::Now();
 
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_BACKING_STORE,
-      Source<RenderWidgetHost>(this),
-      NotificationService::NoDetails());
+      Source<RenderWidgetHost>(this), NotificationService::NoDetails());
 
   // We don't need to update the view if the view is hidden. We must do this
   // early return after the ACK is sent, however, or the renderer will not send
   // us more data.
   if (is_hidden_)
     return;
 
   // If we got a resize ack, then perhaps we have another resize to send?
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
@@ skipping 10 matching lines @@
     const SyntheticGesturePacket& gesture_packet) {
   // Only allow untrustworthy gestures if explicitly enabled.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           cc::switches::kEnableGpuBenchmarking)) {
     bad_message::ReceivedBadMessage(GetProcess(),
                                     bad_message::RWH_SYNTHETIC_GESTURE);
     return;
   }
 
   QueueSyntheticGesture(
-        SyntheticGesture::Create(*gesture_packet.gesture_params()),
-        base::Bind(&RenderWidgetHostImpl::OnSyntheticGestureCompleted,
-                   weak_factory_.GetWeakPtr()));
+      SyntheticGesture::Create(*gesture_packet.gesture_params()),
+      base::Bind(&RenderWidgetHostImpl::OnSyntheticGestureCompleted,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void RenderWidgetHostImpl::OnSetCursor(const WebCursor& cursor) {
   SetCursor(cursor);
 }
 
 void RenderWidgetHostImpl::SetTouchEventEmulationEnabled(
-    bool enabled, ui::GestureProviderConfigType config_type) {
+    bool enabled,
+    ui::GestureProviderConfigType config_type) {
   if (enabled) {
     if (!touch_emulator_) {
       touch_emulator_.reset(new TouchEmulator(
           this,
           view_.get() ? content::GetScaleFactorForView(view_.get()) : 1.0f));
     }
     touch_emulator_->Enable(config_type);
   } else {
     if (touch_emulator_)
       touch_emulator_->Disable();
@@ skipping 101 matching lines @@
     if (current_size != original_size) {
       DCHECK_EQ(original_size - 1, current_size);
       --i;
     }
   }
 
   return false;
 }
 
 InputEventAckState RenderWidgetHostImpl::FilterInputEvent(
-    const blink::WebInputEvent& event, const ui::LatencyInfo& latency_info) {
+    const blink::WebInputEvent& event,
+    const ui::LatencyInfo& latency_info) {
   // Don't ignore touch cancel events, since they may be sent while input
   // events are being ignored in order to keep the renderer from getting
   // confused about how many touches are active.
   if (ShouldDropInputEvents() && event.type != WebInputEvent::TouchCancel)
     return INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
 
   if (!process_->HasConnection())
     return INPUT_EVENT_ACK_STATE_UNKNOWN;
 
   if (delegate_ && (event.type == WebInputEvent::MouseDown ||
@@ skipping 37 matching lines @@
   if (view_)
     view_->DidOverscroll(params);
 }
 
 void RenderWidgetHostImpl::DidStopFlinging() {
   if (view_)
     view_->DidStopFlinging();
 }
 
 void RenderWidgetHostImpl::OnKeyboardEventAck(
-      const NativeWebKeyboardEventWithLatencyInfo& event,
-      InputEventAckState ack_result) {
+    const NativeWebKeyboardEventWithLatencyInfo& event,
+    InputEventAckState ack_result) {
   latency_tracker_.OnInputEventAck(event.event, &event.latency, ack_result);
 
   const bool processed = (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result);
 
   // We only send unprocessed key event upwards if we are not hidden,
   // because the user has moved away from us and no longer expect any effect
   // of this key event.
   if (delegate_ && !processed && !is_hidden() && !event.event.skip_in_browser) {
     delegate_->HandleKeyboardEvent(event.event);
 
@@ skipping 10 matching lines @@
                                    ack_result);
 }
 
 void RenderWidgetHostImpl::OnWheelEventAck(
     const MouseWheelEventWithLatencyInfo& wheel_event,
     InputEventAckState ack_result) {
   latency_tracker_.OnInputEventAck(wheel_event.event, &wheel_event.latency,
                                    ack_result);
 
   if (!is_hidden() && view_) {
-    if (ack_result != INPUT_EVENT_ACK_STATE_CONSUMED &&
-        delegate_ && delegate_->HandleWheelEvent(wheel_event.event)) {
+    if (ack_result != INPUT_EVENT_ACK_STATE_CONSUMED && delegate_ &&
+        delegate_->HandleWheelEvent(wheel_event.event)) {
       ack_result = INPUT_EVENT_ACK_STATE_CONSUMED;
     }
     view_->WheelEventAck(wheel_event.event, ack_result);
   }
 }
 
 void RenderWidgetHostImpl::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   latency_tracker_.OnInputEventAck(event.event, &event.latency, ack_result);
@@ skipping 62 matching lines @@
     return false;
   }
 
   if (!pending_mouse_lock_request_) {
     // This is possible, e.g., the plugin sends us an unlock request before
     // the user allows to lock to mouse.
     return false;
   }
 
   pending_mouse_lock_request_ = false;
-  if (!view_ || !view_->HasFocus()|| !view_->LockMouse()) {
+  if (!view_ || !view_->HasFocus() || !view_->LockMouse()) {
     Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
     return false;
   }
 
   Send(new ViewMsg_LockMouse_ACK(routing_id_, true));
   return true;
 }
 
 // static
 void RenderWidgetHostImpl::SendSwapCompositorFrameAck(
     int32_t route_id,
     uint32_t output_surface_id,
     int renderer_host_id,
     const cc::CompositorFrameAck& ack) {
   RenderProcessHost* host = RenderProcessHost::FromID(renderer_host_id);
   if (!host)
     return;
-  host->Send(new ViewMsg_SwapCompositorFrameAck(
-      route_id, output_surface_id, ack));
+  host->Send(
+      new ViewMsg_SwapCompositorFrameAck(route_id, output_surface_id, ack));
 }
 
 // static
 void RenderWidgetHostImpl::SendReclaimCompositorResources(
     int32_t route_id,
     uint32_t output_surface_id,
     int renderer_host_id,
     const cc::CompositorFrameAck& ack) {
   RenderProcessHost* host = RenderProcessHost::FromID(renderer_host_id);
   if (!host)
@@ skipping 17 matching lines @@
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 void RenderWidgetHostImpl::FrameSwapped(const ui::LatencyInfo& latency_info) {
   ui::LatencyInfo::LatencyComponent window_snapshot_component;
   if (latency_info.FindLatency(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
                                GetLatencyComponentId(),
                                &window_snapshot_component)) {
-    int sequence_number = static_cast<int>(
-        window_snapshot_component.sequence_number);
+    int sequence_number =
+        static_cast<int>(window_snapshot_component.sequence_number);
 #if defined(OS_MACOSX)
     // On Mac, when using CoreAnmation, there is a delay between when content
     // is drawn to the screen, and when the snapshot will actually pick up
     // that content. Insert a manual delay of 1/6th of a second (to simulate
     // 10 frames at 60 fps) before actually taking the snapshot.
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&RenderWidgetHostImpl::WindowSnapshotReachedScreen,
-                   weak_factory_.GetWeakPtr(),
-                   sequence_number),
+                   weak_factory_.GetWeakPtr(), sequence_number),
         base::TimeDelta::FromSecondsD(1. / 6));
 #else
     WindowSnapshotReachedScreen(sequence_number);
 #endif
   }
 
   latency_tracker_.OnFrameSwapped(latency_info);
 }
 
 void RenderWidgetHostImpl::DidReceiveRendererFrame() {
   view_->DidReceiveRendererFrame();
 }
 
 void RenderWidgetHostImpl::WindowSnapshotReachedScreen(int snapshot_id) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   gfx::Rect view_bounds = GetView()->GetViewBounds();
   gfx::Rect snapshot_bounds(view_bounds.size());
 
   std::vector<unsigned char> png;
-  if (ui::GrabViewSnapshot(
-      GetView()->GetNativeView(), &png, snapshot_bounds)) {
+  if (ui::GrabViewSnapshot(GetView()->GetNativeView(), &png, snapshot_bounds)) {
     OnSnapshotDataReceived(snapshot_id, &png.front(), png.size());
     return;
   }
 
   ui::GrabViewSnapshotAsync(
-      GetView()->GetNativeView(),
-      snapshot_bounds,
+      GetView()->GetNativeView(), snapshot_bounds,
       base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&RenderWidgetHostImpl::OnSnapshotDataReceivedAsync,
-                 weak_factory_.GetWeakPtr(),
-                 snapshot_id));
+                 weak_factory_.GetWeakPtr(), snapshot_id));
 }
 
 void RenderWidgetHostImpl::OnSnapshotDataReceived(int snapshot_id,
                                                   const unsigned char* data,
                                                   size_t size) {
   // Any pending snapshots with a lower ID than the one received are considered
   // to be implicitly complete, and returned the same snapshot data.
   PendingSnapshotMap::iterator it = pending_browser_snapshots_.begin();
   while (it != pending_browser_snapshots_.end()) {
-      if (it->first <= snapshot_id) {
-        it->second.Run(data, size);
-        pending_browser_snapshots_.erase(it++);
-      } else {
-        ++it;
-      }
+    if (it->first <= snapshot_id) {
+      it->second.Run(data, size);
+      pending_browser_snapshots_.erase(it++);
+    } else {
+      ++it;
+    }
   }
 }
 
 void RenderWidgetHostImpl::OnSnapshotDataReceivedAsync(
     int snapshot_id,
     scoped_refptr<base::RefCountedBytes> png_data) {
   if (png_data.get())
     OnSnapshotDataReceived(snapshot_id, png_data->front(), png_data->size());
   else
     OnSnapshotDataReceived(snapshot_id, NULL, 0);
@@ skipping 18 matching lines @@
         }
         RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
         if (rwhi_set.insert(rwhi).second)
           rwhi->FrameSwapped(latency_info[i]);
       }
     }
   }
 }
 
 BrowserAccessibilityManager*
-    RenderWidgetHostImpl::GetRootBrowserAccessibilityManager() {
+RenderWidgetHostImpl::GetRootBrowserAccessibilityManager() {
   return delegate_ ? delegate_->GetRootBrowserAccessibilityManager() : NULL;
 }
 
 BrowserAccessibilityManager*
-    RenderWidgetHostImpl::GetOrCreateRootBrowserAccessibilityManager() {
-  return delegate_ ?
-      delegate_->GetOrCreateRootBrowserAccessibilityManager() : NULL;
+RenderWidgetHostImpl::GetOrCreateRootBrowserAccessibilityManager() {
+  return delegate_ ? delegate_->GetOrCreateRootBrowserAccessibilityManager()
+                   : NULL;
 }
 
 }  // namespace content