Add TimeToScrollUpdateSwapBegin2 in RAPPOR

content/browser/renderer_host/input/render_widget_host_latency_tracker_unittest.cc

 // Copyright 2014 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 "base/test/histogram_tester.h"
+#include "components/rappor/public/rappor_utils.h"
+#include "components/rappor/test_rappor_service.h"
 #include "content/browser/renderer_host/input/render_widget_host_latency_tracker.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/public/browser/native_web_keyboard_event.h"
+#include "content/test/test_content_browser_client.h"
+#include "content/test/test_render_view_host.h"
+#include "content/test/test_web_contents.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Bucket;
 using blink::WebInputEvent;
 using testing::ElementsAre;
 
 namespace content {
 namespace {
 
@@ skipping 33 matching lines @@
 
   } else {
     latency->AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT, 0, 0,
         time_stamp, 1);
   }
 }
 
 }  // namespace
 
-class RenderWidgetHostLatencyTrackerTest : public testing::Test {
+class RenderWidgetHostLatencyTrackerTestBrowserClient
+    : public TestContentBrowserClient {
  public:
-  RenderWidgetHostLatencyTrackerTest() {
+  RenderWidgetHostLatencyTrackerTestBrowserClient() {}
+  ~RenderWidgetHostLatencyTrackerTestBrowserClient() override {}
+
+  rappor::RapporService* GetRapporService() override {
+    return &rappor_service_;
+  }
+
+  rappor::TestRapporServiceImpl* getTestRapporService() {
+    return &rappor_service_;
+  }
+
+ private:
+  rappor::TestRapporServiceImpl rappor_service_;
+  DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostLatencyTrackerTestBrowserClient);
+};
+
+class RenderWidgetHostLatencyTrackerTest
+    : public RenderViewHostImplTestHarness {
+ public:
+  RenderWidgetHostLatencyTrackerTest() : old_browser_client_(NULL) {
     tracker_.Initialize(kTestRoutingId, kTestProcessId);
     ResetHistograms();
   }
 
   ::testing::AssertionResult HistogramSizeEq(const char* histogram_name,
                                              int size) {
     uint64_t histogram_size =
         histogram_tester_->GetAllSamples(histogram_name).size();
     if (static_cast<uint64_t>(size) == histogram_size) {
       return ::testing::AssertionSuccess();
     } else {
       return ::testing::AssertionFailure() << histogram_name << " expected "
                                            << size << " entries, but had "
                                            << histogram_size;
     }
   }
 
   RenderWidgetHostLatencyTracker* tracker() { return &tracker_; }
   void ResetHistograms() {
     histogram_tester_.reset(new base::HistogramTester());
   }
 
   const base::HistogramTester& histogram_tester() {
     return *histogram_tester_;
   }
 
- private:
+  void SetUp() override {
+    RenderViewHostImplTestHarness::SetUp();
+    old_browser_client_ = SetBrowserClientForTesting(&test_browser_client_);
+    tracker_.SetDelegate(contents());
+  }
+
+  void TearDown() override {
+    SetBrowserClientForTesting(old_browser_client_);
+    RenderViewHostImplTestHarness::TearDown();
+  }
+
+ protected:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostLatencyTrackerTest);
   const int kTestRoutingId = 3;
   const int kTestProcessId = 1;
   std::unique_ptr<base::HistogramTester> histogram_tester_;
   RenderWidgetHostLatencyTracker tracker_;
+  RenderWidgetHostLatencyTrackerTestBrowserClient test_browser_client_;
+  ContentBrowserClient* old_browser_client_;
 };
 
 TEST_F(RenderWidgetHostLatencyTrackerTest, TestWheelToFirstScrollHistograms) {
   for (bool rendering_on_main : {false, true}) {
     for (bool is_running_navigation_hint_task : {false, true}) {
       ResetHistograms();
       {
         auto wheel = SyntheticWebMouseWheelEventBuilder::Build(
             blink::WebMouseWheelEvent::PhaseChanged);
         base::TimeTicks now = base::TimeTicks::Now();
@@ skipping 267 matching lines @@
       EXPECT_TRUE(HistogramSizeEq(
           "Event.Latency.ScrollUpdate.Touch.BrowserNotifiedToBeforeGpuSwap2",
           0));
       EXPECT_TRUE(
           HistogramSizeEq("Event.Latency.ScrollUpdate.Touch.GpuSwap2", 0));
     }
   }
 }
 
 TEST_F(RenderWidgetHostLatencyTrackerTest, TestTouchToScrollHistograms) {
+  const GURL url("http://www.foo.bar.com/subpage/1");
+  contents()->NavigateAndCommit(url);
   for (bool rendering_on_main : {false, true}) {
     for (bool is_running_navigation_hint_task : {false, true}) {
       ResetHistograms();
+      EXPECT_EQ(0,
+                test_browser_client_.getTestRapporService()->GetReportsCount());
       {
         auto scroll = SyntheticWebGestureEventBuilder::BuildScrollUpdate(
             5.f, -5.f, 0, blink::WebGestureDeviceTouchscreen);
         base::TimeTicks now = base::TimeTicks::Now();
         scroll.timeStampSeconds = (now - base::TimeTicks()).InSecondsF();
         ui::LatencyInfo scroll_latency;
         scroll_latency.AddLatencyNumberWithTimestamp(
             ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT,
             tracker()->latency_component_id(), 0, now, 1);
         AddFakeComponentsWithTimeStamp(*tracker(), &scroll_latency, now);
@@ skipping 26 matching lines @@
             tracker()->latency_component_id(), nullptr));
         EXPECT_TRUE(touch_latency.FindLatency(
             ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, nullptr));
         EXPECT_EQ(2U, touch_latency.input_coordinates_size());
         tracker()->OnInputEventAck(touch, &touch_latency,
                                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
         tracker()->OnFrameSwapped(touch_latency,
                                   is_running_navigation_hint_task);
       }
 
+      // Rappor metrics
+      rappor::TestSample::Shadow* sample_obj =
+          test_browser_client_.getTestRapporService()
+              ->GetRecordedSampleForMetric(
+                  "Event.Latency.ScrollUpdate.Touch."
+                  "TimeToScrollUpdateSwapBegin2");
+      EXPECT_NE(nullptr, sample_obj);
+      const auto& domain_it = sample_obj->string_fields.find("Domain");
+      EXPECT_NE(domain_it, sample_obj->string_fields.end());
+      EXPECT_EQ("bar.com", domain_it->second);
+      const auto& latency_it = sample_obj->uint64_fields.find("Latency");
+      EXPECT_NE(latency_it, sample_obj->uint64_fields.end());
+      EXPECT_EQ(rappor::NO_NOISE, latency_it->second.second);
+
+      EXPECT_EQ(2,
+                test_browser_client_.getTestRapporService()->GetReportsCount());
+
+      // UMA histograms
       EXPECT_TRUE(HistogramSizeEq(
           "Event.Latency.ScrollBegin.Touch.TimeToScrollUpdateSwapBegin2", 0));
       EXPECT_TRUE(HistogramSizeEq(
           "Event.Latency.ScrollUpdate.Touch.TimeToScrollUpdateSwapBegin2", 1));
       EXPECT_TRUE(HistogramSizeEq(
           "Event.Latency.ScrollBegin.Touch.TimeToHandled2_Main", 0));
       EXPECT_TRUE(HistogramSizeEq(
           "Event.Latency.ScrollBegin.Touch.TimeToHandled2_Impl", 0));
       EXPECT_TRUE(HistogramSizeEq(
           "Event.Latency.ScrollBegin.Touch.HandledToRendererSwap2_Main", 0));
@@ skipping 418 matching lines @@
                   "Event.Latency.BlockingTime.TouchEndDefaultPrevented"),
               ElementsAre(Bucket(
                   touchend_timestamps_ms[2] - touchend_timestamps_ms[1], 1)));
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "Event.Latency.BlockingTime.TouchEndDefaultAllowed"),
               ElementsAre(Bucket(
                   touchend_timestamps_ms[2] - touchend_timestamps_ms[1], 1)));
 }
 
 }  // namespace content