Use a monotonic clock (TimeTicks) to report network times to WebCore.

content/common/resource_dispatcher_unittest.cc

 // Copyright (c) 2011 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 <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process.h"
@@ skipping 27 matching lines @@
  public:
   TestRequestCallback() : complete_(false) {
   }
 
   virtual void OnUploadProgress(uint64 position, uint64 size) {
   }
 
   virtual bool OnReceivedRedirect(
       const GURL& new_url,
       const ResourceResponseInfo& info,
+      const base::TimeTicks& start_time,
+      const base::TimeTicks& end_time,
       bool* has_new_first_party_for_cookies,
       GURL* new_first_party_for_cookies) {
     *has_new_first_party_for_cookies = false;
     return true;
   }
 
-  virtual void OnReceivedResponse(const ResourceResponseInfo& info) {
+  virtual void OnReceivedResponse(const ResourceResponseInfo& info,
+                                  const base::TimeTicks& start_time,
+                                  const base::TimeTicks& end_time) {
   }
 
   virtual void OnDownloadedData(int len) {
   }
 
   virtual void OnReceivedData(const char* data,
                               int data_length,
                               int encoded_data_length) {
     EXPECT_FALSE(complete_);
     data_.append(data, data_length);
     total_encoded_data_length_ += encoded_data_length;
   }
 
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                   const std::string& security_info,
-                                  const base::Time& completion_time) {
+                                  const base::TimeTicks& completion_time) {
     EXPECT_FALSE(complete_);
     complete_ = true;
   }
 
   bool complete() const {
     return complete_;
   }
   const std::string& data() const {
     return data_;
   }
@@ skipping 32 matching lines @@
       // check values
       EXPECT_EQ(test_page_url, request.url.spec());
 
       // received response message
       ResourceResponseHead response;
       std::string raw_headers(test_page_headers);
       std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0');
       response.headers = new net::HttpResponseHeaders(raw_headers);
       response.mime_type = test_page_mime_type;
       response.charset = test_page_charset;
-      dispatcher_->OnReceivedResponse(request_id, response);
+      dispatcher_->OnReceivedResponse(request_id, response, base::TimeTicks(),
+                                      base::TimeTicks());
 
       // received data message with the test contents
       base::SharedMemory shared_mem;
       EXPECT_TRUE(shared_mem.CreateAndMapAnonymous(test_page_contents_len));
       char* put_data_here = static_cast<char*>(shared_mem.memory());
       memcpy(put_data_here, test_page_contents, test_page_contents_len);
       base::SharedMemoryHandle dup_handle;
       EXPECT_TRUE(shared_mem.GiveToProcess(
           base::Process::Current().handle(), &dup_handle));
       dispatcher_->OnReceivedData(
@@ skipping 104 matching lines @@
     return true;
   }
 
   void InitMessages() {
     set_defer_loading(true);
 
     ResourceResponseHead response_head;
     response_head.status.set_status(net::URLRequestStatus::SUCCESS);
 
     IPC::Message* response_message =
-        new ResourceMsg_ReceivedResponse(0, 0, response_head);
+        new ResourceMsg_ReceivedResponse(0, 0, response_head,
+                                         base::TimeTicks(), base::TimeTicks());
 
     dispatcher_->OnMessageReceived(*response_message);
 
     delete response_message;
 
     // Duplicate the shared memory handle so both the test and the callee can
     // close their copy.
     base::SharedMemoryHandle duplicated_handle;
     EXPECT_TRUE(shared_handle_.ShareToProcess(base::GetCurrentProcessHandle(),
                                               &duplicated_handle));
 
     response_message =
         new ResourceMsg_DataReceived(0, 0, duplicated_handle, 100, 100);
 
     dispatcher_->OnMessageReceived(*response_message);
 
     delete response_message;
 
     set_defer_loading(false);
   }
 
   // ResourceLoaderBridge::Peer methods.
   virtual void OnUploadProgress(uint64 position, uint64 size) {
   }
 
   virtual bool OnReceivedRedirect(
       const GURL& new_url,
       const ResourceResponseInfo& info,
+      const base::TimeTicks& start_time,
+      const base::TimeTicks& end_time,
       bool* has_new_first_party_for_cookies,
       GURL* new_first_party_for_cookies) {
     *has_new_first_party_for_cookies = false;
     return true;
   }
 
-  virtual void OnReceivedResponse(const ResourceResponseInfo& info) {
+  virtual void OnReceivedResponse(const ResourceResponseInfo& info,
+                                  const base::TimeTicks& start_time,
+                                  const base::TimeTicks& end_time) {
     EXPECT_EQ(defer_loading_, false);
     set_defer_loading(true);
   }
 
   virtual void OnDownloadedData(int len) {
   }
 
   virtual void OnReceivedData(const char* data,
                               int data_length,
                               int encoded_data_length) {
     EXPECT_EQ(defer_loading_, false);
     set_defer_loading(false);
   }
 
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                   const std::string& security_info,
-                                  const base::Time& completion_time) {
+                                  const base::TimeTicks& completion_time) {
   }
 
  protected:
   virtual void SetUp() {
     ResourceDispatcherTest::SetUp();
     shared_handle_.Delete(kShmemSegmentName);
     EXPECT_TRUE(shared_handle_.CreateNamed(kShmemSegmentName, false, 100));
   }
 
   virtual void TearDown() {
@@ skipping 21 matching lines @@
 
   ResourceLoaderBridge* bridge = CreateBridge();
 
   bridge->Start(this);
   InitMessages();
 
   // Dispatch deferred messages.
   message_loop.RunAllPending();
   delete bridge;
 }