Correctly record and pass around navigation start time.

components/web_view/frame_apptest.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 "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
+#include "base/time/time.h"
 #include "components/mus/public/cpp/view_observer.h"
 #include "components/mus/public/cpp/view_tree_connection.h"
 #include "components/mus/public/cpp/view_tree_delegate.h"
 #include "components/mus/public/cpp/view_tree_host_factory.h"
 #include "components/web_view/frame.h"
 #include "components/web_view/frame_connection.h"
 #include "components/web_view/frame_tree.h"
 #include "components/web_view/frame_tree_delegate.h"
 #include "components/web_view/frame_user_data.h"
 #include "components/web_view/test_frame_tree_delegate.h"
@@ skipping 94 matching lines @@
   void last_loading_state_changed_notification(uint32_t* frame_id,
                                                bool* loading) const {
     *frame_id = last_loading_state_changed_notification_.frame_id;
     *loading = last_loading_state_changed_notification_.loading;
   }
 
   uint32_t last_dispatch_load_event_frame_id() const {
     return last_dispatch_load_event_frame_id_;
   }
 
+  base::TimeTicks last_navigation_start_time() const {
+    return last_navigation_start_time_;
+  }
+
   // mojom::FrameClient:
   void OnConnect(mojom::FramePtr frame,
                  uint32_t change_id,
                  uint32_t view_id,
                  mojom::ViewConnectType view_connect_type,
                  mojo::Array<mojom::FrameDataPtr> frames,
+                 int64_t navigation_start_time_ticks,
                  const OnConnectCallback& callback) override {
     connect_count_++;
     connect_frames_ = frames.Pass();
     if (frame)
       server_frame_ = frame.Pass();
     callback.Run();
     if (!on_connect_callback_.is_null())
       on_connect_callback_.Run();
+
+    last_navigation_start_time_ =
+        base::TimeTicks::FromInternalValue(navigation_start_time_ticks);
   }
   void OnFrameAdded(uint32_t change_id, mojom::FrameDataPtr frame) override {
     adds_.push_back(frame.Pass());
   }
   void OnFrameRemoved(uint32_t change_id, uint32_t frame_id) override {}
   void OnFrameClientPropertyChanged(uint32_t frame_id,
                                     const mojo::String& name,
                                     mojo::Array<uint8_t> new_data) override {}
   void OnPostMessageEvent(uint32_t source_frame_id,
                           uint32_t target_frame_id,
@@ skipping 38 matching lines @@
 
   int connect_count_;
   mojo::Array<mojom::FrameDataPtr> connect_frames_;
   mojom::FramePtr server_frame_;
   mojo::Array<mojom::FrameDataPtr> adds_;
   base::Closure on_connect_callback_;
   base::Closure on_loading_state_changed_callback_;
   base::Closure on_dispatch_load_event_callback_;
   LoadingStateChangedNotification last_loading_state_changed_notification_;
   uint32_t last_dispatch_load_event_frame_id_;
+  base::TimeTicks last_navigation_start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(TestFrameClient);
 };
 
 class FrameTest;
 
 // ViewAndFrame maintains the View and TestFrameClient associated with
 // a single FrameClient. In other words this maintains the data structures
 // needed to represent a client side frame. To obtain one use
 // FrameTest::WaitForViewAndFrame().
@@ skipping 76 matching lines @@
   }
 
  protected:
   ViewTreeConnection* window_manager() { return window_manager_; }
   TestFrameTreeDelegate* frame_tree_delegate() {
     return frame_tree_delegate_.get();
   }
   FrameTree* frame_tree() { return frame_tree_.get(); }
   ViewAndFrame* root_view_and_frame() { return root_view_and_frame_.get(); }
 
-  scoped_ptr<ViewAndFrame> NavigateFrame(ViewAndFrame* view_and_frame) {
+  scoped_ptr<ViewAndFrame> NavigateFrameWithStartTime(
+      ViewAndFrame* view_and_frame,
+      base::TimeTicks navigation_start_time) {
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From(application_impl()->url());
+    request->originating_time_ticks = navigation_start_time.ToInternalValue();
     view_and_frame->server_frame()->RequestNavigate(
         mojom::NAVIGATION_TARGET_TYPE_EXISTING_FRAME,
         view_and_frame->view()->id(), request.Pass());
     return WaitForViewAndFrame();
   }
 
+  scoped_ptr<ViewAndFrame> NavigateFrame(ViewAndFrame* view_and_frame) {
+    return NavigateFrameWithStartTime(view_and_frame, base::TimeTicks());
+  }
+
   // Creates a new shared frame as a child of |parent|.
   scoped_ptr<ViewAndFrame> CreateChildViewAndFrame(ViewAndFrame* parent) {
     mus::View* child_frame_view = parent->view()->connection()->CreateView();
     parent->view()->AddChild(child_frame_view);
 
     scoped_ptr<ViewAndFrame> view_and_frame(new ViewAndFrame);
     view_and_frame->set_view(child_frame_view);
 
     mojo::Map<mojo::String, mojo::Array<uint8_t>> client_properties;
     client_properties.mark_non_null();
@@ skipping 45 matching lines @@
     // Creates a FrameTree, which creates a single frame. Wait for the
     // FrameClient to be connected to.
     frame_tree_delegate_.reset(new TestFrameTreeDelegate(application_impl()));
     scoped_ptr<FrameConnection> frame_connection =
         CreateFrameConnection(application_impl());
     mojom::FrameClient* frame_client = frame_connection->frame_client();
     mojo::ViewTreeClientPtr view_tree_client =
         frame_connection->GetViewTreeClient();
     mus::View* frame_root_view = window_manager()->CreateView();
     window_manager()->GetRoot()->AddChild(frame_root_view);
-    frame_tree_.reset(
-        new FrameTree(0u, frame_root_view, view_tree_client.Pass(),
-                      frame_tree_delegate_.get(), frame_client,
-                      frame_connection.Pass(), Frame::ClientPropertyMap()));
+    frame_tree_.reset(new FrameTree(
+        0u, frame_root_view, view_tree_client.Pass(),
+        frame_tree_delegate_.get(), frame_client, frame_connection.Pass(),
+        Frame::ClientPropertyMap(), base::TimeTicks::Now()));
     root_view_and_frame_ = WaitForViewAndFrame();
   }
 
   // Overridden from testing::Test:
   void TearDown() override {
     root_view_and_frame_.reset();
     frame_tree_.reset();
     frame_tree_delegate_.reset();
     ApplicationTestBase::TearDown();
   }
@@ skipping 145 matching lines @@
 
   child_view_and_frame->server_frame()->DispatchLoadEventToParent();
 
   run_loop.Run();
 
   uint32_t frame_id = root_view_and_frame()
                           ->test_frame_client()
                           ->last_dispatch_load_event_frame_id();
   EXPECT_EQ(child_frame_id, frame_id);
 }
+
+TEST_F(FrameTest, PassAlongNavigationStartTime) {
+  scoped_ptr<ViewAndFrame> child_view_and_frame(
+      CreateChildViewAndFrame(root_view_and_frame()));
+  ASSERT_TRUE(child_view_and_frame);
+
+  base::TimeTicks navigation_start_time = base::TimeTicks::FromInternalValue(1);
+  scoped_ptr<ViewAndFrame> navigated_child_view_and_frame =
+      NavigateFrameWithStartTime(child_view_and_frame.get(),
+                                 navigation_start_time)
+          .Pass();
+  EXPECT_EQ(navigation_start_time,
+            navigated_child_view_and_frame->test_frame_client()
+                ->last_navigation_start_time());
+}
+
 }  // namespace web_view