Revert of [Page Load Metrics] PageLoadMetrics Mojofication.

chrome/renderer/page_load_metrics/metrics_render_frame_observer_unittest.cc

 // Copyright (c) 2015 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 "chrome/renderer/page_load_metrics/metrics_render_frame_observer.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/timer/mock_timer.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
-#include "chrome/renderer/page_load_metrics/fake_page_timing_sender.h"
+#include "chrome/renderer/page_load_metrics/fake_page_timing_metrics_ipc_sender.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace page_load_metrics {
 
 // Implementation of the MetricsRenderFrameObserver class we're testing,
 // with the GetTiming() and ShouldSendMetrics() methods stubbed out to make
 // the rest of the class more testable.
 class TestMetricsRenderFrameObserver : public MetricsRenderFrameObserver {
  public:
   TestMetricsRenderFrameObserver() : MetricsRenderFrameObserver(nullptr) {}
 
   std::unique_ptr<base::Timer> CreateTimer() const override {
     if (!mock_timer_)
       ADD_FAILURE() << "CreateTimer() called, but no MockTimer available.";
     return std::move(mock_timer_);
   }
 
-  std::unique_ptr<PageTimingSender> CreatePageTimingSender() override {
-    return base::WrapUnique<PageTimingSender>(
-        new FakePageTimingSender(&validator_));
+  // We intercept sent messages and dispatch them to our
+  // FakePageTimingMetricsIPCSender, which we use to verify that the expected
+  // IPC messages get sent.
+  bool Send(IPC::Message* message) override {
+    return fake_timing_ipc_sender_.Send(message);
   }
 
   void set_mock_timer(std::unique_ptr<base::Timer> timer) {
     ASSERT_EQ(nullptr, mock_timer_);
     mock_timer_ = std::move(timer);
   }
 
   void ExpectPageLoadTiming(const mojom::PageLoadTiming& timing) {
     SetFakePageLoadTiming(timing);
-    validator_.ExpectPageLoadTiming(timing);
+    fake_timing_ipc_sender_.ExpectPageLoadTiming(timing);
   }
 
   void SetFakePageLoadTiming(const mojom::PageLoadTiming& timing) {
     EXPECT_EQ(nullptr, fake_timing_.get());
     fake_timing_ = timing.Clone();
   }
 
   mojom::PageLoadTimingPtr GetTiming() const override {
     EXPECT_NE(nullptr, fake_timing_.get());
     return std::move(fake_timing_);
   }
 
   void VerifyExpectedTimings() const {
     EXPECT_EQ(nullptr, fake_timing_.get());
-    validator_.VerifyExpectedTimings();
+    fake_timing_ipc_sender_.VerifyExpectedTimings();
   }
 
   bool ShouldSendMetrics() const override { return true; }
   bool HasNoRenderFrame() const override { return false; }
 
  private:
-  FakePageTimingSender::PageTimingValidator validator_;
+  FakePageTimingMetricsIPCSender fake_timing_ipc_sender_;
   mutable mojom::PageLoadTimingPtr fake_timing_;
   mutable std::unique_ptr<base::Timer> mock_timer_;
 };
 
 typedef testing::Test MetricsRenderFrameObserverTest;
 
 TEST_F(MetricsRenderFrameObserverTest, NoMetrics) {
   TestMetricsRenderFrameObserver observer;
   base::MockTimer* mock_timer = new base::MockTimer(false, false);
   observer.set_mock_timer(base::WrapUnique(mock_timer));
@@ skipping 119 matching lines @@
   timing_2.document_timing->first_layout = first_layout_2;
   timing_2.document_timing->dom_content_loaded_event_start = dom_event_2;
   timing_2.document_timing->load_event_start = load_event_2;
   observer.ExpectPageLoadTiming(timing_2);
 
   observer.DidChangePerformanceTiming();
   mock_timer2->Fire();
 }
 
 }  // namespace page_load_metrics