Convert PageLoadMetrics to Mojo

components/page_load_metrics/browser/metrics_web_contents_observer.h

 // 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.
 
 #ifndef COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_
 #define COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_
 
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "components/page_load_metrics/browser/page_load_metrics_observer.h"
+#include "components/page_load_metrics/common/page_load_metrics.mojom.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
 #include "content/public/browser/render_widget_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 "mojo/public/cpp/bindings/binding.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 namespace content {
 class NavigationHandle;
 class RenderFrameHost;
 }  // namespace content
 
 namespace IPC {
 class Message;
 }  // namespace IPC
 
 namespace page_load_metrics {
 
+class MetricsWebContentsObserver;
 class PageLoadTracker;
 
 namespace internal {
 
 extern const char kErrorEvents[];
 extern const char kAbortChainSizeReload[];
 extern const char kAbortChainSizeForwardBack[];
 extern const char kAbortChainSizeNewNavigation[];
 extern const char kAbortChainSizeNoCommit[];
 extern const char kAbortChainSizeSameURL[];
@@ skipping 203 matching lines @@
   const int aborted_chain_size_same_url_;
 
   // Interface to chrome features. Must outlive the class.
   PageLoadMetricsEmbedderInterface* const embedder_interface_;
 
   std::vector<std::unique_ptr<PageLoadMetricsObserver>> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(PageLoadTracker);
 };
 
+class PageLoadMetricsImpl : public mojom::PageLoadMetrics {

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

Can you move this definition into the .cc file?

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

Done.

+ public:
+  // Does not take ownership of the arguments, which need to outlive this
+  // object.
+  PageLoadMetricsImpl(MetricsWebContentsObserver* observer,
+                      content::RenderFrameHost* host);
+  ~PageLoadMetricsImpl() override;
+
+  void Bind(mojo::InterfaceRequest<mojom::PageLoadMetrics> request);
+
+  // mojom::PageLoadMetrics override.
+  void TimingUpdated(const PageLoadTiming& timing,
+                     const PageLoadMetadata& metadata) override;
+
+ private:
+  MetricsWebContentsObserver* observer_;

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

const

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

We call OnTimingUpdated, which isn't const.

+  content::RenderFrameHost* host_;

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

const

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

OnTimingUpdated takes a non-const RFH.

+  mojo::Binding<mojom::PageLoadMetrics> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(PageLoadMetricsImpl);
+};
+
 // MetricsWebContentsObserver tracks page loads and loading metrics
 // related data based on IPC messages received from a
 // MetricsRenderFrameObserver.
 class MetricsWebContentsObserver
     : public content::WebContentsObserver,
       public content::WebContentsUserData<MetricsWebContentsObserver>,
       public content::RenderWidgetHost::InputEventObserver {
  public:
   // Note that the returned metrics is owned by the web contents.
   static MetricsWebContentsObserver* CreateForWebContents(
       content::WebContents* web_contents,
       std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface);
   MetricsWebContentsObserver(
       content::WebContents* web_contents,
       std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface);
   ~MetricsWebContentsObserver() override;
 
   // content::WebContentsObserver implementation:
-  bool OnMessageReceived(const IPC::Message& message,
-                         content::RenderFrameHost* render_frame_host) override;
+  void RenderFrameCreated(content::RenderFrameHost* render_frame_host) override;
+  void RenderFrameHostChanged(content::RenderFrameHost* old_host,
+                              content::RenderFrameHost* new_host) override;
+  void WebContentsDestroyed() override;
   void DidStartNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidFinishNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidRedirectNavigation(
       content::NavigationHandle* navigation_handle) override;
   void NavigationStopped() override;
   void OnInputEvent(const blink::WebInputEvent& event) override;
   void WasShown() override;
   void WasHidden() override;
   void RenderProcessGone(base::TerminationStatus status) override;
   void RenderViewHostChanged(content::RenderViewHost* old_host,
                              content::RenderViewHost* new_host) override;
 
   // This getter function is required for testing.
   const PageLoadExtraInfo GetPageLoadExtraInfoForCommittedLoad();
 
+  // Exposed for testing.
+  void OnTimingUpdated(content::RenderFrameHost*,
+                       const PageLoadTiming& timing,
+                       const PageLoadMetadata& metadata);
+
  private:
   friend class content::WebContentsUserData<MetricsWebContentsObserver>;
+  friend class MetricsWebContentsObserverTest;
 
   // Notify all loads, provisional and committed, that we performed an action
   // that might abort them.
   void NotifyAbortAllLoads(UserAbortType abort_type);
   void NotifyAbortAllLoadsWithTimestamp(UserAbortType abort_type,
                                         base::TimeTicks timestamp,
                                         bool is_certainly_browser_timestamp);
 
   // Register / Unregister input event callback to given RenderViewHost
   void RegisterInputEventObserver(content::RenderViewHost* host);
   void UnregisterInputEventObserver(content::RenderViewHost* host);
 
   // Notify aborted provisional loads that a new navigation occurred. This is
   // used for more consistent attribution tracking for aborted provisional
   // loads. This method returns the provisional load that was likely aborted
   // by this navigation, to help instantiate the new PageLoadTracker.
   std::unique_ptr<PageLoadTracker> NotifyAbortedProvisionalLoadsNewNavigation(
       content::NavigationHandle* new_navigation);
 
-  void OnTimingUpdated(content::RenderFrameHost*,
-                       const PageLoadTiming& timing,
-                       const PageLoadMetadata& metadata);
+  // Create and register a new PageLoadMetricsImpl, listening for messages to
+  // |host|.
+  void CreateRegisteredInterface(content::RenderFrameHost* host);
 
   // True if the web contents is currently in the foreground.
   bool in_foreground_;
 
   // The PageLoadTrackers must be deleted before the |embedded_interface_|,
   // because they hold a pointer to the |embedder_interface_|.
   std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface_;
 
   // This map tracks all of the navigations ongoing that are not committed
   // yet. Once a navigation is committed, it moves from the map to
   // committed_load_. Note that a PageLoadTrackers NavigationHandle is only
   // valid until commit time, when we remove it from the map.
   std::map<content::NavigationHandle*, std::unique_ptr<PageLoadTracker>>
       provisional_loads_;
 
   // Tracks aborted provisional loads for a little bit longer than usual (one
   // more navigation commit at the max), in order to better understand how the
   // navigation failed. This is because most provisional loads are destroyed
   // and vanish before we get signal about what caused the abort (new
   // navigation, stop button, etc.).
   std::vector<std::unique_ptr<PageLoadTracker>> aborted_provisional_loads_;
 
   std::unique_ptr<PageLoadTracker> committed_load_;
 
   // Has the MWCO observed at least one navigation?
   bool has_navigated_;
 
+  // Interface implementations we need to delete.
+  std::vector<std::unique_ptr<PageLoadMetricsImpl>> registered_interfaces_;
+
   DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserver);
 };
 
 }  // namespace page_load_metrics
 
 #endif  // COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_