Adding URLResponse Disk Cache to mojo.

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 11 matching lines @@
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "shell/application_manager/data_pipe_peek.h"
 #include "shell/switches.h"
 
 namespace shell {
 
 NetworkFetcher::NetworkFetcher(bool disable_cache,
                                const GURL& url,
                                mojo::NetworkService* network_service,
+                               mojo::service_cache::ServiceCache* service_cache,
                                const FetchCallback& loader_callback)
     : Fetcher(loader_callback),
       disable_cache_(false),
       url_(url),
+      service_cache_(service_cache),
       weak_ptr_factory_(this) {
   StartNetworkRequest(url, network_service);
 }
 
 NetworkFetcher::~NetworkFetcher() {
 }
 
 const GURL& NetworkFetcher::GetURL() const {
   return url_;
 }
@@ skipping 95 matching lines @@
   // The directory is leaked, because it can be reused at any time if the same
   // application is downloaded. Deleting it would be racy. This is only
   // happening when --predictable-app-filenames is used.
   bool result = base::CreateDirectoryAndGetError(app_dir, nullptr);
   DCHECK(result);
   std::string unique_name = base::StringPrintf("%s.mojo", app_id.c_str());
   *new_path = app_dir.Append(unique_name);
   return base::Move(old_path, *new_path);
 }
 
-void NetworkFetcher::CopyCompleted(
+void NetworkFetcher::CacheFileRetrieved(
     base::Callback<void(const base::FilePath&, bool)> callback,
-    bool success) {
+    mojo::Array<uint8_t> path_as_array,
+    mojo::Array<uint8_t> cache_dir) {
+  bool success = !path_as_array.is_null();
   if (success) {
+    path_ = base::FilePath(std::string(
+        reinterpret_cast<char*>(&path_as_array.front()), path_as_array.size()));
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kPredictableAppFilenames)) {
       // The copy completed, now move to $TMP/$APP_ID.mojo before the dlopen.
-      success = false;
       base::FilePath new_path;
       if (RenameToAppId(url_, path_, &new_path)) {
         if (base::PathExists(new_path)) {
           path_ = new_path;
           success = true;
         }
       }
     }
   }
 
   if (success)
     RecordCacheToURLMapping(path_, url_);
 
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::Bind(callback, path_, success));
 }
 
 void NetworkFetcher::AsPath(
     base::TaskRunner* task_runner,
     base::Callback<void(const base::FilePath&, bool)> callback) {
+  // TODO(qsr) Test is not enough anymore -> we do not have anything while
+  // waiting for the service cache. This is fine for now, as AsPath is never
+  // called more than once.
   if (!path_.empty() || !response_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, path_, base::PathExists(path_)));
     return;
   }
 
-  base::CreateTemporaryFile(&path_);
-  mojo::common::CopyToFile(
-      response_->body.Pass(), path_, task_runner,
-      base::Bind(&NetworkFetcher::CopyCompleted, weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+  service_cache_->GetFile(response_.Pass(),
+                          base::Bind(&NetworkFetcher::CacheFileRetrieved,
+                                     weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 std::string NetworkFetcher::MimeType() {
   return response_->mime_type;
 }
 
 bool NetworkFetcher::HasMojoMagic() {
   std::string magic;
   return BlockingPeekNBytes(response_->body.get(), &magic, strlen(kMojoMagic),
                             kPeekTimeout) &&
          magic == kMojoMagic;
 }
 
 bool NetworkFetcher::PeekFirstLine(std::string* line) {
   return BlockingPeekLine(response_->body.get(), line, kMaxShebangLength,
                           kPeekTimeout);
 }
 
 void NetworkFetcher::StartNetworkRequest(
     const GURL& url,
     mojo::NetworkService* network_service) {
   TRACE_EVENT_ASYNC_BEGIN1("mojo_shell", "NetworkFetcher::NetworkRequest", this,
                            "url", url.spec());
   mojo::URLRequestPtr request(mojo::URLRequest::New());

[DaveMoore, 2015/05/06 22:31:21]

I thought the point of etags was that you sent them and the last date fetched in
the request and then could get a response that indicated that there was no
change. But I don't see any place where we first look for the tag / date and add
that to the request.

[qsr, 2015/05/07 08:40:54]

The network service is doing all of this for us. Also ETags do not use date,
just the hermetic identifier.

   request->url = mojo::String::From(url);
   request->auto_follow_redirects = false;
   request->bypass_cache = disable_cache_;
 
   network_service->CreateURLLoader(mojo::GetProxy(&url_loader_));
   url_loader_->Start(request.Pass(),
                      base::Bind(&NetworkFetcher::OnLoadComplete,
                                 weak_ptr_factory_.GetWeakPtr()));
 }
 
@@ skipping 14 matching lines @@
                << "while fetching " << response->url;
     loader_callback_.Run(nullptr);
     return;
   }
 
   response_ = response.Pass();
   loader_callback_.Run(owner.Pass());
 }
 
 }  // namespace shell