Bundle core applicatons in the shell.

services/url_response_disk_cache/url_response_disk_cache_impl.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 "services/url_response_disk_cache/url_response_disk_cache_impl.h"
 
 #include <dirent.h>
 #include <fcntl.h>
 #include <sys/types.h>
 
@@ skipping 185 matching lines @@
 }
 
 // Run the given mojo callback with the given paths.
 void RunMojoCallback(
     const Callback<void(Array<uint8_t>, Array<uint8_t>)>& callback,
     const base::FilePath& path1,
     const base::FilePath& path2) {
   callback.Run(PathToArray(path1), PathToArray(path2));
 }
 
+mojo::URLResponsePtr GetMinimalResponse(const std::string& url) {
+  mojo::URLResponsePtr response = mojo::URLResponse::New();
+  response->url = url;
+  response->status_code = 200;
+  return response.Pass();
+}
+
+void RunMojoCallbackWithResponse(
+    const Callback<void(mojo::URLResponsePtr, Array<uint8_t>, Array<uint8_t>)>&
+        callback,
+    const std::string& url,
+    const base::FilePath& path1,
+    const base::FilePath& path2) {
+  mojo::URLResponsePtr response;
+  if (!path1.empty())
+    response = GetMinimalResponse(url);
+  callback.Run(response.Pass(), PathToArray(path1), PathToArray(path2));
+}
+
 // Returns the list of values for the given |header_name| in the given list of
 // headers.
 std::vector<std::string> GetHeaderValues(const std::string& header_name,
                                          const Array<HttpHeaderPtr>& headers) {
   std::vector<std::string> result;
   for (size_t i = 0u; i < headers.size(); ++i) {
     const std::string& name = headers[i]->name.get();
     if (base::LowerCaseEqualsASCII(name, header_name.c_str()))
       result.push_back(headers[i]->value);
   }
@@ skipping 97 matching lines @@
   MovePathIntoDir(GetCacheDirectory(), trash_dir);
 
   scoped_refptr<URLResponseDiskCacheDB> result =
       new URLResponseDiskCacheDB(db_path);
   result->SetVersion(kCurrentVersion);
   return result;
 }
 
 URLResponseDiskCacheImpl::URLResponseDiskCacheImpl(
     scoped_refptr<base::TaskRunner> task_runner,
+    URLResponseDiskCacheDelegate* delegate,
     scoped_refptr<URLResponseDiskCacheDB> db,
     const std::string& remote_application_url,
     InterfaceRequest<URLResponseDiskCache> request)
-    : task_runner_(task_runner), db_(db), binding_(this, request.Pass()) {
+    : task_runner_(task_runner),
+      delegate_(delegate),
+      db_(db),
+      binding_(this, request.Pass()) {
   request_origin_ = GURL(remote_application_url).GetOrigin().spec();
 }
 
 URLResponseDiskCacheImpl::~URLResponseDiskCacheImpl() {
 }
 
 bool IsInvalidated(const CacheEntryPtr& entry) {
   if (!entry)
     return true;
   return base::Time::Now() -
              base::Time::FromInternalValue(entry->last_invalidation) >
          base::TimeDelta::FromSeconds(kTimeUntilInvalidationInSeconds);
 }
 
 void URLResponseDiskCacheImpl::Get(const String& url,
                                    const GetCallback& callback) {
+  std::string canonilized_url = CanonicalizeURL(url);
   CacheKeyPtr key;
-  CacheEntryPtr entry =
-      db_->GetNewest(request_origin_, CanonicalizeURL(url), &key);
+  CacheEntryPtr entry = db_->GetNewest(request_origin_, canonilized_url, &key);
+  if (!entry && delegate_) {
+    // This is the first request for the given |url|. Ask |delegate| for initial
+    // content.
+
+    std::string identifier = GetNewIdentifier();
+    // The content is copied to the staging directory so that files are not
+    // leaked if the shell terminates before an entry is saved to the database.
+    base::FilePath staged_response_body_path =
+        GetStagingDirectory().Append(identifier);
+
+    delegate_->GetInitialPath(
+        task_runner_, canonilized_url, staged_response_body_path,
+        base::Bind(
+            RunCallbackWithSuccess,
+            base::Bind(&RunMojoCallbackWithResponse, callback, canonilized_url),
+            identifier, request_origin_, canonilized_url,
+            base::Passed(GetMinimalResponse(canonilized_url)), db_,
+            task_runner_));
+    return;
+  }
   if (IsInvalidated(entry) || !IsCacheEntryValid(entry)) {
     callback.Run(URLResponsePtr(), Array<uint8_t>(), Array<uint8_t>());
     return;
   }
   callback.Run(entry->response.Pass(),
                PathToArray(base::FilePath(entry->response_body_path)),
                PathToArray(GetConsumerCacheDirectory(
                    base::FilePath(entry->entry_directory))));
   UpdateLastInvalidation(db_, key.Pass(), base::Time::Now());
 }
@@ skipping 116 matching lines @@
       return;
     }
   }
   // We can ignore write error, as it will just force to clear the cache on the
   // next request.
   WriteFile(GetExtractionSentinel(entry_directory), nullptr, 0);
   callback.Run(extraction_directory, consumer_cache_directory);
 }
 
 }  // namespace mojo