Reland of Break page load metrics test dependency on IPC.

chrome/browser/page_load_metrics/metrics_web_contents_observer.cc

 // Copyright 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/browser/page_load_metrics/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 #include <utility>
@@ skipping 46 matching lines @@
 
   return UserInitiatedInfo::RenderInitiated(
       navigation_handle->HasUserGesture(),
       committed_load &&
           committed_load->input_tracker()->FindAndConsumeInputEventsBefore(
               navigation_handle->NavigationStart()));
 }
 
 }  // namespace
 
-// static
 MetricsWebContentsObserver::MetricsWebContentsObserver(
     content::WebContents* web_contents,
     std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface)
     : content::WebContentsObserver(web_contents),
       in_foreground_(false),
       embedder_interface_(std::move(embedder_interface)),
       has_navigated_(false) {
   RegisterInputEventObserver(web_contents->GetRenderViewHost());
 }
 
+// static
 MetricsWebContentsObserver* MetricsWebContentsObserver::CreateForWebContents(
     content::WebContents* web_contents,
     std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface) {
   DCHECK(web_contents);
 
   MetricsWebContentsObserver* metrics = FromWebContents(web_contents);
   if (!metrics) {
     metrics = new MetricsWebContentsObserver(web_contents,
                                              std::move(embedder_interface));
     web_contents->SetUserData(UserDataKey(), metrics);
   }
   return metrics;
 }
 
 MetricsWebContentsObserver::~MetricsWebContentsObserver() {
   // TODO(csharrison): Use a more user-initiated signal for CLOSE.
   NotifyPageEndAllLoads(END_CLOSE, UserInitiatedInfo::NotUserInitiated());
+
+  for (auto& observer : testing_observers_)
+    observer.OnGoingAway();
 }
 
 void MetricsWebContentsObserver::RegisterInputEventObserver(
     content::RenderViewHost* host) {
   if (host != nullptr)
     host->GetWidget()->AddInputEventObserver(this);
 }
 
 void MetricsWebContentsObserver::UnregisterInputEventObserver(
     content::RenderViewHost* host) {
@@ skipping 467 matching lines @@
   if (render_frame_host->GetParent() != nullptr) {
     // Child frames may send PageLoadMetadata updates, but not PageLoadTiming
     // updates.
     if (!timing.IsEmpty())
       RecordInternalError(ERR_TIMING_IPC_FROM_SUBFRAME);
     committed_load_->UpdateChildFrameMetadata(metadata);
     return;
   }
 
   committed_load_->UpdateTiming(timing, metadata);
+
+  for (auto& observer : testing_observers_)
+    observer.OnTimingUpdated(timing, metadata);
 }
 
 bool MetricsWebContentsObserver::ShouldTrackNavigation(
     content::NavigationHandle* navigation_handle) const {
   DCHECK(navigation_handle->IsInMainFrame());
   DCHECK(!navigation_handle->HasCommitted() ||
          !navigation_handle->IsSameDocument());
 
   return BrowserPageTrackDecider(embedder_interface_.get(), web_contents(),
                                  navigation_handle).ShouldTrack();
 }
 
+void MetricsWebContentsObserver::AddTestingObserver(TestingObserver* observer) {
+  if (!testing_observers_.HasObserver(observer))
+    testing_observers_.AddObserver(observer);
+}
+
+void MetricsWebContentsObserver::RemoveTestingObserver(
+    TestingObserver* observer) {
+  testing_observers_.RemoveObserver(observer);
+}
+
+MetricsWebContentsObserver::TestingObserver::TestingObserver(
+    content::WebContents* web_contents)
+    : observer_(page_load_metrics::MetricsWebContentsObserver::FromWebContents(
+          web_contents)) {
+  observer_->AddTestingObserver(this);
+}
+
+MetricsWebContentsObserver::TestingObserver::~TestingObserver() {
+  if (observer_) {
+    observer_->RemoveTestingObserver(this);
+    observer_ = nullptr;
+  }
+}
+
+void MetricsWebContentsObserver::TestingObserver::OnGoingAway() {
+  observer_ = nullptr;
+}
+
 }  // namespace page_load_metrics