[Page Load Metrics] PageLoadMetrics Mojofication.

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>
 
+#include "base/feature_list.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/page_load_metrics/browser_page_track_decider.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_embedder_interface.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
 #include "chrome/browser/page_load_metrics/page_load_tracker.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/page_load_metrics/page_load_metrics_messages.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
@@ skipping 34 matching lines @@
 }
 
 }  // namespace
 
 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) {
+      has_navigated_(false),
+      page_load_metrics_binding_(web_contents, this) {
   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);
@@ skipping 46 matching lines @@
         video_type, render_frame_host == web_contents()->GetMainFrame());
 }
 
 bool MetricsWebContentsObserver::OnMessageReceived(
     const IPC::Message& message,
     content::RenderFrameHost* render_frame_host) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(MetricsWebContentsObserver, message,
                                    render_frame_host)
-    IPC_MESSAGE_HANDLER(PageLoadMetricsMsg_TimingUpdated, OnTimingUpdated)
+    IPC_MESSAGE_HANDLER(PageLoadMetricsMsg_TimingUpdated, OnUpdateTimingOverIPC)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MetricsWebContentsObserver::WillStartNavigationRequest(
     content::NavigationHandle* navigation_handle) {
   // Same-document navigations should never go through
   // WillStartNavigationRequest.
   DCHECK(!navigation_handle->IsSameDocument());
@@ skipping 459 matching lines @@
   if (is_main_frame) {
     committed_load_->UpdateTiming(timing, metadata);
   } else {
     committed_load_->UpdateSubFrameTiming(render_frame_host, timing, metadata);
   }
 
   for (auto& observer : testing_observers_)
     observer.OnTimingUpdated(is_main_frame, timing, metadata);
 }
 
+void MetricsWebContentsObserver::OnUpdateTimingOverIPC(
+    content::RenderFrameHost* render_frame_host,
+    const mojom::PageLoadTiming& timing,
+    const mojom::PageLoadMetadata& metadata) {
+  DCHECK(!base::FeatureList::IsEnabled(features::kPageLoadMetricsMojofication));
+  OnTimingUpdated(render_frame_host, timing, metadata);
+
+  for (auto& observer : testing_observers_)
+    observer.DidReceiveTimingUpdate(TestingObserver::IPCType::LEGACY);
+}
+
+void MetricsWebContentsObserver::UpdateTiming(
+    const mojom::PageLoadTimingPtr timing,
+    const mojom::PageLoadMetadataPtr metadata) {
+  content::RenderFrameHost* render_frame_host =
+      page_load_metrics_binding_.GetCurrentTargetFrame();
+  DCHECK(base::FeatureList::IsEnabled(features::kPageLoadMetricsMojofication));
+  OnTimingUpdated(render_frame_host, *timing, *metadata);
+
+  for (auto& observer : testing_observers_)
+    observer.DidReceiveTimingUpdate(TestingObserver::IPCType::MOJO);
+}
+
 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();
 }
 
@@ skipping 19 matching lines @@
     observer_->RemoveTestingObserver(this);
     observer_ = nullptr;
   }
 }
 
 void MetricsWebContentsObserver::TestingObserver::OnGoingAway() {
   observer_ = nullptr;
 }
 
 }  // namespace page_load_metrics