[Page Load Metrics] Add mojom file to page load metrics.

chrome/browser/page_load_metrics/page_load_metrics_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_PAGE_LOAD_METRICS_OBSERVER_H_
 #define CHROME_BROWSER_PAGE_LOAD_METRICS_PAGE_LOAD_METRICS_OBSERVER_H_
 
 #include <memory>
 #include <string>
 
@@ skipping 104 matching lines @@
       const base::Optional<base::TimeDelta>& first_background_time,
       const base::Optional<base::TimeDelta>& first_foreground_time,
       bool started_in_foreground,
       UserInitiatedInfo user_initiated_info,
       const GURL& url,
       const GURL& start_url,
       bool did_commit,
       PageEndReason page_end_reason,
       UserInitiatedInfo page_end_user_initiated_info,
       const base::Optional<base::TimeDelta>& page_end_time,
-      const PageLoadMetadata& main_frame_metadata,
-      const PageLoadMetadata& subframe_metadata);
+      const mojom::PageLoadMetadata& main_frame_metadata,
+      const mojom::PageLoadMetadata& subframe_metadata);
 
   // Simplified version of the constructor, intended for use in tests.
   static PageLoadExtraInfo CreateForTesting(const GURL& url,
                                             bool started_in_foreground);
 
   PageLoadExtraInfo(const PageLoadExtraInfo& other);
 
   ~PageLoadExtraInfo();
 
   // The time the navigation was initiated.
@@ skipping 48 matching lines @@
   // * the page load is stopped
   // * the tab hosting the page is closed
   // * the render process hosting the page goes away
   // * a new navigation which later commits is initiated in the same tab
   // This field will not be set if the page is still active and hasn't yet
   // finished.
   const base::Optional<base::TimeDelta> page_end_time;
 
   // Extra information supplied to the page load metrics system from the
   // renderer for the main frame.
-  const PageLoadMetadata main_frame_metadata;
+  const mojom::PageLoadMetadata main_frame_metadata;
 
   // PageLoadMetadata for subframes of the current page load.
-  const PageLoadMetadata subframe_metadata;
+  const mojom::PageLoadMetadata subframe_metadata;
 };
 
 // Container for various information about a completed request within a page
 // load.
 struct ExtraRequestCompleteInfo {
   ExtraRequestCompleteInfo(
       const GURL& url,
       int frame_tree_node_id,
       bool was_cached,
       int64_t raw_body_bytes,
@@ skipping 94 matching lines @@
   // was a same document navigation, or has been replaced. It is up to the
   // observer to query |navigation_handle| to determine which happened. Note
   // that |navigation_handle| will be destroyed soon after this call. Don't
   // hold a reference to it.
   virtual ObservePolicy OnDidFinishSubFrameNavigation(
       content::NavigationHandle* navigation_handle);
 
   // OnHidden is triggered when a page leaves the foreground. It does not fire
   // when a foreground page is permanently closed; for that, listen to
   // OnComplete instead.
-  virtual ObservePolicy OnHidden(const PageLoadTiming& timing,
+  virtual ObservePolicy OnHidden(const mojom::PageLoadTiming& timing,
                                  const PageLoadExtraInfo& extra_info);
 
   // OnShown is triggered when a page is brought to the foreground. It does not
   // fire when the page first loads; for that, listen for OnStart instead.
   virtual ObservePolicy OnShown();
 
   // Called before OnCommit. The observer should return whether it wishes to
   // observe navigations whose main resource has MIME type |mine_type|. The
   // default is to observe HTML and XHTML only. Note that PageLoadTrackers only
   // track XHTML, HTML, and MHTML (related/multipart).
   virtual ObservePolicy ShouldObserveMimeType(
       const std::string& mime_type) const;
 
   // The callbacks below are only invoked after a navigation commits, for
   // tracked page loads. Page loads that don't meet the criteria for being
   // tracked at the time a navigation commits will not receive any of the
   // callbacks below.
 
   // OnTimingUpdate is triggered when an updated PageLoadTiming is
   // available. This method may be called multiple times over the course of the
   // page load. This method is currently only intended for use in testing. Most
   // implementers should implement one of the On* callbacks, such as
   // OnFirstContentfulPaint or OnDomContentLoadedEventStart. Please email
   // loading-dev@chromium.org if you intend to override this method.
-  virtual void OnTimingUpdate(const PageLoadTiming& timing,
+  virtual void OnTimingUpdate(const mojom::PageLoadTiming& timing,
                               const PageLoadExtraInfo& extra_info) {}
 
   // OnUserInput is triggered when a new user input is passed in to
   // web_contents. Contains a TimeDelta from navigation start.
   virtual void OnUserInput(const blink::WebInputEvent& event) {}
 
   // The following methods are invoked at most once, when the timing for the
   // associated event first becomes available.
   virtual void OnDomContentLoadedEventStart(
-      const PageLoadTiming& timing,
+      const mojom::PageLoadTiming& timing,
       const PageLoadExtraInfo& extra_info) {}
-  virtual void OnLoadEventStart(const PageLoadTiming& timing,
+  virtual void OnLoadEventStart(const mojom::PageLoadTiming& timing,
                                 const PageLoadExtraInfo& extra_info) {}
-  virtual void OnFirstLayout(const PageLoadTiming& timing,
+  virtual void OnFirstLayout(const mojom::PageLoadTiming& timing,
                              const PageLoadExtraInfo& extra_info) {}
-  virtual void OnParseStart(const PageLoadTiming& timing,
+  virtual void OnParseStart(const mojom::PageLoadTiming& timing,
                             const PageLoadExtraInfo& extra_info) {}
-  virtual void OnParseStop(const PageLoadTiming& timing,
+  virtual void OnParseStop(const mojom::PageLoadTiming& timing,
                            const PageLoadExtraInfo& extra_info) {}
 
   // On*PaintInPage(...) are invoked when the first relevant paint in the page,
   // across all frames, is observed.
-  virtual void OnFirstPaintInPage(const PageLoadTiming& timing,
+  virtual void OnFirstPaintInPage(const mojom::PageLoadTiming& timing,
                                   const PageLoadExtraInfo& extra_info) {}
-  virtual void OnFirstTextPaintInPage(const PageLoadTiming& timing,
+  virtual void OnFirstTextPaintInPage(const mojom::PageLoadTiming& timing,
                                       const PageLoadExtraInfo& extra_info) {}
-  virtual void OnFirstImagePaintInPage(const PageLoadTiming& timing,
+  virtual void OnFirstImagePaintInPage(const mojom::PageLoadTiming& timing,
                                        const PageLoadExtraInfo& extra_info) {}
   virtual void OnFirstContentfulPaintInPage(
-      const PageLoadTiming& timing,
+      const mojom::PageLoadTiming& timing,
       const PageLoadExtraInfo& extra_info) {}
 
   // Unlike other paint callbacks, OnFirstMeaningfulPaintInMainFrameDocument is
   // tracked per document, and is reported for the main frame document only.
   virtual void OnFirstMeaningfulPaintInMainFrameDocument(
-      const PageLoadTiming& timing,
+      const mojom::PageLoadTiming& timing,
       const PageLoadExtraInfo& extra_info) {}
 
   // Invoked when there is a change in either the main_frame_metadata or the
   // subframe_metadata's loading behavior_flags.
   virtual void OnLoadingBehaviorObserved(
       const page_load_metrics::PageLoadExtraInfo& extra_info) {}
 
   // Invoked when a media element starts playing.
   virtual void MediaStartedPlaying(
       const content::WebContentsObserver::MediaPlayerInfo& video_type,
@@ skipping 12 matching lines @@
   // the application may be killed at any time after this method is invoked
   // without further notification. Note that this may be called both for
   // provisional loads as well as committed loads. Implementations that only
   // want to track committed loads should check whether extra_info.committed_url
   // is empty to determine if the load had committed. If the implementation
   // returns CONTINUE_OBSERVING, this method may be called multiple times per
   // observer, once for each time that the application enters the backround.
   //
   // The default implementation does nothing, and returns CONTINUE_OBSERVING.
   virtual ObservePolicy FlushMetricsOnAppEnterBackground(
-      const PageLoadTiming& timing,
+      const mojom::PageLoadTiming& timing,
       const PageLoadExtraInfo& extra_info);
 
   // One of OnComplete or OnFailedProvisionalLoad is invoked for tracked page
   // loads, immediately before the observer is deleted. These callbacks will not
   // be invoked for page loads that did not meet the criteria for being tracked
   // at the time the navigation completed. The PageLoadTiming struct contains
   // timing data and the PageLoadExtraInfo struct contains other useful data
   // collected over the course of the page load. Most observers should not need
   // to implement these callbacks, and should implement the On* timing callbacks
   // instead.
 
   // OnComplete is invoked for tracked page loads that committed, immediately
   // before the observer is deleted. Observers that implement OnComplete may
   // also want to implement FlushMetricsOnAppEnterBackground, to avoid loss of
   // data if the application is killed while in the background (this happens
   // frequently on Android).
-  virtual void OnComplete(const PageLoadTiming& timing,
+  virtual void OnComplete(const mojom::PageLoadTiming& timing,
                           const PageLoadExtraInfo& extra_info) {}
 
   // OnFailedProvisionalLoad is invoked for tracked page loads that did not
   // commit, immediately before the observer is deleted.
   virtual void OnFailedProvisionalLoad(
       const FailedProvisionalLoadInfo& failed_provisional_load_info,
       const PageLoadExtraInfo& extra_info) {}
 
   // Called whenever a request load begins.
   virtual void OnStartedResource(
       const ExtraRequestStartInfo& extra_request_start_info) {}
 
   // Called whenever a request is loaded for this page load. This comes
   // unfiltered from the ResourceDispatcherHost and may include blob requests
   // and data uris.
   virtual void OnLoadedResource(
       const ExtraRequestCompleteInfo& extra_request_complete_info) {}
 };
 
 }  // namespace page_load_metrics
 
 #endif  // CHROME_BROWSER_PAGE_LOAD_METRICS_PAGE_LOAD_METRICS_OBSERVER_H_