Log First User Interaction in Page Load Metrics

content/browser/renderer_host/render_widget_host_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 151 matching lines @@
   void ResizeRectChanged(const gfx::Rect& new_rect) override;
   void RestartHangMonitorTimeout() override;
   void DisableHangMonitorForTesting() override;
   void SetIgnoreInputEvents(bool ignore_input_events) override;
   void WasResized() override;
   void AddKeyPressEventCallback(const KeyPressEventCallback& callback) override;
   void RemoveKeyPressEventCallback(
       const KeyPressEventCallback& callback) override;
   void AddMouseEventCallback(const MouseEventCallback& callback) override;
   void RemoveMouseEventCallback(const MouseEventCallback& callback) override;
+  void AddInputEventObserver(
+      RenderWidgetHost::InputEventObserver* observer) override;
+  void RemoveInputEventObserver(
+      RenderWidgetHost::InputEventObserver* observer) override;
   void GetWebScreenInfo(blink::WebScreenInfo* result) override;
   bool GetScreenColorProfile(std::vector<char>* color_profile) override;
   void HandleCompositorProto(const std::vector<uint8_t>& proto) override;
 
   // Notification that the screen info has changed.
   void NotifyScreenInfoChanged();
 
   // Forces redraw in the renderer and when the update reaches the browser
   // grabs snapshot from the compositor. Returns PNG-encoded snapshot.
   using GetSnapshotFromBrowserCallback =
@@ skipping 107 matching lines @@
   // a page load. This stops |new_content_rendering_timeout_|, or prevents
   // the timer from running if the load commit message hasn't been received
   // yet.
   void OnFirstPaintAfterLoad();
 
   // Forwards the given message to the renderer. These are called by the view
   // when it has received a message.
   void ForwardGestureEventWithLatencyInfo(
       const blink::WebGestureEvent& gesture_event,
       const ui::LatencyInfo& ui_latency) override;
-  void ForwardTouchEventWithLatencyInfo(
-      const blink::WebTouchEvent& touch_event,
-      const ui::LatencyInfo& ui_latency);
-  void ForwardMouseEventWithLatencyInfo(
-      const blink::WebMouseEvent& mouse_event,
-      const ui::LatencyInfo& ui_latency);
+  void ForwardTouchEventWithLatencyInfo(const blink::WebTouchEvent& touch_event,
+                                        const ui::LatencyInfo& ui_latency);
+  void ForwardMouseEventWithLatencyInfo(const blink::WebMouseEvent& mouse_event,
+                                        const ui::LatencyInfo& ui_latency);
   virtual void ForwardWheelEventWithLatencyInfo(
       const blink::WebMouseWheelEvent& wheel_event,
-      const ui::LatencyInfo& ui_latency); // Virtual for testing.
+      const ui::LatencyInfo& ui_latency);  // Virtual for testing.
 
   // Enables/disables touch emulation using mouse event. See TouchEmulator.
-  void SetTouchEventEmulationEnabled(
-      bool enabled, ui::GestureProviderConfigType config_type);
+  void SetTouchEventEmulationEnabled(bool enabled,
+                                     ui::GestureProviderConfigType config_type);
 
   // TouchEmulatorClient implementation.
   void ForwardEmulatedGestureEvent(
       const blink::WebGestureEvent& gesture_event) override;
   void ForwardEmulatedTouchEvent(
       const blink::WebTouchEvent& touch_event) override;
   void SetCursor(const WebCursor& cursor) override;
   void ShowContextMenuAtPoint(const gfx::Point& point) override;
 
   // Queues a synthetic gesture for testing purposes.  Invokes the on_complete
@@ skipping 32 matching lines @@
   //   (on Windows);
   // * when it receives a "commit" signal of GtkIMContext (on Linux);
   // * when insertText of NSTextInput is called (on Mac).
   void ImeConfirmComposition(const base::string16& text,
                              const gfx::Range& replacement_range,
                              bool keep_selection);
 
   // Cancels an ongoing composition.
   void ImeCancelComposition();
 
-  bool ignore_input_events() const {
-    return ignore_input_events_;
-  }
+  bool ignore_input_events() const { return ignore_input_events_; }
 
   // Whether forwarded WebInputEvents should be dropped.
   bool ShouldDropInputEvents() const;
 
   bool has_touch_handler() const { return has_touch_handler_; }
 
   // Set the RenderView background transparency.
   void SetBackgroundOpaque(bool opaque);
 
   // Notifies the renderer that the next key event is bound to one or more
   // pre-defined edit commands
-  void SetEditCommandsForNextKeyEvent(
-      const std::vector<EditCommand>& commands);
+  void SetEditCommandsForNextKeyEvent(const std::vector<EditCommand>& commands);
 
   // Executes the edit command.
-  void ExecuteEditCommand(const std::string& command,
-                          const std::string& value);
+  void ExecuteEditCommand(const std::string& command, const std::string& value);
 
   // Tells the renderer to scroll the currently focused node into rect only if
   // the currently focused node is a Text node (textfield, text area or content
   // editable divs).
   void ScrollFocusedEditableNodeIntoRect(const gfx::Rect& rect);
 
   // Requests the renderer to move the caret selection towards the point.
   void MoveCaret(const gfx::Point& point);
 
   // Called when the reponse to a pending mouse lock request has arrived.
   // Returns true if |allowed| is true and the mouse has been successfully
   // locked.
   bool GotResponseToLockMouseRequest(bool allowed);
 
   // Tells the RenderWidget about the latest vsync parameters.
   void UpdateVSyncParameters(base::TimeTicks timebase,
                              base::TimeDelta interval);
 
   // Called by the view in response to OnSwapCompositorFrame.
-  static void SendSwapCompositorFrameAck(
-      int32_t route_id,
-      uint32_t output_surface_id,
-      int renderer_host_id,
-      const cc::CompositorFrameAck& ack);
+  static void SendSwapCompositorFrameAck(int32_t route_id,
+                                         uint32_t output_surface_id,
+                                         int renderer_host_id,
+                                         const cc::CompositorFrameAck& ack);
 
   // Called by the view to return resources to the compositor.
   static void SendReclaimCompositorResources(int32_t route_id,
                                              uint32_t output_surface_id,
                                              int renderer_host_id,
                                              const cc::CompositorFrameAck& ack);
 
   void set_allow_privileged_mouse_lock(bool allow) {
     allow_privileged_mouse_lock_ = allow;
   }
@@ skipping 277 matching lines @@
   bool waiting_for_screen_rects_ack_;
   gfx::Rect last_view_screen_rect_;
   gfx::Rect last_window_screen_rect_;
 
   // Keyboard event listeners.
   std::vector<KeyPressEventCallback> key_press_event_callbacks_;
 
   // Mouse event callbacks.
   std::vector<MouseEventCallback> mouse_event_callbacks_;
 
+  // Input event callbacks.
+  base::ObserverList<RenderWidgetHost::InputEventObserver>
+      input_event_observers_;
+
   // If true, then we should repaint when restoring even if we have a
   // backingstore.  This flag is set to true if we receive a paint message
   // while is_hidden_ to true.  Even though we tell the render widget to hide
   // itself, a paint message could already be in flight at that point.
   bool needs_repainting_on_restore_;
 
   // This is true if the renderer is currently unresponsive.
   bool is_unresponsive_;
 
   // This value denotes the number of input events yet to be acknowledged
@@ skipping 95 matching lines @@
   base::TimeDelta new_content_rendering_delay_;
 
   base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_