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 277 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,

[Bryan McQuade, 2016/05/25 21:32:30]

can you run git cl format in  your client just to be sure that all of the style
changes you made for this file are consistent with what the formatter expects?
if git cl format makes any changes (including reverting to the file's previous
style for these methods), you should keep whatever style changes it makes.

+                                        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 42 matching lines @@
   int64_t GetLatencyComponentId() const;
 
   static void CompositorFrameDrawn(
       const std::vector<ui::LatencyInfo>& latency_info);
 
   // Don't check whether we expected a resize ack during layout tests.
   static void DisableResizeAckCheckForTesting();
 
   InputRouter* input_router() { return input_router_.get(); }
 
+  RenderWidgetHostLatencyTracker* latency_tracker() {
+    return latency_tracker_.get();
+  }
+
   // Get the BrowserAccessibilityManager for the root of the frame tree,
   BrowserAccessibilityManager* GetRootBrowserAccessibilityManager();
 
   // Get the BrowserAccessibilityManager for the root of the frame tree,
   // or create it if it doesn't already exist.
   BrowserAccessibilityManager* GetOrCreateRootBrowserAccessibilityManager();
 
   void RejectMouseLockOrUnlockIfNecessary();
 
   void set_renderer_initialized(bool renderer_initialized) {
@@ skipping 299 matching lines @@
   // called. This means that a paint for the new load has completed before
   // the browser received a DidCommitProvisionalLoad message. In that case
   // |new_content_rendering_timeout_| is not needed. The renderer will send
   // both the FirstPaintAfterLoad and DidCommitProvisionalLoad messages after
   // any new page navigation, it doesn't matter which is received first, and
   // it should not be possible to interleave other navigations in between
   // receipt of those messages (unless FirstPaintAfterLoad is prevented from
   // being sent, in which case the timer should fire).
   bool received_paint_after_load_;
 
-  RenderWidgetHostLatencyTracker latency_tracker_;
+  std::unique_ptr<RenderWidgetHostLatencyTracker> latency_tracker_;

[tdresser, 2016/05/24 14:28:38]

Why change this to unique_ptr?

 
   int next_browser_snapshot_id_;
   using PendingSnapshotMap = std::map<int, GetSnapshotFromBrowserCallback>;
   PendingSnapshotMap pending_browser_snapshots_;
 
   // Indicates whether a RenderFramehost has ownership, in which case this
   // object does not self destroy.
   bool owned_by_render_frame_host_;
 
   // Indicates whether this RenderWidgetHost thinks is focused. This is trying
@@ skipping 10 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_