latency: Stop using a component-id for BEGIN_RWH component.

The component-id for BEGIN_RWH component is currently generated from the
process-id and routing-id of the associated RenderWidgetHostImpl, so
that it is possible to find the RenderWidgetHostImpl from the
LatencyInfo after gpu-swap happens. However, the BEGIN_RWH component is
unused at that time (only LatencyInfos that have snapshot requests are
processed after gpu-swap, and the snapshot requests already carry the
identifier for the RenderWidgetHostImpl separately), except for in a
test. So, the changes in this CL:
 . Use zero as the component-id for BEGIN_RWH component.
 . Introduce a SetLatencyInfoProcessorForTesting() method to install a
   callback that receives all the LatencyInfo after a gpu-swap happens,
   and use that in the tests that needed this.

BUG=849729

Change-Id: I19beb790931cfe8e708d0eb4223a3ba23d51e4c1
Reviewed-on: https://chromium-review.googlesource.com/1089583Reviewed-by: Timothy Dresser <tdresser@chromium.org>
Commit-Queue: Sadrul Chowdhury <sadrul@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565488}

content/browser/renderer_host/input/mouse_latency_browsertest.cc

@@ -83,11 +83,18 @@ class TracingRenderWidgetHost : public RenderWidgetHostImpl {
                              process,
                              routing_id,
                              std::move(widget),
-                             hidden) {}
-  void OnGpuSwapBuffersCompletedInternal(
-      const ui::LatencyInfo& latency_info) override {
-    RenderWidgetHostImpl::OnGpuSwapBuffersCompletedInternal(latency_info);
-    RunClosureIfNecessary(latency_info);
+                             hidden) {
+    SetLatencyInfoProcessorForTesting(base::BindRepeating(
+        &TracingRenderWidgetHost::HandleLatencyInfoAfterGpuSwap,
+        base::Unretained(this)));
+  }
+
+  void HandleLatencyInfoAfterGpuSwap(
+      const std::vector<ui::LatencyInfo>& latency_infos) {
+    for (const auto& latency_info : latency_infos) {
+      if (latency_info.terminated())
+        RunClosureIfNecessary(latency_info);
+    }
   }
 
   void OnMouseEventAck(const MouseEventWithLatencyInfo& event,

content/browser/renderer_host/input/render_widget_host_latency_tracker.cc

@@ -57,7 +57,6 @@ void RenderWidgetHostLatencyTracker::Initialize(int routing_id,
 
 void RenderWidgetHostLatencyTracker::ComputeInputLatencyHistograms(
     WebInputEvent::Type type,
-    int64_t latency_component_id,
     const LatencyInfo& latency,
     InputEventAckState ack_result) {
   // If this event was coalesced into another event, ignore it, as the event it
@@ -73,9 +72,8 @@ void RenderWidgetHostLatencyTracker::ComputeInputLatencyHistograms(
   // The event will have gone through OnInputEvent(). So the BEGIN_RWH component
   // should always be available here.
   LatencyInfo::LatencyComponent rwh_component;
-  bool found_component =
-      latency.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
-                          latency_component_id, &rwh_component);
+  bool found_component = latency.FindLatency(
+      ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, &rwh_component);
   DCHECK(found_component);
   DCHECK_EQ(rwh_component.event_count, 1u);
 
@@ -150,9 +148,8 @@ void RenderWidgetHostLatencyTracker::OnInputEvent(
 
   // This is the only place to add the BEGIN_RWH component. So this component
   // should not already be present in the latency info.
-  bool found_component =
-      latency->FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
-                           latency_component_id_, nullptr);
+  bool found_component = latency->FindLatency(
+      ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, nullptr);
   DCHECK(!found_component);
 
   if (!event.TimeStamp().is_null() &&
@@ -176,7 +173,7 @@ void RenderWidgetHostLatencyTracker::OnInputEvent(
   }
 
   latency->AddLatencyNumberWithTraceName(
-      ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, latency_component_id_,
+      ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0,
       WebInputEvent::GetName(event.GetType()));
 
   if (event.GetType() == blink::WebInputEvent::kGestureScrollBegin) {
@@ -234,8 +231,7 @@ void RenderWidgetHostLatencyTracker::OnInputEventAck(
     latency->Terminate();
   }
 
-  ComputeInputLatencyHistograms(event.GetType(), latency_component_id_,
-                                *latency, ack_result);
+  ComputeInputLatencyHistograms(event.GetType(), *latency, ack_result);
 }
 
 void RenderWidgetHostLatencyTracker::OnEventStart(ui::LatencyInfo* latency) {

content/browser/renderer_host/input/render_widget_host_latency_tracker.h

@@ -32,7 +32,6 @@ class CONTENT_EXPORT RenderWidgetHostLatencyTracker {
   void Initialize(int routing_id, int process_id);
 
   void ComputeInputLatencyHistograms(blink::WebInputEvent::Type type,
-                                     int64_t latency_component_id,
                                      const ui::LatencyInfo& latency,
                                      InputEventAckState ack_result);
 

content/browser/renderer_host/render_widget_host_impl.cc

@@ -24,6 +24,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/no_destructor.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ -184,6 +185,12 @@ class RenderWidgetHostIteratorImpl : public RenderWidgetHostIterator {
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostIteratorImpl);
 };
 
+RenderWidgetHostImpl::LatencyInfoProcessor& GetLatencyInfoProcessor() {
+  static base::NoDestructor<RenderWidgetHostImpl::LatencyInfoProcessor>
+      processor;
+  return *processor;
+}
+
 inline blink::WebGestureEvent CreateScrollBeginForWrapping(
     const blink::WebGestureEvent& gesture_event) {
   DCHECK(gesture_event.GetType() == blink::WebInputEvent::kGestureScrollUpdate);
@@ -1974,6 +1981,11 @@ bool RenderWidgetHostImpl::IsMouseLocked() const {
   return view_ ? view_->IsMouseLocked() : false;
 }
 
+void RenderWidgetHostImpl::SetLatencyInfoProcessorForTesting(
+    const LatencyInfoProcessor& processor) {
+  GetLatencyInfoProcessor() = processor;
+}
+
 void RenderWidgetHostImpl::SetAutoResize(bool enable,
                                          const gfx::Size& min_size,
                                          const gfx::Size& max_size) {
@@ -2056,7 +2068,7 @@ void RenderWidgetHostImpl::ClearDisplayedGraphics() {
     view_->ClearCompositorFrame();
 }
 
-void RenderWidgetHostImpl::OnGpuSwapBuffersCompletedInternal(
+void RenderWidgetHostImpl::ProcessSnapshotResponses(
     const ui::LatencyInfo& latency_info) {
   // Note that a compromised renderer can send LatencyInfo to a
   // RenderWidgetHostImpl other than its own. Be mindful of security
@@ -2745,20 +2757,17 @@ void RenderWidgetHostImpl::NotifyCorrespondingRenderWidgetHost(
     return;
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
   if (notified_hosts.insert(rwhi).second)
-    rwhi->OnGpuSwapBuffersCompletedInternal(latency_info);
+    rwhi->ProcessSnapshotResponses(latency_info);
 }
 
 // static
 void RenderWidgetHostImpl::OnGpuSwapBuffersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info) {
+  auto& callback = GetLatencyInfoProcessor();
+  if (!callback.is_null())
+    callback.Run(latency_info);
   for (size_t i = 0; i < latency_info.size(); i++) {
     std::set<RenderWidgetHostImpl*> rwhi_set;
-    for (const auto& lc : latency_info[i].latency_components()) {
-      if (lc.first.first == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT) {
-        NotifyCorrespondingRenderWidgetHost(lc.first.second, rwhi_set,
-                                            latency_info[i]);
-      }
-    }
     for (const auto& snapshot : latency_info[i].Snapshots())
       NotifyCorrespondingRenderWidgetHost(snapshot.first, rwhi_set,
                                           latency_info[i]);

content/browser/renderer_host/render_widget_host_impl.h

@@ -722,6 +722,11 @@ class CONTENT_EXPORT RenderWidgetHostImpl
 
   void GetContentRenderingTimeoutFrom(RenderWidgetHostImpl* other);
 
+  using LatencyInfoProcessor =
+      base::RepeatingCallback<void(const std::vector<ui::LatencyInfo>&)>;
+  static void SetLatencyInfoProcessorForTesting(
+      const LatencyInfoProcessor& processor);
+
  protected:
   // ---------------------------------------------------------------------------
   // The following method is overridden by RenderViewHost to send upwards to
@@ -731,9 +736,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl
   // from a newly loaded page. Used for testing.
   virtual void NotifyNewContentRenderingTimeoutForTesting() {}
 
-  // Can be overriden for subclass based testing.
-  virtual void OnGpuSwapBuffersCompletedInternal(
-      const ui::LatencyInfo& latency_info);
+  void ProcessSnapshotResponses(const ui::LatencyInfo& latency_info);
 
   // InputAckHandler
   void OnKeyboardEventAck(const NativeWebKeyboardEventWithLatencyInfo& event,

content/browser/renderer_host/render_widget_host_unittest.cc

@@ -2054,7 +2054,7 @@ void CheckLatencyInfoComponentInMessage(
               expected_type);
   EXPECT_TRUE(
       dispatched_events[0]->ToEvent()->Event()->latency_info.FindLatency(
-          ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, component_id, nullptr));
+          ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, nullptr));
   dispatched_events[0]->ToEvent()->CallCallback(INPUT_EVENT_ACK_STATE_CONSUMED);
 }
 
@@ -2071,7 +2071,7 @@ void CheckLatencyInfoComponentInGestureScrollUpdate(
             dispatched_events[1]->ToEvent()->Event()->web_event->GetType());
   EXPECT_TRUE(
       dispatched_events[1]->ToEvent()->Event()->latency_info.FindLatency(
-          ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, component_id, nullptr));
+          ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, nullptr));
   dispatched_events[1]->ToEvent()->CallCallback(INPUT_EVENT_ACK_STATE_CONSUMED);
 }