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

webkit/tools/test_shell/simple_resource_loader_bridge.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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using net::URLRequest, meaning it is a "simple"
 // version that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because net::URLRequest only provides an asynchronous resource loading API,
@@ skipping 217 matching lines @@
   // --------------------------------------------------------------------------
   // The following methods are called on the owner's thread in response to
   // various net::URLRequest callbacks.  The event hooks, defined below, trigger
   // these methods asynchronously.
 
   void NotifyReceivedRedirect(const GURL& new_url,
                               const ResourceResponseInfo& info) {
     bool has_new_first_party_for_cookies = false;
     GURL new_first_party_for_cookies;
     if (peer_ && peer_->OnReceivedRedirect(new_url, info,
+                                           base::TimeTicks(), base::TimeTicks(),
                                            &has_new_first_party_for_cookies,
                                            &new_first_party_for_cookies)) {
       g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
           this, &RequestProxy::AsyncFollowDeferredRedirect,
           has_new_first_party_for_cookies, new_first_party_for_cookies));
     } else {
       Cancel();
     }
   }
 
   void NotifyReceivedResponse(const ResourceResponseInfo& info) {
     if (peer_)
-      peer_->OnReceivedResponse(info);
+      peer_->OnReceivedResponse(info, base::TimeTicks(), base::TimeTicks());
   }
 
   void NotifyReceivedData(int bytes_read) {
     if (!peer_)
       return;
 
     // Make a local copy of buf_, since AsyncReadData reuses it.
     scoped_array<char> buf_copy(new char[bytes_read]);
     memcpy(buf_copy.get(), buf_->data(), bytes_read);
 
@@ skipping 16 matching lines @@
 
     // Continue reading more data, see the comment in NotifyReceivedData.
     g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &RequestProxy::AsyncReadData));
 
     peer_->OnDownloadedData(bytes_read);
   }
 
   void NotifyCompletedRequest(const net::URLRequestStatus& status,
                               const std::string& security_info,
-                              const base::Time& complete_time) {
+                              const base::TimeTicks& complete_time) {
     if (peer_) {
       peer_->OnCompletedRequest(status, security_info, complete_time);
       DropPeer();  // ensure no further notifications
     }
   }
 
   void NotifyUploadProgress(uint64 position, uint64 size) {
     if (peer_)
       peer_->OnUploadProgress(position, size);
   }
@@ skipping 110 matching lines @@
           this, &RequestProxy::NotifyDownloadedData, bytes_read));
       return;
     }
 
     owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &RequestProxy::NotifyReceivedData, bytes_read));
   }
 
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                   const std::string& security_info,
-                                  const base::Time& complete_time) {
+                                  const base::TimeTicks& complete_time) {
     if (download_to_file_)
       file_stream_.Close();
     owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this,
         &RequestProxy::NotifyCompletedRequest,
         status,
         security_info,
         complete_time));
   }
 
@@ skipping 77 matching lines @@
     if (upload_progress_timer_.IsRunning()) {
       MaybeUpdateUploadProgress();
       upload_progress_timer_.Stop();
     }
     DCHECK(request_.get());
     // If |failed_file_request_status_| is not empty, which means the request
     // was a file request and encountered an error, then we need to use the
     // |failed_file_request_status_|. Otherwise use request_'s status.
     OnCompletedRequest(failed_file_request_status_.get() ?
                        *failed_file_request_status_ : request_->status(),
-                       std::string(), base::Time());
+                       std::string(), base::TimeTicks());
     request_.reset();  // destroy on the io thread
   }
 
   // Called on the IO thread.
   void MaybeUpdateUploadProgress() {
     // If a redirect is received upload is cancelled in net::URLRequest, we
     // should try to stop the |upload_progress_timer_| timer and return.
     if (!request_->has_upload()) {
       if (upload_progress_timer_.IsRunning())
         upload_progress_timer_.Stop();
@@ skipping 190 matching lines @@
   virtual void OnReceivedData(int bytes_read) {
     if (download_to_file_)
       file_stream_.Write(buf_->data(), bytes_read, NULL);
     else
       result_->data.append(buf_->data(), bytes_read);
     AsyncReadData();  // read more (may recurse)
   }
 
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                   const std::string& security_info,
-                                  const base::Time& complete_time) {
+                                  const base::TimeTicks& complete_time) {
     if (download_to_file_)
       file_stream_.Close();
     result_->status = status;
     event_.Signal();
   }
 
  private:
   ResourceLoaderBridge::SyncLoadResponse* result_;
   base::WaitableEvent event_;
 };
@@ skipping 294 matching lines @@
 
 // static
 void SimpleResourceLoaderBridge::AllowFileOverHTTP(
     const std::string& file_path_template, const GURL& http_prefix) {
   DCHECK(!file_path_template.empty());
   DCHECK(http_prefix.is_valid() &&
          (http_prefix.SchemeIs("http") || http_prefix.SchemeIs("https")));
   g_file_over_http_params = new FileOverHTTPParams(file_path_template,
                                                    http_prefix);
 }