Convert PageLoadMetrics to Mojo

components/page_load_metrics/browser/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 "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "components/page_load_metrics/browser/page_load_metrics_util.h"
 #include "components/page_load_metrics/common/page_load_metrics_messages.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
 #include "content/public/browser/browser_thread.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"
 #include "content/public/browser/web_contents_user_data.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
+#include "services/shell/public/cpp/interface_registry.h"
 #include "ui/base/page_transition_types.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
     page_load_metrics::MetricsWebContentsObserver);
 
 namespace page_load_metrics {
 
 namespace internal {
 
 const char kErrorEvents[] = "PageLoad.Events.InternalError";
@@ skipping 526 matching lines @@
     return;
   }
   abort_type_ = abort_type;
   abort_time_ = timestamp;
 
   if (is_certainly_browser_timestamp) {
     ClampBrowserTimestampIfInterProcessTimeTickSkew(&abort_time_);
   }
 }
 
+PageLoadMetricsImpl::PageLoadMetricsImpl(MetricsWebContentsObserver* observer,
+                                         content::RenderFrameHost* host)
+    : observer_(observer), host_(host), binding_(this) {}
+
+PageLoadMetricsImpl::~PageLoadMetricsImpl() = default;
+
+void PageLoadMetricsImpl::Bind(
+    mojo::InterfaceRequest<mojom::PageLoadMetrics> request) {
+  binding_.Bind(std::move(request));
+}
+
+void PageLoadMetricsImpl::TimingUpdated(const PageLoadTiming& timing,
+                                        const PageLoadMetadata& metadata) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  observer_->OnTimingUpdated(host_, timing, metadata);
+}
+
 // 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());
 }
@@ skipping 28 matching lines @@
     host->GetWidget()->RemoveInputEventObserver(this);
 }
 
 void MetricsWebContentsObserver::RenderViewHostChanged(
     content::RenderViewHost* old_host,
     content::RenderViewHost* new_host) {
   UnregisterInputEventObserver(old_host);
   RegisterInputEventObserver(new_host);
 }
 
-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_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
 void MetricsWebContentsObserver::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
   if (embedder_interface_->IsPrerendering(web_contents()))
     return;
   if (navigation_handle->GetURL().spec().compare(url::kAboutBlankURL) == 0)
     return;
 
   std::unique_ptr<PageLoadTracker> last_aborted =
@@ skipping 229 matching lines @@
   aborted_provisional_loads_.pop_back();
 
   base::TimeTicks timestamp = new_navigation->NavigationStart();
   if (last_aborted_load->IsLikelyProvisionalAbort(timestamp))
     last_aborted_load->UpdateAbort(ABORT_UNKNOWN_NAVIGATION, timestamp, false);
 
   aborted_provisional_loads_.clear();
   return last_aborted_load;
 }
 
+void MetricsWebContentsObserver::RenderFrameCreated(
+    content::RenderFrameHost* render_frame_host) {
+  CreateRegisteredInterface(render_frame_host);
+}
+
+void MetricsWebContentsObserver::RenderFrameHostChanged(
+    content::RenderFrameHost* old_host,
+    content::RenderFrameHost* new_host) {
+  CreateRegisteredInterface(new_host);
+}
+void MetricsWebContentsObserver::WebContentsDestroyed() {
+  // At this point we no longer accept any more requests, as OnTimingUpdated
+  // requires the WebContents to exist.
+  registered_interfaces_.clear();
+}
+
+void MetricsWebContentsObserver::CreateRegisteredInterface(
+    content::RenderFrameHost* host) {
+  registered_interfaces_.push_back(

[Sam McNally, 2016/07/07 05:10:48]

Do you need to create the interface impls eagerly? Can you delay until a request
arrives?

These seem like they will accumulate as frames are created over the life of each
WebContents.

[tibell, 2016/07/08 01:12:53]

Done.

+      base::MakeUnique<PageLoadMetricsImpl>(this, host));
+  host->GetInterfaceRegistry()->AddInterface(
+      base::Bind(&PageLoadMetricsImpl::Bind,
+                 base::Unretained(registered_interfaces_.back().get())));
+}
+
 void MetricsWebContentsObserver::OnTimingUpdated(
     content::RenderFrameHost* render_frame_host,
     const PageLoadTiming& timing,
     const PageLoadMetadata& metadata) {
   bool error = false;
   if (!committed_load_ || !committed_load_->renderer_tracked()) {
     RecordInternalError(ERR_IPC_WITH_NO_RELEVANT_LOAD);
     error = true;
   }
 
@@ skipping 17 matching lines @@
 
   if (!committed_load_->UpdateTiming(timing, metadata)) {
     // If the page load tracker cannot update its timing, something is wrong
     // with the IPC (it's from another load, or it's invalid in some other way).
     // We expect this to be a rare occurrence.
     RecordInternalError(ERR_BAD_TIMING_IPC);
   }
 }
 
 }  // namespace page_load_metrics