Correctly record and pass around navigation start time.

components/web_view/frame.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/web_view/frame.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 78 matching lines @@
   if (view_) {
     view_->ClearLocalProperty(kFrame);
     if (view_ownership_ == ViewOwnership::OWNS_VIEW)
       view_->Destroy();
   }
   tree_->delegate_->DidDestroyFrame(this);
 }
 
 void Frame::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) {
   {
     // Set the FrameClient to null so that we don't notify the client of the
     // add before OnConnect().
     base::AutoReset<mojom::FrameClient*> frame_client_resetter(&frame_client_,
                                                                nullptr);
     if (parent)
       parent->Add(this);
   }
 
   const ClientType client_type = frame_request.is_pending()
                                      ? ClientType::NEW_CHILD_FRAME
                                      : ClientType::EXISTING_FRAME_NEW_APP;
   InitClient(client_type, nullptr, view_tree_client.Pass(),
-             frame_request.Pass());
+             frame_request.Pass(), navigation_start_time);
 
   tree_->delegate_->DidCreateFrame(this);
 
   DVLOG(2) << "Frame id=" << id_ << " parent=" << (parent_ ? parent_->id_ : 0)
            << " app_id=" << app_id_ << " this=" << this;
 }
 
 // static
 Frame* Frame::FindFirstFrameAncestor(View* view) {
   while (view && !view->GetLocalProperty(kFrame))
@@ skipping 59 matching lines @@
                                       reset);
 }
 
 void Frame::StopHighlightingFindResults() {
   frame_client_->StopHighlightingFindResults();
 }
 
 void Frame::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) {
   if (client_type == ClientType::EXISTING_FRAME_NEW_APP &&
       view_tree_client.get()) {
     embedded_connection_id_ = kInvalidConnectionId;
     embed_weak_ptr_factory_.InvalidateWeakPtrs();
     view_->Embed(
         view_tree_client.Pass(), mojo::ViewTree::ACCESS_POLICY_DEFAULT,
         base::Bind(&Frame::OnEmbedAck, embed_weak_ptr_factory_.GetWeakPtr()));
   }
 
   if (client_type == ClientType::NEW_CHILD_FRAME) {
     // Don't install an error handler. We allow for the target to only
     // implement ViewTreeClient.
     // This frame (and client) was created by an existing FrameClient. There
     // is no need to send it OnConnect().
     frame_binding_.reset(
         new mojo::Binding<mojom::Frame>(this, frame_request.Pass()));
     frame_client_->OnConnect(
         nullptr, tree_->change_id(), id_, mojom::VIEW_CONNECT_TYPE_USE_NEW,
         mojo::Array<mojom::FrameDataPtr>(),
+        navigation_start_time.ToInternalValue(),
         base::Bind(&OnConnectAck, base::Passed(&data_and_binding)));
   } else {
     std::vector<const Frame*> frames;
     tree_->root()->BuildFrameTree(&frames);
 
     mojo::Array<mojom::FrameDataPtr> array(frames.size());
     for (size_t i = 0; i < frames.size(); ++i)
       array[i] = FrameToFrameData(frames[i]).Pass();
 
     mojom::FramePtr frame_ptr;
     // Don't install an error handler. We allow for the target to only
     // implement ViewTreeClient.
     frame_binding_.reset(
         new mojo::Binding<mojom::Frame>(this, GetProxy(&frame_ptr).Pass()));
     frame_client_->OnConnect(
         frame_ptr.Pass(), tree_->change_id(), id_,
         client_type == ClientType::EXISTING_FRAME_SAME_APP
             ? mojom::VIEW_CONNECT_TYPE_USE_EXISTING
             : mojom::VIEW_CONNECT_TYPE_USE_NEW,
-        array.Pass(),
+        array.Pass(), navigation_start_time.ToInternalValue(),
         base::Bind(&OnConnectAck, base::Passed(&data_and_binding)));
     tree_->delegate_->DidStartNavigation(this);
 
     // We need |embedded_connection_id_| is order to validate requests to
     // create a child frame (OnCreatedFrame()). Pause incoming methods until
     // we get the id to prevent race conditions.
     if (embedded_connection_id_ == kInvalidConnectionId)
       frame_binding_->PauseIncomingMethodCallProcessing();
   }
 }
 
 // static
 void Frame::OnConnectAck(scoped_ptr<FrameUserDataAndBinding> data_and_binding) {
 }
 
 void Frame::ChangeClient(mojom::FrameClient* frame_client,
                          scoped_ptr<FrameUserData> user_data,
                          mojo::ViewTreeClientPtr view_tree_client,
-                         uint32_t app_id) {
+                         uint32_t app_id,
+                         base::TimeTicks navigation_start_time) {
   while (!children_.empty())
     delete children_[0];
 
   ClientType client_type = view_tree_client.get() == nullptr
                                ? ClientType::EXISTING_FRAME_SAME_APP
                                : ClientType::EXISTING_FRAME_NEW_APP;
   scoped_ptr<FrameUserDataAndBinding> data_and_binding;
 
   if (client_type == ClientType::EXISTING_FRAME_SAME_APP) {
     // See comment in InitClient() for details.
     data_and_binding.reset(new FrameUserDataAndBinding);
     data_and_binding->user_data = user_data_.Pass();
     data_and_binding->frame_binding = frame_binding_.Pass();
   } else {
     loading_ = false;
     progress_ = 0.f;
   }
 
   user_data_ = user_data.Pass();
   frame_client_ = frame_client;
   frame_binding_.reset();
   app_id_ = app_id;
 
   InitClient(client_type, data_and_binding.Pass(), view_tree_client.Pass(),
-             nullptr);
+             nullptr, navigation_start_time);
 }
 
 void Frame::OnEmbedAck(bool success, mus::ConnectionSpecificId connection_id) {
   if (success)
     embedded_connection_id_ = connection_id;
   if (frame_binding_->is_bound())
     frame_binding_->ResumeIncomingMethodCallProcessing();
 }
 
 void Frame::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) {
   DCHECK(waiting_for_on_will_navigate_ack_);
   DVLOG(2) << "Frame::OnWillNavigateAck id=" << id_;
   waiting_for_on_will_navigate_ack_ = false;
-  ChangeClient(frame_client, user_data.Pass(), view_tree_client.Pass(), app_id);
+  ChangeClient(frame_client, user_data.Pass(), view_tree_client.Pass(), app_id,
+               navigation_start_time);
   if (pending_navigate_.get())
     StartNavigate(pending_navigate_.Pass());
 }
 
 void Frame::SetView(mus::View* view) {
   DCHECK(!view_);
   DCHECK_EQ(id_, view->id());
   view_ = view;
   view_->SetLocalProperty(kFrame, this);
   view_->AddObserver(this);
@@ skipping 42 matching lines @@
     pending_navigate_ = request.Pass();
     return;
   }
 
   // Drop any pending navigation requests.
   navigate_weak_ptr_factory_.InvalidateWeakPtrs();
 
   DVLOG(2) << "Frame::StartNavigate id=" << id_ << " url=" << request->url;
 
   const GURL requested_url(request->url);
+  base::TimeTicks navigation_start_time =
+      base::TimeTicks::FromInternalValue(request->originating_time_ticks);
   tree_->delegate_->CanNavigateFrame(
-      this, request.Pass(),
-      base::Bind(&Frame::OnCanNavigateFrame,
-                 navigate_weak_ptr_factory_.GetWeakPtr(), requested_url));
+      this, request.Pass(), base::Bind(&Frame::OnCanNavigateFrame,
+                                       navigate_weak_ptr_factory_.GetWeakPtr(),
+                                       requested_url, navigation_start_time));
 }
 
 void Frame::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) {
   DVLOG(2) << "Frame::OnCanNavigateFrame id=" << id_
            << " equal=" << (AreAppIdsEqual(app_id, app_id_) ? "true" : "false");
   if (AreAppIdsEqual(app_id, app_id_)) {
     // The app currently rendering the frame will continue rendering it. In this
     // case we do not use the ViewTreeClient (because the app has a View already
     // and ends up reusing it).
     DCHECK(!view_tree_client.get());
     ChangeClient(frame_client, user_data.Pass(), view_tree_client.Pass(),
-                 app_id);
+                 app_id, navigation_start_time);
   } else {
     waiting_for_on_will_navigate_ack_ = true;
     DCHECK(view_tree_client.get());
     // TODO(sky): url isn't correct here, it should be a security origin.
-    frame_client_->OnWillNavigate(url.spec(), base::Bind(
-        &Frame::OnWillNavigateAck, base::Unretained(this), frame_client,
-        base::Passed(&user_data), base::Passed(&view_tree_client), app_id));
+    frame_client_->OnWillNavigate(
+        url.spec(),
+        base::Bind(&Frame::OnWillNavigateAck, base::Unretained(this),
+                   frame_client, base::Passed(&user_data),
+                   base::Passed(&view_tree_client), app_id,
+                   navigation_start_time));
   }
 }
 
 void Frame::NotifyAdded(const Frame* source,
                         const Frame* added_node,
                         uint32_t change_id) {
   // |frame_client_| may be null during initial frame creation and parenting.
   if (frame_client_)
     frame_client_->OnFrameAdded(change_id, FrameToFrameData(added_node));
 
@@ skipping 183 matching lines @@
                                               final_update);
 }
 
 void Frame::OnFindInPageSelectionUpdated(int32_t request_id,
                                          int32_t active_match_ordinal) {
   tree_->delegate_->OnFindInPageSelectionUpdated(request_id, this,
                                                  active_match_ordinal);
 }
 
 }  // namespace web_view