PageLoadTiming fixes in prep for using base::Optional

We use PageLoadTiming with gmock in a few places. gmock sometimes passes
objects to functions by value. In these cases, if PageLoadTiming contains
base::Optional members, the code fails to compile on windows due to as
issue with Optional's use of aligned memory.

This changes updates our use of PageLoadTiming with gmock to no longer
use aspects of gmock that pass PageLoadTiming by value.

This factors common code into a new FakePageTimingMetricsIPCSender class,
which provides the functionality we had been using gmock for.

See https://groups.google.com/forum/#!topic/googletestframework/W-Hud3j_c6I
for additional details on why gmock is not compatible with Optional.

BUG=623556

Review-Url: https://codereview.chromium.org/2100653002
Cr-Commit-Position: refs/heads/master@{#403266}

components/components_tests.gyp

@@ -504,6 +504,8 @@
     ],
     'page_load_metrics_unittest_sources': [
       'page_load_metrics/browser/metrics_web_contents_observer_unittest.cc',
+      'page_load_metrics/renderer/fake_page_timing_metrics_ipc_sender.cc',
+      'page_load_metrics/renderer/fake_page_timing_metrics_ipc_sender.h',
       'page_load_metrics/renderer/metrics_render_frame_observer_unittest.cc',
       'page_load_metrics/renderer/page_timing_metrics_sender_unittest.cc',
     ],

components/page_load_metrics/renderer/BUILD.gn

@@ -25,6 +25,8 @@ static_library("renderer") {
 source_set("unit_tests") {
   testonly = true
   sources = [
+    "fake_page_timing_metrics_ipc_sender.cc",
+    "fake_page_timing_metrics_ipc_sender.h",
     "metrics_render_frame_observer_unittest.cc",
     "page_timing_metrics_sender_unittest.cc",
   ]

components/page_load_metrics/renderer/fake_page_timing_metrics_ipc_sender.cc

+// Copyright 2016 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 "components/page_load_metrics/common/page_load_metrics_messages.h"
+#include "components/page_load_metrics/renderer/fake_page_timing_metrics_ipc_sender.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_message_macros.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace page_load_metrics {
+
+FakePageTimingMetricsIPCSender::FakePageTimingMetricsIPCSender() {}
+
+FakePageTimingMetricsIPCSender::~FakePageTimingMetricsIPCSender() {
+  VerifyExpectedTimings();
+}
+
+void FakePageTimingMetricsIPCSender::ExpectPageLoadTiming(
+    const PageLoadTiming& timing) {
+  VerifyExpectedTimings();
+  expected_timings_.push_back(timing);
+}
+
+void FakePageTimingMetricsIPCSender::VerifyExpectedTimings() const {
+  // Ideally we'd just call ASSERT_EQ(actual_timings_, expected_timings_) here,
+  // but this causes the generated gtest code to fail to build on Windows. See
+  // the comments in the header file for additional details.
+  ASSERT_EQ(actual_timings_.size(), expected_timings_.size());
+  for (size_t i = 0; i < actual_timings_.size(); ++i) {
+    if (actual_timings_.at(i) == expected_timings_.at(i))
+      continue;
+    ADD_FAILURE() << "Actual timing != expected timing at index " << i;
+  }
+}
+
+bool FakePageTimingMetricsIPCSender::Send(IPC::Message* message) {
+  IPC_BEGIN_MESSAGE_MAP(FakePageTimingMetricsIPCSender, *message)
+    IPC_MESSAGE_HANDLER(PageLoadMetricsMsg_TimingUpdated, OnTimingUpdated)
+    IPC_MESSAGE_UNHANDLED(ADD_FAILURE())
+  IPC_END_MESSAGE_MAP()
+
+  delete message;
+  return true;
+}
+
+void FakePageTimingMetricsIPCSender::OnTimingUpdated(
+    const PageLoadTiming& timing,
+    PageLoadMetadata metadata) {
+  actual_timings_.push_back(timing);
+  VerifyExpectedTimings();
+}
+
+}  // namespace page_load_metrics

components/page_load_metrics/renderer/fake_page_timing_metrics_ipc_sender.h

+// Copyright (c) 2016 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 COMPONENTS_PAGE_LOAD_METRICS_RENDERER_FAKE_PAGE_TIMING_METRICS_IPC_SENDER_H_
+#define COMPONENTS_PAGE_LOAD_METRICS_RENDERER_FAKE_PAGE_TIMING_METRICS_IPC_SENDER_H_
+
+#include <vector>
+
+#include "components/page_load_metrics/common/page_load_timing.h"
+#include "ipc/ipc_sender.h"
+
+namespace IPC {
+class Message;
+}
+
+namespace page_load_metrics {
+
+// IPC::Sender implementation for use in tests. Allows for setting and verifying
+// basic expectations when sending PageLoadTiming IPCs. By default,
+// FakePageTimingMetricsIPCSender will verify that expected and actual
+// PageLoadTimings match on each invocation to ExpectPageLoadTiming() and
+// Send(), as well as in the destructor. Tests can force additional validations
+// by calling VerifyExpectedTimings.
+//
+// Expected PageLoadTimings are specified via ExpectPageLoadTiming, and actual
+// PageLoadTimings are dispatched through Send(). When Send() is called, we
+// verify that the actual PageLoadTimings dipatched through Send() match the
+// expected PageLoadTimings provided via ExpectPageLoadTiming.
+//
+// Normally, gmock would be used in place of this class, but gmock is not
+// compatible with structures that use aligned memory, and PageLoadTiming will
+// soon use base::Optional which uses aligned memory, so we're forced to roll
+// our own implementation here.  See
+// https://groups.google.com/forum/#!topic/googletestframework/W-Hud3j_c6I for
+// more details.
+class FakePageTimingMetricsIPCSender : public IPC::Sender {
+ public:
+  FakePageTimingMetricsIPCSender();
+  ~FakePageTimingMetricsIPCSender() override;
+
+  // Implementation of IPC::Sender. PageLoadMetricsMsg_TimingUpdated IPCs that
+  // send updated PageLoadTimings should be dispatched through this method. This
+  // method will verify that all PageLoadTiming update IPCs dispatched so far
+  // match with the expected PageLoadTimings passed to ExpectPageLoadTiming.
+  bool Send(IPC::Message* message) override;
+
+  // PageLoadTimings that are expected to be sent through Send() should be
+  // passed to ExpectPageLoadTiming.
+  void ExpectPageLoadTiming(const PageLoadTiming& timing);
+
+  // Forces verification that actual timings sent through Send match
+  // expected timings provided via ExpectPageLoadTiming.
+  void VerifyExpectedTimings() const;
+
+  const std::vector<PageLoadTiming>& expected_timings() const {
+    return expected_timings_;
+  }
+  const std::vector<PageLoadTiming>& actual_timings() const {
+    return actual_timings_;
+  }
+
+ private:
+  void OnTimingUpdated(const PageLoadTiming& timing, PageLoadMetadata metadata);
+
+  std::vector<PageLoadTiming> expected_timings_;
+  std::vector<PageLoadTiming> actual_timings_;
+};
+
+}  // namespace page_load_metrics
+
+#endif  // COMPONENTS_PAGE_LOAD_METRICS_RENDERER_FAKE_PAGE_TIMING_METRICS_IPC_SENDER_H_

components/page_load_metrics/renderer/metrics_render_frame_observer_unittest.cc

@@ -10,41 +10,18 @@
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/timer/mock_timer.h"
-#include "components/page_load_metrics/common/page_load_metrics_messages.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
-#include "ipc/ipc_message_macros.h"
-#include "testing/gmock/include/gmock/gmock.h"
+#include "components/page_load_metrics/renderer/fake_page_timing_metrics_ipc_sender.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using testing::NiceMock;
-using testing::Return;
-using testing::StrictMock;
-
 namespace page_load_metrics {
 
-// IPC interceptor class, which we use to verify that certain IPC
-// messages get sent.
-class MockIPCInterceptor {
- public:
-  void OnMessage(const IPC::Message& message) {
-    IPC_BEGIN_MESSAGE_MAP(MockIPCInterceptor, message)
-      IPC_MESSAGE_HANDLER(PageLoadMetricsMsg_TimingUpdated, OnTimingUpdated)
-      IPC_MESSAGE_UNHANDLED(ADD_FAILURE())
-    IPC_END_MESSAGE_MAP()
-  }
-
-  MOCK_METHOD2(OnTimingUpdated, void(PageLoadTiming, PageLoadMetadata));
-};
-
 // 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 MockMetricsRenderFrameObserver : public MetricsRenderFrameObserver {
+class TestMetricsRenderFrameObserver : public MetricsRenderFrameObserver {
  public:
-  MockMetricsRenderFrameObserver() : MetricsRenderFrameObserver(nullptr) {
-    ON_CALL(*this, ShouldSendMetrics()).WillByDefault(Return(true));
-    ON_CALL(*this, HasNoRenderFrame()).WillByDefault(Return(false));
-  }
+  TestMetricsRenderFrameObserver() : MetricsRenderFrameObserver(nullptr) {}
 
   std::unique_ptr<base::Timer> CreateTimer() const override {
     if (!mock_timer_)
@@ -52,12 +29,11 @@ class MockMetricsRenderFrameObserver : public MetricsRenderFrameObserver {
     return std::move(mock_timer_);
   }
 
-  // We intercept sent messages and dispatch them to a MockIPCInterceptor, which
-  // we use to verify that the expected IPC messages get sent.
-  virtual bool Send(IPC::Message* message) {
-    interceptor_.OnMessage(*message);
-    delete message;
-    return true;
+  // 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) {
@@ -65,25 +41,35 @@ class MockMetricsRenderFrameObserver : public MetricsRenderFrameObserver {
     mock_timer_ = std::move(timer);
   }
 
-  MOCK_CONST_METHOD0(GetTiming, PageLoadTiming());
-  MOCK_CONST_METHOD0(ShouldSendMetrics, bool());
-  MOCK_CONST_METHOD0(HasNoRenderFrame, bool());
-  MockIPCInterceptor* ipc_interceptor() { return &interceptor_; }
+  void ExpectPageLoadTiming(const PageLoadTiming& timing) {
+    fake_timing_ipc_sender_.ExpectPageLoadTiming(timing);
+  }
+
+  PageLoadTiming GetTiming() const override {
+    return fake_timing_ipc_sender_.expected_timings().empty()
+               ? PageLoadTiming()
+               : fake_timing_ipc_sender_.expected_timings().back();
+  }
+
+  void VerifyExpectedTimings() const {
+    fake_timing_ipc_sender_.VerifyExpectedTimings();
+  }
+
+  bool ShouldSendMetrics() const override { return true; }
+  bool HasNoRenderFrame() const override { return false; }
 
  private:
-  StrictMock<MockIPCInterceptor> interceptor_;
+  FakePageTimingMetricsIPCSender fake_timing_ipc_sender_;
   mutable std::unique_ptr<base::Timer> mock_timer_;
 };
 
 typedef testing::Test MetricsRenderFrameObserverTest;
 
 TEST_F(MetricsRenderFrameObserverTest, NoMetrics) {
-  NiceMock<MockMetricsRenderFrameObserver> observer;
+  TestMetricsRenderFrameObserver observer;
   base::MockTimer* mock_timer = new base::MockTimer(false, false);
   observer.set_mock_timer(base::WrapUnique(mock_timer));
 
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(PageLoadTiming()));
-
   observer.DidChangePerformanceTiming();
   ASSERT_FALSE(mock_timer->IsRunning());
 }
@@ -92,23 +78,18 @@ TEST_F(MetricsRenderFrameObserverTest, SingleMetric) {
   base::Time nav_start = base::Time::FromDoubleT(10);
   base::TimeDelta first_layout = base::TimeDelta::FromMillisecondsD(10);
 
-  NiceMock<MockMetricsRenderFrameObserver> observer;
+  TestMetricsRenderFrameObserver observer;
   base::MockTimer* mock_timer = new base::MockTimer(false, false);
   observer.set_mock_timer(base::WrapUnique(mock_timer));
 
   PageLoadTiming timing;
   timing.navigation_start = nav_start;
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing));
+  observer.ExpectPageLoadTiming(timing);
   observer.DidCommitProvisionalLoad(true, false);
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing, PageLoadMetadata()));
   mock_timer->Fire();
 
   timing.first_layout = first_layout;
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing));
-
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing, PageLoadMetadata()));
+  observer.ExpectPageLoadTiming(timing);
 
   observer.DidChangePerformanceTiming();
   mock_timer->Fire();
@@ -120,43 +101,37 @@ TEST_F(MetricsRenderFrameObserverTest, MultipleMetrics) {
   base::TimeDelta dom_event = base::TimeDelta::FromMillisecondsD(2);
   base::TimeDelta load_event = base::TimeDelta::FromMillisecondsD(2);
 
-  NiceMock<MockMetricsRenderFrameObserver> observer;
+  TestMetricsRenderFrameObserver observer;
   base::MockTimer* mock_timer = new base::MockTimer(false, false);
   observer.set_mock_timer(base::WrapUnique(mock_timer));
 
   PageLoadTiming timing;
   timing.navigation_start = nav_start;
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing));
+  observer.ExpectPageLoadTiming(timing);
   observer.DidCommitProvisionalLoad(true, false);
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing, PageLoadMetadata()));
   mock_timer->Fire();
 
   timing.first_layout = first_layout;
   timing.dom_content_loaded_event_start = dom_event;
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing));
+  observer.ExpectPageLoadTiming(timing);
 
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing, PageLoadMetadata()));
   observer.DidChangePerformanceTiming();
   mock_timer->Fire();
 
   // At this point, we should have triggered the generation of two metrics.
   // Verify and reset the observer's expectations before moving on to the next
   // part of the test.
-  testing::Mock::VerifyAndClearExpectations(observer.ipc_interceptor());
+  observer.VerifyExpectedTimings();
 
   timing.load_event_start = load_event;
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing));
+  observer.ExpectPageLoadTiming(timing);
 
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing, PageLoadMetadata()));
   observer.DidChangePerformanceTiming();
   mock_timer->Fire();
 
   // Verify and reset the observer's expectations before moving on to the next
   // part of the test.
-  testing::Mock::VerifyAndClearExpectations(observer.ipc_interceptor());
+  observer.VerifyExpectedTimings();
 
   // The PageLoadTiming above includes timing information for the first layout,
   // dom content, and load metrics. However, since we've already generated
@@ -172,31 +147,27 @@ TEST_F(MetricsRenderFrameObserverTest, MultipleNavigations) {
   base::TimeDelta dom_event = base::TimeDelta::FromMillisecondsD(2);
   base::TimeDelta load_event = base::TimeDelta::FromMillisecondsD(2);
 
-  NiceMock<MockMetricsRenderFrameObserver> observer;
+  TestMetricsRenderFrameObserver observer;
   base::MockTimer* mock_timer = new base::MockTimer(false, false);
   observer.set_mock_timer(base::WrapUnique(mock_timer));
 
   PageLoadTiming timing;
   timing.navigation_start = nav_start;
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing));
+  observer.ExpectPageLoadTiming(timing);
   observer.DidCommitProvisionalLoad(true, false);
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing, PageLoadMetadata()));
   mock_timer->Fire();
 
   timing.first_layout = first_layout;
   timing.dom_content_loaded_event_start = dom_event;
   timing.load_event_start = load_event;
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing));
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing, PageLoadMetadata()));
+  observer.ExpectPageLoadTiming(timing);
   observer.DidChangePerformanceTiming();
   mock_timer->Fire();
 
   // At this point, we should have triggered the generation of two metrics.
   // Verify and reset the observer's expectations before moving on to the next
   // part of the test.
-  testing::Mock::VerifyAndClearExpectations(observer.ipc_interceptor());
+  observer.VerifyExpectedTimings();
 
   base::Time nav_start_2 = base::Time::FromDoubleT(100);
   base::TimeDelta first_layout_2 = base::TimeDelta::FromMillisecondsD(20);
@@ -208,19 +179,15 @@ TEST_F(MetricsRenderFrameObserverTest, MultipleNavigations) {
   base::MockTimer* mock_timer2 = new base::MockTimer(false, false);
   observer.set_mock_timer(base::WrapUnique(mock_timer2));
 
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing_2));
+  observer.ExpectPageLoadTiming(timing_2);
   observer.DidCommitProvisionalLoad(true, false);
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing_2, PageLoadMetadata()));
   mock_timer2->Fire();
 
   timing_2.first_layout = first_layout_2;
   timing_2.dom_content_loaded_event_start = dom_event_2;
   timing_2.load_event_start = load_event_2;
-  EXPECT_CALL(observer, GetTiming()).WillRepeatedly(Return(timing_2));
+  observer.ExpectPageLoadTiming(timing_2);
 
-  EXPECT_CALL(*observer.ipc_interceptor(),
-              OnTimingUpdated(timing_2, PageLoadMetadata()));
   observer.DidChangePerformanceTiming();
   mock_timer2->Fire();
 }

components/page_load_metrics/renderer/page_timing_metrics_sender_unittest.cc

@@ -6,31 +6,13 @@
 
 #include "base/time/time.h"
 #include "base/timer/mock_timer.h"
-#include "components/page_load_metrics/common/page_load_metrics_messages.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
+#include "components/page_load_metrics/renderer/fake_page_timing_metrics_ipc_sender.h"
 #include "ipc/ipc_message.h"
-#include "ipc/ipc_message_macros.h"
-#include "ipc/ipc_sender.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace page_load_metrics {
 
-class MockIPCSender : public IPC::Sender {
- public:
-  bool Send(IPC::Message* message) {
-    IPC_BEGIN_MESSAGE_MAP(MockIPCSender, *message)
-      IPC_MESSAGE_HANDLER(PageLoadMetricsMsg_TimingUpdated, OnTimingUpdated)
-      IPC_MESSAGE_UNHANDLED(ADD_FAILURE())
-    IPC_END_MESSAGE_MAP()
-
-    delete message;
-    return true;
-  }
-
-  MOCK_METHOD2(OnTimingUpdated, void(PageLoadTiming, PageLoadMetadata));
-};
-
 // Thin wrapper around PageTimingMetricsSender that provides access to the
 // MockTimer instance.
 class TestPageTimingMetricsSender : public PageTimingMetricsSender {
@@ -51,11 +33,12 @@ class TestPageTimingMetricsSender : public PageTimingMetricsSender {
 class PageTimingMetricsSenderTest : public testing::Test {
  public:
   PageTimingMetricsSenderTest()
-      : metrics_sender_(&mock_ipc_sender_, PageLoadTiming()) {}
+      : metrics_sender_(new TestPageTimingMetricsSender(&fake_ipc_sender_,
+                                                        PageLoadTiming())) {}
 
  protected:
-  testing::StrictMock<MockIPCSender> mock_ipc_sender_;
-  TestPageTimingMetricsSender metrics_sender_;
+  FakePageTimingMetricsIPCSender fake_ipc_sender_;
+  std::unique_ptr<TestPageTimingMetricsSender> metrics_sender_;
 };
 
 TEST_F(PageTimingMetricsSenderTest, Basic) {
@@ -66,21 +49,21 @@ TEST_F(PageTimingMetricsSenderTest, Basic) {
   timing.navigation_start = nav_start;
   timing.first_layout = first_layout;
 
-  metrics_sender_.Send(timing);
+  metrics_sender_->Send(timing);
 
   // Firing the timer should trigger sending of an OnTimingUpdated IPC.
-  EXPECT_CALL(mock_ipc_sender_, OnTimingUpdated(timing, PageLoadMetadata()));
-  ASSERT_TRUE(metrics_sender_.mock_timer()->IsRunning());
-  metrics_sender_.mock_timer()->Fire();
-  EXPECT_FALSE(metrics_sender_.mock_timer()->IsRunning());
+  fake_ipc_sender_.ExpectPageLoadTiming(timing);
+  ASSERT_TRUE(metrics_sender_->mock_timer()->IsRunning());
+  metrics_sender_->mock_timer()->Fire();
+  EXPECT_FALSE(metrics_sender_->mock_timer()->IsRunning());
 
   // At this point, we should have triggered the send of the PageLoadTiming IPC.
-  testing::Mock::VerifyAndClearExpectations(&mock_ipc_sender_);
+  fake_ipc_sender_.VerifyExpectedTimings();
 
   // Attempt to send the same timing instance again. The send should be
   // suppressed, since the timing instance hasn't changed since the last send.
-  metrics_sender_.Send(timing);
-  EXPECT_FALSE(metrics_sender_.mock_timer()->IsRunning());
+  metrics_sender_->Send(timing);
+  EXPECT_FALSE(metrics_sender_->mock_timer()->IsRunning());
 }
 
 TEST_F(PageTimingMetricsSenderTest, CoalesceMultipleIPCs) {
@@ -92,19 +75,19 @@ TEST_F(PageTimingMetricsSenderTest, CoalesceMultipleIPCs) {
   timing.navigation_start = nav_start;
   timing.first_layout = first_layout;
 
-  metrics_sender_.Send(timing);
-  ASSERT_TRUE(metrics_sender_.mock_timer()->IsRunning());
+  metrics_sender_->Send(timing);
+  ASSERT_TRUE(metrics_sender_->mock_timer()->IsRunning());
 
   // Send an updated PageLoadTiming before the timer has fired. When the timer
   // fires, the updated PageLoadTiming should be sent.
   timing.load_event_start = load_event;
-  metrics_sender_.Send(timing);
+  metrics_sender_->Send(timing);
 
   // Firing the timer should trigger sending of the OnTimingUpdated IPC with
   // the most recently provided PageLoadTiming instance.
-  EXPECT_CALL(mock_ipc_sender_, OnTimingUpdated(timing, PageLoadMetadata()));
-  metrics_sender_.mock_timer()->Fire();
-  EXPECT_FALSE(metrics_sender_.mock_timer()->IsRunning());
+  fake_ipc_sender_.ExpectPageLoadTiming(timing);
+  metrics_sender_->mock_timer()->Fire();
+  EXPECT_FALSE(metrics_sender_->mock_timer()->IsRunning());
 }
 
 TEST_F(PageTimingMetricsSenderTest, MultipleIPCs) {
@@ -116,21 +99,21 @@ TEST_F(PageTimingMetricsSenderTest, MultipleIPCs) {
   timing.navigation_start = nav_start;
   timing.first_layout = first_layout;
 
-  metrics_sender_.Send(timing);
-  ASSERT_TRUE(metrics_sender_.mock_timer()->IsRunning());
-  EXPECT_CALL(mock_ipc_sender_, OnTimingUpdated(timing, PageLoadMetadata()));
-  metrics_sender_.mock_timer()->Fire();
-  EXPECT_FALSE(metrics_sender_.mock_timer()->IsRunning());
-  testing::Mock::VerifyAndClearExpectations(&mock_ipc_sender_);
+  metrics_sender_->Send(timing);
+  ASSERT_TRUE(metrics_sender_->mock_timer()->IsRunning());
+  fake_ipc_sender_.ExpectPageLoadTiming(timing);
+  metrics_sender_->mock_timer()->Fire();
+  EXPECT_FALSE(metrics_sender_->mock_timer()->IsRunning());
+  fake_ipc_sender_.VerifyExpectedTimings();
 
   // Send an updated PageLoadTiming after the timer for the first send request
   // has fired, and verify that a second IPC is sent.
   timing.load_event_start = load_event;
-  metrics_sender_.Send(timing);
-  ASSERT_TRUE(metrics_sender_.mock_timer()->IsRunning());
-  EXPECT_CALL(mock_ipc_sender_, OnTimingUpdated(timing, PageLoadMetadata()));
-  metrics_sender_.mock_timer()->Fire();
-  EXPECT_FALSE(metrics_sender_.mock_timer()->IsRunning());
+  metrics_sender_->Send(timing);
+  ASSERT_TRUE(metrics_sender_->mock_timer()->IsRunning());
+  fake_ipc_sender_.ExpectPageLoadTiming(timing);
+  metrics_sender_->mock_timer()->Fire();
+  EXPECT_FALSE(metrics_sender_->mock_timer()->IsRunning());
 }
 
 TEST_F(PageTimingMetricsSenderTest, SendIPCOnDestructor) {
@@ -139,11 +122,14 @@ TEST_F(PageTimingMetricsSenderTest, SendIPCOnDestructor) {
   timing.first_layout = base::TimeDelta::FromMilliseconds(10);
 
   // This test wants to verify behavior in the PageTimingMetricsSender
-  // destructor, the EXPECT_CALL will be verified when the test tears down and
-  // |metrics_sender_| goes out of scope.
-  metrics_sender_.Send(timing);
-  EXPECT_CALL(mock_ipc_sender_, OnTimingUpdated(timing, PageLoadMetadata()));
-  ASSERT_TRUE(metrics_sender_.mock_timer()->IsRunning());
+  // destructor. The EXPECT_CALL will be satisfied when the |metrics_sender_|
+  // is destroyed below.
+  metrics_sender_->Send(timing);
+  fake_ipc_sender_.ExpectPageLoadTiming(timing);
+  ASSERT_TRUE(metrics_sender_->mock_timer()->IsRunning());
+
+  // Destroy |metrics_sender_|, in order to force its destructor to run.
+  metrics_sender_.reset();
 }
 
 }  // namespace page_load_metrics