Stitch CacheStorage messages to the implementation

Also do a bit of renaming from Stores -> Cache while we're at it.

BUG=392621

Review URL: https://codereview.chromium.org/411973004

Cr-Commit-Position: refs/heads/master@{#289036}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@289036 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 208 insertions, 54 deletions

diff --git a/content/browser/service_worker/service_worker_cache_listener.cc b/content/browser/service_worker/service_worker_cache_listener.cc
index ffd55a4..0a4b66b 100644
--- a/content/browser/service_worker/service_worker_cache_listener.cc
+++ b/content/browser/service_worker/service_worker_cache_listener.cc
@@ -4,21 +4,62 @@
 
 #include "content/browser/service_worker/service_worker_cache_listener.h"
 
+#include "base/bind.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/browser/service_worker/service_worker_cache_storage_manager.h"
+#include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerCacheError.h"
 
 namespace content {
 
-ServiceWorkerStoresListener::ServiceWorkerStoresListener(
-    ServiceWorkerVersion* version) : version_(version) {}
+using blink::WebServiceWorkerCacheError;
 
-ServiceWorkerStoresListener::~ServiceWorkerStoresListener() {}
+namespace {
 
-bool ServiceWorkerStoresListener::OnMessageReceived(
+WebServiceWorkerCacheError ToWebServiceWorkerCacheError(
+    ServiceWorkerCacheStorage::CacheStorageError err) {
+  switch (err) {
+    case ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR:
+      NOTREACHED();
+      return WebServiceWorkerCacheError::
+          WebServiceWorkerCacheErrorNotImplemented;
+    case ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NOT_IMPLEMENTED:
+      return WebServiceWorkerCacheError::
+          WebServiceWorkerCacheErrorNotImplemented;
+    case ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NOT_FOUND:
+      return WebServiceWorkerCacheError::WebServiceWorkerCacheErrorNotFound;
+    case ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_EXISTS:
+      return WebServiceWorkerCacheError::WebServiceWorkerCacheErrorExists;
+    case ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_STORAGE:
+      // TODO(jkarlin): Changethis to CACHE_STORAGE_ERROR_STORAGE once that's
+      // added.
+      return WebServiceWorkerCacheError::WebServiceWorkerCacheErrorNotFound;
+    case ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_EMPTY_KEY:
+      // TODO(jkarlin): Update this to CACHE_STORAGE_ERROR_EMPTY_KEY once that's
+      // added.
+      return WebServiceWorkerCacheError::WebServiceWorkerCacheErrorNotFound;
+  }
+  NOTREACHED();
+  return WebServiceWorkerCacheError::WebServiceWorkerCacheErrorNotImplemented;
+}
+
+}  // namespace
+
+ServiceWorkerCacheListener::ServiceWorkerCacheListener(
+    ServiceWorkerVersion* version,
+    base::WeakPtr<ServiceWorkerContextCore> context)
+    : version_(version), context_(context), weak_factory_(this) {
+}
+
+ServiceWorkerCacheListener::~ServiceWorkerCacheListener() {
+}
+
+bool ServiceWorkerCacheListener::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ServiceWorkerStoresListener, message)
+  IPC_BEGIN_MESSAGE_MAP(ServiceWorkerCacheListener, message)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_CacheStorageGet,
                         OnCacheStorageGet)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_CacheStorageHas,
@@ -35,50 +76,132 @@ bool ServiceWorkerStoresListener::OnMessageReceived(
   return handled;
 }
 
-void ServiceWorkerStoresListener::OnCacheStorageGet(
+void ServiceWorkerCacheListener::OnCacheStorageGet(
     int request_id,
-    const base::string16& fetch_store_name) {
-  // TODO(gavinp,jkarlin): Implement this method.
-  Send(ServiceWorkerMsg_CacheStorageGetError(
-      request_id,
-      blink::WebServiceWorkerCacheErrorNotImplemented));
+    const base::string16& cache_name) {
+  context_->cache_manager()->GetCache(
+      version_->scope().GetOrigin(),
+      base::UTF16ToUTF8(cache_name),
+      base::Bind(&ServiceWorkerCacheListener::OnCacheStorageGetCallback,
+                 weak_factory_.GetWeakPtr(),
+                 request_id));
 }
 
-void ServiceWorkerStoresListener::OnCacheStorageHas(
+void ServiceWorkerCacheListener::OnCacheStorageHas(
     int request_id,
-    const base::string16& fetch_store_name) {
-  // TODO(gavinp,jkarlin): Implement this method.
-  Send(ServiceWorkerMsg_CacheStorageHasError(
-      request_id,
-      blink::WebServiceWorkerCacheErrorNotImplemented));
+    const base::string16& cache_name) {
+  context_->cache_manager()->HasCache(
+      version_->scope().GetOrigin(),
+      base::UTF16ToUTF8(cache_name),
+      base::Bind(&ServiceWorkerCacheListener::OnCacheStorageHasCallback,
+                 weak_factory_.GetWeakPtr(),
+                 request_id));
 }
 
-void ServiceWorkerStoresListener::OnCacheStorageCreate(
+void ServiceWorkerCacheListener::OnCacheStorageCreate(
     int request_id,
-    const base::string16& fetch_store_name) {
-  // TODO(gavinp,jkarlin): Implement this method.
-  Send(ServiceWorkerMsg_CacheStorageCreateError(
-      request_id,
-      blink::WebServiceWorkerCacheErrorNotImplemented));
+    const base::string16& cache_name) {
+  context_->cache_manager()->CreateCache(
+      version_->scope().GetOrigin(),
+      base::UTF16ToUTF8(cache_name),
+      base::Bind(&ServiceWorkerCacheListener::OnCacheStorageCreateCallback,
+                 weak_factory_.GetWeakPtr(),
+                 request_id));
 }
 
-void ServiceWorkerStoresListener::OnCacheStorageDelete(
+void ServiceWorkerCacheListener::OnCacheStorageDelete(
     int request_id,
-    const base::string16& fetch_store_name) {
-  // TODO(gavinp,jkarlin): Implement this method.
-  Send(ServiceWorkerMsg_CacheStorageDeleteError(
-      request_id, blink::WebServiceWorkerCacheErrorNotImplemented));
+    const base::string16& cache_name) {
+  context_->cache_manager()->DeleteCache(
+      version_->scope().GetOrigin(),
+      base::UTF16ToUTF8(cache_name),
+      base::Bind(&ServiceWorkerCacheListener::OnCacheStorageDeleteCallback,
+                 weak_factory_.GetWeakPtr(),
+                 request_id));
 }
 
-void ServiceWorkerStoresListener::OnCacheStorageKeys(
-    int request_id) {
-  // TODO(gavinp,jkarlin): Implement this method.
-  Send(ServiceWorkerMsg_CacheStorageKeysError(
-      request_id, blink::WebServiceWorkerCacheErrorNotImplemented));
+void ServiceWorkerCacheListener::OnCacheStorageKeys(int request_id) {
+  context_->cache_manager()->EnumerateCaches(
+      version_->scope().GetOrigin(),
+      base::Bind(&ServiceWorkerCacheListener::OnCacheStorageKeysCallback,
+                 weak_factory_.GetWeakPtr(),
+                 request_id));
 }
 
-void ServiceWorkerStoresListener::Send(const IPC::Message& message) {
+void ServiceWorkerCacheListener::Send(const IPC::Message& message) {
   version_->embedded_worker()->SendMessage(message);
 }
 
+void ServiceWorkerCacheListener::OnCacheStorageGetCallback(
+    int request_id,
+    int cache_id,
+    ServiceWorkerCacheStorage::CacheStorageError error) {
+  if (error != ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    Send(ServiceWorkerMsg_CacheStorageGetError(
+        request_id, ToWebServiceWorkerCacheError(error)));
+    return;
+  }
+  Send(ServiceWorkerMsg_CacheStorageGetSuccess(request_id, cache_id));
+}
+
+void ServiceWorkerCacheListener::OnCacheStorageHasCallback(
+    int request_id,
+    bool has_cache,
+    ServiceWorkerCacheStorage::CacheStorageError error) {
+  if (error != ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    Send(ServiceWorkerMsg_CacheStorageHasError(
+        request_id, ToWebServiceWorkerCacheError(error)));
+    return;
+  }
+  if (!has_cache) {
+    Send(ServiceWorkerMsg_CacheStorageHasError(
+        request_id,
+        WebServiceWorkerCacheError::WebServiceWorkerCacheErrorNotFound));
+    return;
+  }
+  Send(ServiceWorkerMsg_CacheStorageHasSuccess(request_id));
+}
+
+void ServiceWorkerCacheListener::OnCacheStorageCreateCallback(
+    int request_id,
+    int cache_id,
+    ServiceWorkerCacheStorage::CacheStorageError error) {
+  if (error != ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    Send(ServiceWorkerMsg_CacheStorageCreateError(
+        request_id, ToWebServiceWorkerCacheError(error)));
+    return;
+  }
+  Send(ServiceWorkerMsg_CacheStorageCreateSuccess(request_id, cache_id));
+}
+
+void ServiceWorkerCacheListener::OnCacheStorageDeleteCallback(
+    int request_id,
+    bool deleted,
+    ServiceWorkerCacheStorage::CacheStorageError error) {
+  if (!deleted ||
+      error != ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    Send(ServiceWorkerMsg_CacheStorageDeleteError(
+        request_id, ToWebServiceWorkerCacheError(error)));
+    return;
+  }
+  Send(ServiceWorkerMsg_CacheStorageDeleteSuccess(request_id));
+}
+
+void ServiceWorkerCacheListener::OnCacheStorageKeysCallback(
+    int request_id,
+    const std::vector<std::string>& strings,
+    ServiceWorkerCacheStorage::CacheStorageError error) {
+  if (error != ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR) {
+    Send(ServiceWorkerMsg_CacheStorageKeysError(
+        request_id, ToWebServiceWorkerCacheError(error)));
+    return;
+  }
+
+  std::vector<base::string16> string16s;
+  for (size_t i = 0, max = strings.size(); i < max; ++i) {
+    string16s.push_back(base::UTF8ToUTF16(strings[i]));
+  }
+  Send(ServiceWorkerMsg_CacheStorageKeysSuccess(request_id, string16s));
+}
+
 }  // namespace content
diff --git a/content/browser/service_worker/service_worker_cache_listener.h b/content/browser/service_worker/service_worker_cache_listener.h
index 5bc85d1..27a6089 100644
--- a/content/browser/service_worker/service_worker_cache_listener.h
+++ b/content/browser/service_worker/service_worker_cache_listener.h
@@ -2,23 +2,26 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORES_LISTENER_H_
-#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORES_LISTENER_H_
+#ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CACHE_LISTENER_H_
+#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CACHE_LISTENER_H_
 
+#include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
+#include "content/browser/service_worker/service_worker_cache_storage.h"
 
 namespace content {
 
 class ServiceWorkerVersion;
 
-// This class listens for requests on the Store APIs, and sends response
+// This class listens for requests on the Cache APIs, and sends response
 // messages to the renderer process. There is one instance per
 // ServiceWorkerVersion instance.
-class ServiceWorkerStoresListener : public EmbeddedWorkerInstance::Listener {
+class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
  public:
-  explicit ServiceWorkerStoresListener(ServiceWorkerVersion* version);
-  virtual ~ServiceWorkerStoresListener();
+  ServiceWorkerCacheListener(ServiceWorkerVersion* version,
+                             base::WeakPtr<ServiceWorkerContextCore> context);
+  virtual ~ServiceWorkerCacheListener();
 
   // From EmbeddedWorkerInstance::Listener:
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
@@ -35,10 +38,38 @@ class ServiceWorkerStoresListener : public EmbeddedWorkerInstance::Listener {
  private:
   void Send(const IPC::Message& message);
 
+  void OnCacheStorageGetCallback(
+      int request_id,
+      int cache_id,
+      ServiceWorkerCacheStorage::CacheStorageError error);
+  void OnCacheStorageHasCallback(
+      int request_id,
+      bool has_cache,
+      ServiceWorkerCacheStorage::CacheStorageError error);
+  void OnCacheStorageCreateCallback(
+      int request_id,
+      int cache_id,
+      ServiceWorkerCacheStorage::CacheStorageError error);
+  void OnCacheStorageDeleteCallback(
+      int request_id,
+      bool deleted,
+      ServiceWorkerCacheStorage::CacheStorageError error);
+  void OnCacheStorageKeysCallback(
+      int request_id,
+      const std::vector<std::string>& strings,
+      ServiceWorkerCacheStorage::CacheStorageError error);
+
   // The ServiceWorkerVersion to use for messaging back to the renderer thread.
   ServiceWorkerVersion* version_;
+
+  // The ServiceWorkerContextCore should always outlive this.
+  base::WeakPtr<ServiceWorkerContextCore> context_;
+
+  base::WeakPtrFactory<ServiceWorkerCacheListener> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerCacheListener);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORES_LISTENER_H_
+#endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CACHE_LISTENER_H_
diff --git a/content/browser/service_worker/service_worker_context_core.cc b/content/browser/service_worker/service_worker_context_core.cc
index 582a4c5..1e8e858 100644
--- a/content/browser/service_worker/service_worker_context_core.cc
+++ b/content/browser/service_worker/service_worker_context_core.cc
@@ -83,7 +83,7 @@ void ServiceWorkerContextCore::ProviderHostIterator::Initialize() {
 
 ServiceWorkerContextCore::ServiceWorkerContextCore(
     const base::FilePath& path,
-    base::SequencedTaskRunner* stores_task_runner,
+    base::SequencedTaskRunner* cache_task_runner,
     base::SequencedTaskRunner* database_task_runner,
     base::MessageLoopProxy* disk_cache_thread,
     quota::QuotaManagerProxy* quota_manager_proxy,
@@ -97,8 +97,8 @@ ServiceWorkerContextCore::ServiceWorkerContextCore(
                                             database_task_runner,
                                             disk_cache_thread,
                                             quota_manager_proxy)),
-      fetch_stores_manager_(
-          ServiceWorkerCacheStorageManager::Create(path, stores_task_runner)),
+      cache_manager_(
+          ServiceWorkerCacheStorageManager::Create(path, cache_task_runner)),
       embedded_worker_registry_(EmbeddedWorkerRegistry::Create(AsWeakPtr())),
       job_coordinator_(new ServiceWorkerJobCoordinator(AsWeakPtr())),
       next_handle_id_(0),
@@ -113,8 +113,8 @@ ServiceWorkerContextCore::ServiceWorkerContextCore(
       providers_(old_context->providers_.release()),
       storage_(
           ServiceWorkerStorage::Create(AsWeakPtr(), old_context->storage())),
-      fetch_stores_manager_(ServiceWorkerCacheStorageManager::Create(
-          old_context->fetch_stores_manager())),
+      cache_manager_(ServiceWorkerCacheStorageManager::Create(
+          old_context->cache_manager())),
       embedded_worker_registry_(EmbeddedWorkerRegistry::Create(
           AsWeakPtr(),
           old_context->embedded_worker_registry())),
diff --git a/content/browser/service_worker/service_worker_context_core.h b/content/browser/service_worker/service_worker_context_core.h
index eacbd85..13a8632 100644
--- a/content/browser/service_worker/service_worker_context_core.h
+++ b/content/browser/service_worker/service_worker_context_core.h
@@ -62,7 +62,7 @@ class CONTENT_EXPORT ServiceWorkerContextCore
   typedef IDMap<ServiceWorkerProviderHost, IDMapOwnPointer> ProviderMap;
   typedef IDMap<ProviderMap, IDMapOwnPointer> ProcessToProviderMap;
 
-  // Directory for ServiceWorkerStorage and ServiceWorkerFetchStores.
+  // Directory for ServiceWorkerStorage and ServiceWorkerCacheManager.
   static const base::FilePath::CharType kServiceWorkerDirectory[];
 
   // Iterates over ServiceWorkerProviderHost objects in a ProcessToProviderMap.
@@ -93,7 +93,7 @@ class CONTENT_EXPORT ServiceWorkerContextCore
   // be called on the thread which called AddObserver() of |observer_list|.
   ServiceWorkerContextCore(
       const base::FilePath& user_data_directory,
-      base::SequencedTaskRunner* stores_task_runner,
+      base::SequencedTaskRunner* cache_task_runner,
       base::SequencedTaskRunner* database_task_runner,
       base::MessageLoopProxy* disk_cache_thread,
       quota::QuotaManagerProxy* quota_manager_proxy,
@@ -121,8 +121,8 @@ class CONTENT_EXPORT ServiceWorkerContextCore
                                       const GURL& source_url) OVERRIDE;
 
   ServiceWorkerStorage* storage() { return storage_.get(); }
-  ServiceWorkerCacheStorageManager* fetch_stores_manager() {
-    return fetch_stores_manager_.get();
+  ServiceWorkerCacheStorageManager* cache_manager() {
+    return cache_manager_.get();
   }
   ServiceWorkerProcessManager* process_manager();
   EmbeddedWorkerRegistry* embedded_worker_registry() {
@@ -202,7 +202,7 @@ class CONTENT_EXPORT ServiceWorkerContextCore
   ServiceWorkerContextWrapper* wrapper_;
   scoped_ptr<ProcessToProviderMap> providers_;
   scoped_ptr<ServiceWorkerStorage> storage_;
-  scoped_ptr<ServiceWorkerCacheStorageManager> fetch_stores_manager_;
+  scoped_ptr<ServiceWorkerCacheStorageManager> cache_manager_;
   scoped_refptr<EmbeddedWorkerRegistry> embedded_worker_registry_;
   scoped_ptr<ServiceWorkerJobCoordinator> job_coordinator_;
   std::map<int64, ServiceWorkerRegistration*> live_registrations_;
diff --git a/content/browser/service_worker/service_worker_version.cc b/content/browser/service_worker/service_worker_version.cc
index f73ecfb..161b894 100644
--- a/content/browser/service_worker/service_worker_version.cc
+++ b/content/browser/service_worker/service_worker_version.cc
@@ -110,8 +110,8 @@ ServiceWorkerVersion::ServiceWorkerVersion(
   context_->AddLiveVersion(this);
   embedded_worker_ = context_->embedded_worker_registry()->CreateWorker();
   embedded_worker_->AddListener(this);
-  stores_listener_.reset(new ServiceWorkerStoresListener(this));
-  embedded_worker_->AddListener(stores_listener_.get());
+  cache_listener_.reset(new ServiceWorkerCacheListener(this, context));
+  embedded_worker_->AddListener(cache_listener_.get());
 }
 
 ServiceWorkerVersion::~ServiceWorkerVersion() {
diff --git a/content/browser/service_worker/service_worker_version.h b/content/browser/service_worker/service_worker_version.h
index d729d3e..48cbda9 100644
--- a/content/browser/service_worker/service_worker_version.h
+++ b/content/browser/service_worker/service_worker_version.h
@@ -285,7 +285,7 @@ class CONTENT_EXPORT ServiceWorkerVersion
   GURL scope_;
   Status status_;
   scoped_ptr<EmbeddedWorkerInstance> embedded_worker_;
-  scoped_ptr<ServiceWorkerStoresListener> stores_listener_;
+  scoped_ptr<ServiceWorkerCacheListener> cache_listener_;
   std::vector<StatusCallback> start_callbacks_;
   std::vector<StatusCallback> stop_callbacks_;
   std::vector<base::Closure> status_change_callbacks_;