[Page Load Metrics] PageLoadMetrics Mojofication.

chrome/browser/page_load_metrics/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 CHROME_BROWSER_PAGE_LOAD_METRICS_METRICS_WEB_CONTENTS_OBSERVER_H_
 #define CHROME_BROWSER_PAGE_LOAD_METRICS_METRICS_WEB_CONTENTS_OBSERVER_H_
 
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
+#include "chrome/common/page_load_metrics/page_load_metrics.mojom.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_data.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_binding_set.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "content/public/common/resource_type.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 
 namespace content {
 class NavigationHandle;
 class RenderFrameHost;
 }  // namespace content
 
 namespace IPC {
 class Message;
 }  // namespace IPC
 
 namespace page_load_metrics {
 
 class PageLoadMetricsEmbedderInterface;
 class PageLoadTracker;
 
 // 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 content::RenderWidgetHost::InputEventObserver,
+      public mojom::PageLoadMetrics {
  public:
   // TestingObserver allows tests to observe MetricsWebContentsObserver state
   // changes. Tests may use TestingObserver to wait until certain state changes,
   // such as the arrivial of PageLoadTiming messages from the render process,
   // have been observed.
   class TestingObserver {
    public:
+    enum class IPCType { LEGACY, MOJO };
+
     explicit TestingObserver(content::WebContents* web_contents);
     virtual ~TestingObserver();
 
     void OnGoingAway();
 
     // Invoked when a new PageLoadTiming update has been received and processed.
     virtual void OnTimingUpdated(bool is_main_frame,
                                  const mojom::PageLoadTiming& timing,
                                  const mojom::PageLoadMetadata& metadata) {}
 
+    virtual void DidReceiveTimingUpdate(IPCType type) {}
+
    private:
     page_load_metrics::MetricsWebContentsObserver* observer_;
 
     DISALLOW_COPY_AND_ASSIGN(TestingObserver);
   };
 
   // Note that the returned metrics is owned by the web contents.
   static MetricsWebContentsObserver* CreateForWebContents(
       content::WebContents* web_contents,
       std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface);
@@ skipping 66 matching lines @@
   void RemoveTestingObserver(TestingObserver* observer);
 
   // public only for testing
   void OnTimingUpdated(content::RenderFrameHost* render_frame_host,
                        const mojom::PageLoadTiming& timing,
                        const mojom::PageLoadMetadata& metadata);
 
  private:
   friend class content::WebContentsUserData<MetricsWebContentsObserver>;
 
+  // page_load_metrics::mojom::PageLoadMetrics implementation.
+  void UpdateTiming(mojom::PageLoadTimingPtr timing,
+                    mojom::PageLoadMetadataPtr metadata) override;
+
+  // Called from legacy IPC.
+  void OnUpdateTimingOverIPC(content::RenderFrameHost* render_frame_host,
+                             const mojom::PageLoadTiming& timing,
+                             const mojom::PageLoadMetadata& metadata);
+
   void HandleFailedNavigationForTrackedLoad(
       content::NavigationHandle* navigation_handle,
       std::unique_ptr<PageLoadTracker> tracker);
 
   void HandleCommittedNavigationForTrackedLoad(
       content::NavigationHandle* navigation_handle,
       std::unique_ptr<PageLoadTracker> tracker);
 
   // Return a PageLoadTracker (either provisional or committed) that matches the
   // given request attributes, or nullptr if there are no matching
@@ skipping 47 matching lines @@
   // 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_;
 
   base::ObserverList<TestingObserver> testing_observers_;
+  content::WebContentsFrameBindingSet<mojom::PageLoadMetrics>
+      page_load_metrics_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserver);
 };
 
 }  // namespace page_load_metrics
 
 #endif  // CHROME_BROWSER_PAGE_LOAD_METRICS_METRICS_WEB_CONTENTS_OBSERVER_H_