net: Return LoadTiming information in the case of a cache hit

net/http/http_cache_transaction.cc

 // Copyright (c) 2012 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 "net/http/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
+#include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/upload_data_stream.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_delegate.h"
@@ skipping 444 matching lines @@
 UploadProgress HttpCache::Transaction::GetUploadProgress() const {
   if (network_trans_.get())
     return network_trans_->GetUploadProgress();
   return final_upload_progress_;
 }
 
 bool HttpCache::Transaction::GetLoadTimingInfo(
     LoadTimingInfo* load_timing_info) const {
   if (network_trans_)
     return network_trans_->GetLoadTimingInfo(load_timing_info);
-  // Don't modify |load_timing_info| when reading from the cache instead of the
-  // network.
-  return false;
+
+  if (last_network_trans_load_timing_) {
+    *load_timing_info = *last_network_trans_load_timing_;
+    return true;
+  }
+
+  if (first_cache_access_since_.is_null())
+    return false;
+
+  // If the cache entry was opened, return that time.
+  load_timing_info->send_start = first_cache_access_since_;
+  // This time doesn't make much sense when reading from the cache, so just use
+  // the same time as send_start.
+  load_timing_info->send_end = first_cache_access_since_;
+  return true;
 }
 
 void HttpCache::Transaction::SetPriority(RequestPriority priority) {
   priority_ = priority;
   if (network_trans_)
     network_trans_->SetPriority(priority_);
 }
 
 //-----------------------------------------------------------------------------
 
@@ skipping 315 matching lines @@
   DCHECK(!network_trans_.get());
 
   send_request_since_ = TimeTicks::Now();
 
   // Create a network transaction.
   int rv = cache_->network_layer_->CreateTransaction(
       priority_, &network_trans_, NULL);
   if (rv != OK)
     return rv;
 
+  // Old load timing information, if any, is now obsolete.
+  last_network_trans_load_timing_.reset();
+
   ReportNetworkActionStart();
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
   rv = network_trans_->Start(request_, io_callback_, net_log_);
   return rv;
 }
 
 int HttpCache::Transaction::DoSendRequestComplete(int result) {
   ReportNetworkActionFinish();
 
   if (!cache_)
@@ skipping 413 matching lines @@
     // the cached 200 response, is what will be returned to the user.
     DoneWritingToEntry(true);
   } else if (entry_ && !handling_206_) {
     DCHECK_EQ(READ_WRITE, mode_);
     if (!partial_.get() || partial_->IsLastRange()) {
       cache_->ConvertWriterToReader(entry_);
       mode_ = READ;
     }
     // We no longer need the network transaction, so destroy it.
     final_upload_progress_ = network_trans_->GetUploadProgress();
+    CacheLoadTimingInformation();
     network_trans_.reset();
   } else if (entry_ && handling_206_ && truncated_ &&
              partial_->initial_validation()) {
     // We just finished the validation of a truncated entry, and the server
     // is willing to resume the operation. Now we go back and start serving
     // the first part to the user.
+    CacheLoadTimingInformation();
     network_trans_.reset();
     new_response_ = NULL;
     next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
     partial_->SetRangeToStartDownload();
     return OK;
   }
   next_state_ = STATE_OVERWRITE_CACHED_RESPONSE;
   return OK;
 }
 
@@ skipping 1034 matching lines @@
   is_sparse_ = false;
   if (delete_object)
     partial_.reset(NULL);
 }
 
 int HttpCache::Transaction::DoPartialNetworkReadCompleted(int result) {
   partial_->OnNetworkReadCompleted(result);
 
   if (result == 0) {
     // We need to move on to the next range.
+    CacheLoadTimingInformation();
     network_trans_.reset();
     next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
   }
   return result;
 }
 
 int HttpCache::Transaction::DoPartialCacheReadCompleted(int result) {
   partial_->OnCacheReadCompleted(result);
 
   if (result == 0 && mode_ == READ_WRITE) {
@@ skipping 222 matching lines @@
   }
 }
 
 int HttpCache::Transaction::ResetCacheIOStart(int return_value) {
   DCHECK(cache_io_start_.is_null());
   if (return_value == ERR_IO_PENDING)
     cache_io_start_ = base::TimeTicks::Now();
   return return_value;
 }
 
+void HttpCache::Transaction::CacheLoadTimingInformation() {
+  DCHECK(!last_network_trans_load_timing_);
+  last_network_trans_load_timing_.reset(new LoadTimingInfo());
+  bool result =
+      network_trans_->GetLoadTimingInfo(last_network_trans_load_timing_.get());
+  // This is only called after getting a response from the transaction, so it
+  // should have timing information.
+  DCHECK(result);
+}
+
 }  // namespace net