Plumb network stack information about existence of cached copy

content/browser/loader/async_resource_handler.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 "content/browser/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 317 matching lines @@
   base::debug::Alias(url_buf);
 
   // TODO(gavinp): Remove this CHECK when we figure out the cause of
   // http://crbug.com/124680 . This check mirrors closely check in
   // WebURLLoaderImpl::OnCompletedRequest that routes this message to a WebCore
   // ResourceHandleInternal which asserts on its state and crashes. By crashing
   // when the message is sent, we should get better crash reports.
   CHECK(status.status() != net::URLRequestStatus::SUCCESS ||
         sent_received_response_msg_);
 
-  TimeTicks completion_time = TimeTicks::Now();
-
   int error_code = status.error();
   bool was_ignored_by_handler = info->WasIgnoredByHandler();
 
   DCHECK(status.status() != net::URLRequestStatus::IO_PENDING);
   // If this check fails, then we're in an inconsistent state because all
   // requests ignored by the handler should be canceled (which should result in
   // the ERR_ABORTED error code).
   DCHECK(!was_ignored_by_handler || error_code == net::ERR_ABORTED);
 
   // TODO(mkosiba): Fix up cases where we create a URLRequestStatus
   // with a status() != SUCCESS and an error_code() == net::OK.
   if (status.status() == net::URLRequestStatus::CANCELED &&
       error_code == net::OK) {
     error_code = net::ERR_ABORTED;
   } else if (status.status() == net::URLRequestStatus::FAILED &&
              error_code == net::OK) {
     error_code = net::ERR_FAILED;
   }
 
+  ResourceMsg_RequestCompleteData request_complete_data;
+  request_complete_data.error_code = error_code;
+  request_complete_data.was_ignored_by_handler = was_ignored_by_handler;
+  request_complete_data.exists_in_cache = request()->response_info().was_cached;
+  request_complete_data.security_info = security_info;
+  request_complete_data.completion_time = TimeTicks::Now();
   info->filter()->Send(
-      new ResourceMsg_RequestComplete(request_id,
-                                      error_code,
-                                      was_ignored_by_handler,
-                                      security_info,
-                                      completion_time));
+      new ResourceMsg_RequestComplete(request_id, request_complete_data));
 }
 
 bool AsyncResourceHandler::EnsureResourceBufferIsInitialized() {
   if (buffer_.get() && buffer_->IsInitialized())
     return true;
 
   if (!has_checked_for_sufficient_resources_) {
     has_checked_for_sufficient_resources_ = true;
     if (!rdh_->HasSufficientResourcesForRequest(request())) {
       controller()->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
@@ skipping 13 matching lines @@
     request()->LogUnblocked();
     controller()->Resume();
   }
 }
 
 void AsyncResourceHandler::OnDefer() {
   request()->LogBlockedBy("AsyncResourceHandler");
 }
 
 }  // namespace content