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 <ostream>
 #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_metrics_param_traits.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 527 matching lines @@
     return;
   }
   abort_type_ = abort_type;
   abort_time_ = timestamp;
 
   if (is_certainly_browser_timestamp) {
     ClampBrowserTimestampIfInterProcessTimeTickSkew(&abort_time_);
   }
 }
 
+class MetricsWebContentsObserver::PageLoadMetricsImpl
+    : public mojom::PageLoadMetrics {
+ public:
+  // Does not take ownership of the arguments, which need to outlive this
+  // object.
+  PageLoadMetricsImpl(MetricsWebContentsObserver* observer,
+                      content::RenderFrameHost* host)
+      : observer_(observer), host_(host), binding_(this) {}
+  ~PageLoadMetricsImpl() override = default;
+
+  // Factory for creating PageLoadMetricsImpl objects upon incoming connections.
+  static void Create(MetricsWebContentsObserver* observer,
+                     content::RenderFrameHost* host,
+                     mojo::InterfaceRequest<mojom::PageLoadMetrics> request) {
+    auto impl = base::MakeUnique<PageLoadMetricsImpl>(observer, host);
+    impl->binding_.Bind(std::move(request));
+    observer->registered_interfaces_.push_back(std::move(impl));
+  }
+
+  // mojom::PageLoadMetrics override.
+  void TimingUpdated(const PageLoadTiming& timing,
+                     const PageLoadMetadata& metadata) override {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    observer_->OnTimingUpdated(host_, timing, metadata);
+  }
+
+ private:
+  MetricsWebContentsObserver* const observer_;
+  content::RenderFrameHost* const host_;
+  mojo::Binding<mojom::PageLoadMetrics> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(PageLoadMetricsImpl);
+};
+
 // 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;
 
   std::unique_ptr<PageLoadTracker> last_aborted =
       NotifyAbortedProvisionalLoadsNewNavigation(navigation_handle);
 
   int chain_size_same_url = 0;
   int chain_size = 0;
@@ skipping 237 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) {
+  RegisterInterfaceImpl(render_frame_host);
+}
+
+void MetricsWebContentsObserver::RenderFrameHostChanged(
+    content::RenderFrameHost* old_host,
+    content::RenderFrameHost* new_host) {
+  RegisterInterfaceImpl(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::RegisterInterfaceImpl(
+    content::RenderFrameHost* host) {
+  host->GetInterfaceRegistry()->AddInterface(
+      base::Bind(&PageLoadMetricsImpl::Create, base::Unretained(this),
+                 base::Unretained(host)));
+}
+
 void MetricsWebContentsObserver::OnTimingUpdated(
     content::RenderFrameHost* render_frame_host,
     const PageLoadTiming& timing,
     const PageLoadMetadata& metadata) {
   bool error = false;
   if (!committed_load_) {
     RecordInternalError(ERR_IPC_WITH_NO_RELEVANT_LOAD);
     error = true;
   }
 
@@ skipping 34 matching lines @@
     if (navigation_handle->IsSamePage() || navigation_handle->IsErrorPage())
       return false;
     const std::string& mime_type = web_contents()->GetContentsMimeType();
     if (mime_type != "text/html" && mime_type != "application/xhtml+xml")
       return false;
   }
   return true;
 }
 
 }  // namespace page_load_metrics