Correctly record and pass around navigation start time.

components/web_view/frame.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_WEB_VIEW_FRAME_H_
 #define COMPONENTS_WEB_VIEW_FRAME_H_
 
 #include <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
 #include "components/mus/public/cpp/types.h"
 #include "components/mus/public/cpp/view_observer.h"
 #include "components/web_view/public/interfaces/frame.mojom.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
 
 class GURL;
 
 namespace web_view {
 
 class FrameTest;
@@ skipping 38 matching lines @@
         uint32_t frame_id,
         uint32_t app_id,
         ViewOwnership view_ownership,
         mojom::FrameClient* frame_client,
         scoped_ptr<FrameUserData> user_data,
         const ClientPropertyMap& client_properties);
   ~Frame() override;
 
   void Init(Frame* parent,
             mojo::ViewTreeClientPtr view_tree_client,
-            mojo::InterfaceRequest<mojom::Frame> frame_request);
+            mojo::InterfaceRequest<mojom::Frame> frame_request,
+            base::TimeTicks navigation_start_time);
 
   // Walks the View tree starting at |view| going up returning the first
   // Frame that is associated with |view|. For example, if |view|
   // has a Frame associated with it, then that is returned. Otherwise
   // this checks view->parent() and so on.
   static Frame* FindFirstFrameAncestor(mus::View* view);
 
   FrameTree* tree() { return tree_; }
 
   Frame* parent() { return parent_; }
@@ skipping 66 matching lines @@
   // and is destroyed after the connection responds to OnConnect().
   //
   // If |client_type| is SAME_APP we can't destroy the existing client
   // (and related data) until we get back the ack from OnConnect(). This way
   // we know the client has completed the switch. If we did not do this it
   // would be possible for the app to see it's existing Frame connection lost
   // (and assume the frame is being torn down) before the OnConnect().
   void InitClient(ClientType client_type,
                   scoped_ptr<FrameUserDataAndBinding> data_and_binding,
                   mojo::ViewTreeClientPtr view_tree_client,
-                  mojo::InterfaceRequest<mojom::Frame> frame_request);
+                  mojo::InterfaceRequest<mojom::Frame> frame_request,
+                  base::TimeTicks navigation_start_time);
 
   // Callback from OnConnect(). This does nothing (other than destroying
   // |data_and_binding|). See InitClient() for details as to why destruction of
   // |data_and_binding| happens after OnConnect().
   static void OnConnectAck(
       scoped_ptr<FrameUserDataAndBinding> data_and_binding);
 
   // Callback from OnEmbed().
   void OnEmbedAck(bool success, mus::ConnectionSpecificId connection_id);
 
   // Callback from Frame::OnWillNavigate(). Completes navigation.
   void OnWillNavigateAck(mojom::FrameClient* frame_client,
                          scoped_ptr<FrameUserData> user_data,
                          mojo::ViewTreeClientPtr view_tree_client,
-                         uint32 app_id);
+                         uint32 app_id,
+                         base::TimeTicks navigation_start_time);
 
   // Completes a navigation request; swapping the existing FrameClient to the
   // supplied arguments.
   void ChangeClient(mojom::FrameClient* frame_client,
                     scoped_ptr<FrameUserData> user_data,
                     mojo::ViewTreeClientPtr view_tree_client,
-                    uint32 app_id);
+                    uint32 app_id,
+                    base::TimeTicks navigation_start_time);
 
   void SetView(mus::View* view);
 
   // Adds this to |frames| and recurses through the children calling the
   // same function.
   void BuildFrameTree(std::vector<const Frame*>* frames) const;
 
   void Add(Frame* node);
   void Remove(Frame* node);
 
   // Starts a new navigation to |request|. The navigation proceeds as long
   // as there is a View and once OnWillNavigate() has returned. If there is
   // no View the navigation waits until the View is available.
   void StartNavigate(mojo::URLRequestPtr request);
   void OnCanNavigateFrame(const GURL& url,
+                          base::TimeTicks navigation_start_time,
                           uint32_t app_id,
                           mojom::FrameClient* frame_client,
                           scoped_ptr<FrameUserData> user_data,
                           mojo::ViewTreeClientPtr view_tree_client);
 
   // Notifies the client and all descendants as appropriate.
   void NotifyAdded(const Frame* source,
                    const Frame* added_node,
                    uint32_t change_id);
   void NotifyRemoved(const Frame* source,
@@ skipping 68 matching lines @@
   base::WeakPtrFactory<Frame> embed_weak_ptr_factory_;
 
   base::WeakPtrFactory<Frame> navigate_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Frame);
 };
 
 }  // namespace web_view
 
 #endif  // COMPONENTS_WEB_VIEW_FRAME_H_