Plumb network stack information about existence of cached copy

webkit/child/weburlloader_impl.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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "webkit/child/weburlloader_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 227 matching lines @@
       GURL* new_first_party_for_cookies) OVERRIDE;
   virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE;
   virtual void OnDownloadedData(int len, int encoded_data_length) OVERRIDE;
   virtual void OnReceivedData(const char* data,
                               int data_length,
                               int encoded_data_length) OVERRIDE;
   virtual void OnReceivedCachedMetadata(const char* data, int len) OVERRIDE;
   virtual void OnCompletedRequest(
       int error_code,
       bool was_ignored_by_handler,
+      bool stale_copy_in_cache,
       const std::string& security_info,
       const base::TimeTicks& completion_time) OVERRIDE;
 
  private:
   friend class base::RefCounted<Context>;
   virtual ~Context() {}
 
   // We can optimize the handling of data URLs in most cases.
   bool CanHandleDataURL(const GURL& url) const;
   void HandleDataURL();
@@ skipping 333 matching lines @@
 
 void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(
     const char* data, int len) {
   if (client_)
     client_->didReceiveCachedMetadata(loader_, data, len);
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
     int error_code,
     bool was_ignored_by_handler,
+    bool stale_copy_in_cache,
     const std::string& security_info,
     const base::TimeTicks& completion_time) {
   if (ftp_listing_delegate_) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   } else if (multipart_delegate_) {
     multipart_delegate_->OnCompletedRequest();
     multipart_delegate_.reset(NULL);
   }
 
   // Prevent any further IPC to the browser now that we're complete, but
   // don't delete it to keep any downloaded temp files alive.
   DCHECK(!completed_bridge_.get());
   completed_bridge_.swap(bridge_);
 
   if (client_) {
     if (error_code != net::OK) {
-      client_->didFail(loader_, CreateError(request_.url(), error_code));
+      client_->didFail(loader_, CreateError(request_.url(),
+                                            stale_copy_in_cache,
+                                            error_code));
     } else {
       client_->didFinishLoading(
           loader_, (completion_time - TimeTicks()).InSecondsF());
     }
   }
 
   // We are done with the bridge now, and so we need to release the reference
   // to ourselves that we took on behalf of the bridge.  This may cause our
   // destruction.
   Release();
@@ skipping 33 matching lines @@
   ResourceResponseInfo info;
   int error_code;
   std::string data;
 
   if (GetInfoFromDataURL(request_.url(), &info, &data, &error_code)) {
     OnReceivedResponse(info);
     if (!data.empty())
       OnReceivedData(data.data(), data.size(), 0);
   }
 
-  OnCompletedRequest(error_code, false, info.security_info,
+  OnCompletedRequest(error_code, false, false, info.security_info,
                      base::TimeTicks::Now());
 }
 
 // WebURLLoaderImpl -----------------------------------------------------------
 
 WebURLLoaderImpl::WebURLLoaderImpl(WebKitPlatformSupportImpl* platform)
     : context_(new Context(this)),
       platform_(platform) {
 }
 
 WebURLLoaderImpl::~WebURLLoaderImpl() {
   cancel();
 }
 
 WebURLError WebURLLoaderImpl::CreateError(const WebURL& unreachable_url,
+                                          bool stale_copy_in_cache,
                                           int reason) {
   WebURLError error;
   error.domain = WebString::fromUTF8(net::kErrorDomain);
   error.reason = reason;
   error.unreachableURL = unreachable_url;
+  error.staleCopyInCache = stale_copy_in_cache;
   if (reason == net::ERR_ABORTED) {
     error.isCancellation = true;
   } else if (reason == net::ERR_TEMPORARILY_THROTTLED) {
     error.localizedDescription = WebString::fromUTF8(
         kThrottledErrorDescription);
   } else {
     error.localizedDescription = WebString::fromUTF8(
         net::ErrorToString(reason));
   }
   return error;
@@ skipping 147 matching lines @@
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 void WebURLLoaderImpl::didChangePriority(WebURLRequest::Priority new_priority) {
   context_->DidChangePriority(new_priority);
 }
 
 }  // namespace webkit_glue