Add invalidation to url_response_disk_cache.

shell/application_manager/network_fetcher.cc

 // Copyright 2015 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 "shell/application_manager/network_fetcher.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 18 matching lines @@
 #if defined(OS_LINUX)
 char kArchitecture[] = "linux-x64";
 #elif defined(OS_ANDROID)
 char kArchitecture[] = "android-arm";
 #elif defined(OS_MACOSX)
 char kArchitecture[] = "macosx";
 #else
 #error "Unsupported."
 #endif
 
+const bool kScheduleUpdate = true;
+const bool kDoNotScheduleUpdate = false;
+
 // The delay to wait before trying to update an application after having served
 // it from the cache.
 const uint32_t kUpdateApplicationDelayInSeconds = 60;
 
 base::FilePath ToFilePath(const mojo::Array<uint8_t>& array) {
   return base::FilePath(
       std::string(reinterpret_cast<const char*>(&array.front()), array.size()));
 }
 
 void IgnoreResult(bool result) {}
 
 mojo::URLRequestPtr GetRequest(const GURL& url, bool disable_cache) {
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url);
   request->auto_follow_redirects = false;
   if (disable_cache)
     request->cache_mode = mojo::URLRequest::CACHE_MODE_BYPASS_CACHE;
   auto architecture_header = mojo::HttpHeader::New();
   architecture_header->name = "X-Architecture";
   architecture_header->value = kArchitecture;
   mojo::Array<mojo::HttpHeaderPtr> headers;
   headers.push_back(architecture_header.Pass());
   request->headers = headers.Pass();
 
   return request.Pass();
 }
 
+// Clone an URLResponse, except for the body.
+mojo::URLResponsePtr CloneResponse(const mojo::URLResponsePtr& response) {
+  mojo::URLResponsePtr cloned = mojo::URLResponse::New();
+  cloned->error = response->error.Clone();
+  cloned->url = response->url;
+  cloned->status_code = response->status_code;
+  cloned->status_line = response->status_line;
+  cloned->headers = response->headers.Clone();
+  cloned->mime_type = response->mime_type;
+  cloned->charset = response->charset;
+  cloned->redirect_method = response->redirect_method;
+  cloned->redirect_url = response->redirect_url;
+  cloned->redirect_referrer = response->redirect_referrer;
+  return cloned.Pass();
+}
+
 // This class is self owned and will delete itself after having tried to update
 // the application cache.
 class ApplicationUpdater : public base::MessageLoop::DestructionObserver {
  public:
   ApplicationUpdater(const GURL& url,
                      const base::TimeDelta& update_delay,
                      mojo::URLResponseDiskCache* url_response_disk_cache,
                      mojo::NetworkService* network_service);
   ~ApplicationUpdater() override;
 
@@ skipping 36 matching lines @@
 }
 
 void ApplicationUpdater::UpdateApplication() {
   network_service_->CreateURLLoader(GetProxy(&url_loader_));
   url_loader_->Start(
       GetRequest(url_, false),
       base::Bind(&ApplicationUpdater::OnLoadComplete, base::Unretained(this)));
 }
 
 void ApplicationUpdater::OnLoadComplete(mojo::URLResponsePtr response) {
+  std::string url = response->url;
   url_response_disk_cache_->Update(response.Pass());
+  url_response_disk_cache_->Validate(url);
   delete this;
 }
 
 }  // namespace
 
 NetworkFetcher::NetworkFetcher(
     bool disable_cache,
     bool force_offline_by_default,
     const GURL& url,
     mojo::URLResponseDiskCache* url_response_disk_cache,
     mojo::NetworkService* network_service,
     const FetchCallback& loader_callback)
     : Fetcher(loader_callback),
       disable_cache_(disable_cache),
       force_offline_by_default_(force_offline_by_default),
       url_(url),
       url_response_disk_cache_(url_response_disk_cache),
       network_service_(network_service),
       weak_ptr_factory_(this) {
   if (CanLoadDirectlyFromCache()) {
-    LoadFromCache(true);
+    LoadFromCache();
   } else {
     StartNetworkRequest();
   }
 }
 
 NetworkFetcher::~NetworkFetcher() {
 }
 
 const GURL& NetworkFetcher::GetURL() const {
   return url_;
@@ skipping 49 matching lines @@
   if (disable_cache_)
     return false;
 
   if (force_offline_by_default_)
     return true;
 
   const std::string& host = url_.host();
   return !(host == "localhost" || host == "127.0.0.1" || host == "[::1]");
 }
 
-void NetworkFetcher::LoadFromCache(bool schedule_update) {
+void NetworkFetcher::LoadFromCache() {
   url_response_disk_cache_->Get(
       mojo::String::From(url_),
-      base::Bind(&NetworkFetcher::OnCachedResponseReceived,
-                 base::Unretained(this), schedule_update));
+      base::Bind(&NetworkFetcher::OnResponseReceived, base::Unretained(this),
+                 kScheduleUpdate));
 }
 
-void NetworkFetcher::OnCachedResponseReceived(
-    bool schedule_update,
-    mojo::URLResponsePtr response,
-    mojo::Array<uint8_t> path_as_array,
-    mojo::Array<uint8_t> cache_dir) {
+void NetworkFetcher::OnResponseReceived(bool schedule_update,
+                                        mojo::URLResponsePtr response,
+                                        mojo::Array<uint8_t> path_as_array,
+                                        mojo::Array<uint8_t> cache_dir) {
   if (!response) {
     // Not in cache, loading from net.
     StartNetworkRequest();
     return;
   }
   if (schedule_update) {
     // The response has been found in the cache. Plan updating the application.
     new ApplicationUpdater(
         url_, base::TimeDelta::FromSeconds(kUpdateApplicationDelayInSeconds),
         url_response_disk_cache_, network_service_);
@@ skipping 32 matching lines @@
     delete this;
     return;
   }
 
   if (!response->redirect_url.is_null()) {
     response_ = response.Pass();
     loader_callback_.Run(make_scoped_ptr(this));
     return;
   }
 
+  mojo::URLResponsePtr cloned_response = CloneResponse(response);
   url_response_disk_cache_->UpdateAndGet(
       response.Pass(), base::Bind(&NetworkFetcher::OnFileSavedToCache,
-                                  weak_ptr_factory_.GetWeakPtr()));
+                                  weak_ptr_factory_.GetWeakPtr(),
+                                  base::Passed(cloned_response.Pass())));
 }
 
-void NetworkFetcher::OnFileSavedToCache(mojo::Array<uint8_t> path_as_array,
+void NetworkFetcher::OnFileSavedToCache(mojo::URLResponsePtr response,
+                                        mojo::Array<uint8_t> path_as_array,
                                         mojo::Array<uint8_t> cache_dir) {
   if (!path_as_array) {
     LOG(WARNING) << "Error when retrieving content from cache for: "
                  << url_.spec();
     loader_callback_.Run(nullptr);
     delete this;
     return;
   }
-  LoadFromCache(false);
+  OnResponseReceived(kDoNotScheduleUpdate, response.Pass(),
+                     path_as_array.Pass(), cache_dir.Pass());
 }
 
 void NetworkFetcher::RecordCacheToURLMapping(const base::FilePath& path,
                                              const GURL& url) {
   // This is used to extract symbols on android.
   // TODO(eseidel): All users of this log should move to using the map file.
   LOG(INFO) << "Caching mojo app " << url << " at " << path.value();
 
   base::FilePath temp_dir;
   base::GetTempDir(&temp_dir);
   base::ProcessId pid = base::Process::Current().Pid();
   std::string map_name = base::StringPrintf("mojo_shell.%d.maps", pid);
   base::FilePath map_path = temp_dir.Append(map_name);
 
   // TODO(eseidel): Paths or URLs with spaces will need quoting.
   std::string map_entry =
       base::StringPrintf("%s %s\n", path.value().c_str(), url.spec().c_str());
   // TODO(eseidel): AppendToFile is missing O_CREAT, crbug.com/450696
   if (!PathExists(map_path)) {
     base::WriteFile(map_path, map_entry.data(), map_entry.length());
   } else {
     base::AppendToFile(map_path, map_entry.data(), map_entry.length());
   }
 }
 
 }  // namespace shell