1 files changed, 281 insertions, 374 deletions

diff --git a/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc b/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc
index 6a2bf56fac8..9680429f601 100644
--- a/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc
@@ -15,28 +15,28 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
-#include "content/browser/bad_message.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
 #include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_context_impl.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
-#include "content/common/cache_storage/cache_storage_messages.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/origin_util.h"
-#include "storage/browser/blob/blob_data_handle.h"
-#include "third_party/WebKit/public/platform/modules/cache_storage/cache_storage.mojom.h"
+#include "mojo/public/cpp/bindings/message.h"
+#include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
-using blink::mojom::CacheStorageError;
 
 namespace content {
 
 namespace {
 
-const uint32_t kCacheFilteredMessageClasses[] = {CacheStorageMsgStart};
+using blink::mojom::CacheStorageError;
+
 const int32_t kCachePreservationSeconds = 5;
 
+// TODO(lucmult): Check this before binding.
 bool OriginCanAccessCacheStorage(const url::Origin& origin) {
   return !origin.unique() && IsOriginSecure(origin.GetURL());
 }
@@ -45,50 +45,198 @@ void StopPreservingCache(CacheStorageCacheHandle cache_handle) {}
 
 }  // namespace
 
-CacheStorageDispatcherHost::CacheStorageDispatcherHost()
-    : BrowserMessageFilter(kCacheFilteredMessageClasses,
-                           arraysize(kCacheFilteredMessageClasses)) {}
+// Implements the mojom interface CacheStorageCache. It's owned by
+// CacheStorageDispatcherHost and it's destroyed when client drops the mojo ptr
+// which in turn removes from StrongBindingSet in CacheStorageDispatcherHost.
+class CacheStorageDispatcherHost::CacheImpl
+    : public blink::mojom::CacheStorageCache {
+ public:
+  CacheImpl(CacheStorageCacheHandle cache_handle,
+            CacheStorageDispatcherHost* dispatcher_host)
+      : cache_handle_(std::move(cache_handle)),
+        owner_(dispatcher_host),
+        weak_factory_(this) {}
+
+  ~CacheImpl() override = default;
+
+  // blink::mojom::CacheStorageCache implementation:
+  void Match(const ServiceWorkerFetchRequest& request,
+             const CacheStorageCacheQueryParams& match_params,
+             MatchCallback callback) override {
+    content::CacheStorageCache* cache = cache_handle_.value();
+    if (!cache) {
+      std::move(callback).Run(blink::mojom::MatchResult::NewStatus(
+          CacheStorageError::kErrorNotFound));
+      return;
+    }
+
+    auto scoped_request = std::make_unique<ServiceWorkerFetchRequest>(
+        request.url, request.method, request.headers, request.referrer,
+        request.is_reload);
+    cache->Match(std::move(scoped_request), match_params,
+                 base::BindOnce(&CacheImpl::OnCacheMatchCallback,
+                                weak_factory_.GetWeakPtr(), std::move(callback),
+                                cache_handle_.Clone()));
+  }
+
+  void OnCacheMatchCallback(
+      blink::mojom::CacheStorageCache::MatchCallback callback,
+      CacheStorageCacheHandle cache_handle,
+      blink::mojom::CacheStorageError error,
+      std::unique_ptr<ServiceWorkerResponse> response) {
+    if (error != CacheStorageError::kSuccess) {
+      std::move(callback).Run(blink::mojom::MatchResult::NewStatus(error));
+      return;
+    }
+
+    std::move(callback).Run(blink::mojom::MatchResult::NewResponse(*response));
+  }
 
-CacheStorageDispatcherHost::~CacheStorageDispatcherHost() {
-}
+  void MatchAll(const ServiceWorkerFetchRequest& request,
+                const CacheStorageCacheQueryParams& match_params,
+                MatchAllCallback callback) override {
+    content::CacheStorageCache* cache = cache_handle_.value();
+    if (!cache) {
+      std::move(callback).Run(blink::mojom::MatchAllResult::NewStatus(
+          CacheStorageError::kErrorNotFound));
+      return;
+    }
+
+    if (request.url.is_empty()) {
+      cache->MatchAll(
+          nullptr, match_params,
+          base::BindOnce(&CacheImpl::OnCacheMatchAllCallback,
+                         weak_factory_.GetWeakPtr(), std::move(callback),
+                         cache_handle_.Clone()));
+      return;
+    }
+
+    auto scoped_request = std::make_unique<ServiceWorkerFetchRequest>(
+        request.url, request.method, request.headers, request.referrer,
+        request.is_reload);
+    if (match_params.ignore_search) {
+      cache->MatchAll(
+          std::move(scoped_request), match_params,
+          base::BindOnce(&CacheImpl::OnCacheMatchAllCallback,
+                         weak_factory_.GetWeakPtr(), std::move(callback),
+                         cache_handle_.Clone()));
+      return;
+    }
+
+    cache->Match(std::move(scoped_request), match_params,
+                 base::BindOnce(&CacheImpl::OnCacheMatchAllCallbackAdapter,
+                                weak_factory_.GetWeakPtr(), std::move(callback),
+                                cache_handle_.Clone()));
+  }
+
+  void OnCacheMatchAllCallback(
+      blink::mojom::CacheStorageCache::MatchAllCallback callback,
+      CacheStorageCacheHandle cache_handle,
+      blink::mojom::CacheStorageError error,
+      std::vector<ServiceWorkerResponse> responses) {
+    if (error != CacheStorageError::kSuccess &&
+        error != CacheStorageError::kErrorNotFound) {
+      std::move(callback).Run(blink::mojom::MatchAllResult::NewStatus(error));
+      return;
+    }
+
+    std::move(callback).Run(
+        blink::mojom::MatchAllResult::NewResponses(std::move(responses)));
+  }
+
+  void OnCacheMatchAllCallbackAdapter(
+      blink::mojom::CacheStorageCache::MatchAllCallback callback,
+      CacheStorageCacheHandle cache_handle,
+      blink::mojom::CacheStorageError error,
+      std::unique_ptr<ServiceWorkerResponse> response) {
+    std::vector<ServiceWorkerResponse> responses;
+    if (error == CacheStorageError::kSuccess) {
+      DCHECK(response);
+      responses.push_back(std::move(*response.release()));
+    }
+    OnCacheMatchAllCallback(std::move(callback), std::move(cache_handle), error,
+                            std::move(responses));
+  }
+
+  void Keys(const ServiceWorkerFetchRequest& request,
+            const CacheStorageCacheQueryParams& match_params,
+            KeysCallback callback) override {
+    content::CacheStorageCache* cache = cache_handle_.value();
+    if (!cache) {
+      std::move(callback).Run(blink::mojom::CacheKeysResult::NewStatus(
+          CacheStorageError::kErrorNotFound));
+      return;
+    }
+
+    auto request_ptr = std::make_unique<ServiceWorkerFetchRequest>(
+        request.url, request.method, request.headers, request.referrer,
+        request.is_reload);
+    cache->Keys(std::move(request_ptr), match_params,
+                base::BindOnce(&CacheImpl::OnCacheKeysCallback,
+                               weak_factory_.GetWeakPtr(), std::move(callback),
+                               cache_handle_.Clone()));
+  }
+
+  void OnCacheKeysCallback(
+      blink::mojom::CacheStorageCache::KeysCallback callback,
+      CacheStorageCacheHandle cache_handle,
+      blink::mojom::CacheStorageError error,
+      std::unique_ptr<content::CacheStorageCache::Requests> requests) {
+    if (error != CacheStorageError::kSuccess) {
+      std::move(callback).Run(blink::mojom::CacheKeysResult::NewStatus(error));
+      return;
+    }
+
+    std::move(callback).Run(blink::mojom::CacheKeysResult::NewKeys(*requests));
+  }
+
+  void Batch(const std::vector<CacheStorageBatchOperation>& batch_operations,
+             BatchCallback callback) override {
+    content::CacheStorageCache* cache = cache_handle_.value();
+    if (!cache) {
+      std::move(callback).Run(CacheStorageError::kErrorNotFound);
+      return;
+    }
+    cache->BatchOperation(
+        batch_operations,
+        base::BindOnce(&CacheImpl::OnCacheBatchCallback,
+                       weak_factory_.GetWeakPtr(), std::move(callback),
+                       cache_handle_.Clone()),
+        base::BindOnce(&CacheImpl::OnBadMessage, weak_factory_.GetWeakPtr(),
+                       mojo::GetBadMessageCallback()));
+  }
+
+  void OnCacheBatchCallback(
+      blink::mojom::CacheStorageCache::BatchCallback callback,
+      CacheStorageCacheHandle cache_handle,
+      blink::mojom::CacheStorageError error) {
+    std::move(callback).Run(error);
+  }
+
+  void OnBadMessage(mojo::ReportBadMessageCallback bad_message_callback) {
+    std::move(bad_message_callback).Run("CSDH_UNEXPECTED_OPERATION");
+  }
+
+  CacheStorageCacheHandle cache_handle_;
+
+  // Owns this.
+  CacheStorageDispatcherHost* const owner_;
+
+  base::WeakPtrFactory<CacheImpl> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CacheImpl);
+};
+
+CacheStorageDispatcherHost::CacheStorageDispatcherHost() = default;
+
+CacheStorageDispatcherHost::~CacheStorageDispatcherHost() = default;
 
 void CacheStorageDispatcherHost::Init(CacheStorageContextImpl* context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&CacheStorageDispatcherHost::CreateCacheListener, this,
-                     base::RetainedRef(context)));
-}
-
-void CacheStorageDispatcherHost::OnDestruct() const {
-  BrowserThread::DeleteOnIOThread::Destruct(this);
-}
-
-bool CacheStorageDispatcherHost::OnMessageReceived(
-    const IPC::Message& message) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(CacheStorageDispatcherHost, message)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageHas, OnCacheStorageHas)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageOpen, OnCacheStorageOpen)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageDelete,
-                      OnCacheStorageDelete)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageKeys, OnCacheStorageKeys)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheStorageMatch,
-                      OnCacheStorageMatch)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheMatch, OnCacheMatch)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheMatchAll, OnCacheMatchAll)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheKeys, OnCacheKeys)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheBatch, OnCacheBatch)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_CacheClosed, OnCacheClosed)
-  IPC_MESSAGE_HANDLER(CacheStorageHostMsg_BlobDataHandled, OnBlobDataHandled)
-  IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  if (!handled)
-    bad_message::ReceivedBadMessage(this, bad_message::CSDH_NOT_RECOGNIZED);
-  return handled;
+      base::BindOnce(&CacheStorageDispatcherHost::CreateCacheListener,
+                     base::RetainedRef(this), base::RetainedRef(context)));
 }
 
 void CacheStorageDispatcherHost::CreateCacheListener(
@@ -97,241 +245,121 @@ void CacheStorageDispatcherHost::CreateCacheListener(
   context_ = context;
 }
 
-void CacheStorageDispatcherHost::OnCacheStorageHas(
-    int thread_id,
-    int request_id,
-    const url::Origin& origin,
-    const base::string16& cache_name) {
+void CacheStorageDispatcherHost::Has(
+    const base::string16& cache_name,
+    blink::mojom::CacheStorage::HasCallback callback) {
   TRACE_EVENT0("CacheStorage", "CacheStorageDispatcherHost::OnCacheStorageHas");
+  url::Origin origin = bindings_.dispatch_context();
   if (!OriginCanAccessCacheStorage(origin)) {
-    bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
+    bindings_.ReportBadMessage("CSDH_INVALID_ORIGIN");
     return;
   }
+  if (!ValidState())
+    return;
   context_->cache_manager()->HasCache(
       origin, base::UTF16ToUTF8(cache_name),
-      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageHasCallback,
-                     this, thread_id, request_id));
+      base::BindOnce(&CacheStorageDispatcherHost::OnHasCallback, this,
+                     std::move(callback)));
 }
 
-void CacheStorageDispatcherHost::OnCacheStorageOpen(
-    int thread_id,
-    int request_id,
-    const url::Origin& origin,
-    const base::string16& cache_name) {
+void CacheStorageDispatcherHost::Open(
+    const base::string16& cache_name,
+    blink::mojom::CacheStorage::OpenCallback callback) {
   TRACE_EVENT0("CacheStorage",
                "CacheStorageDispatcherHost::OnCacheStorageOpen");
+  url::Origin origin = bindings_.dispatch_context();
   if (!OriginCanAccessCacheStorage(origin)) {
-    bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
+    bindings_.ReportBadMessage("CSDH_INVALID_ORIGIN");
     return;
   }
+  if (!ValidState())
+    return;
   context_->cache_manager()->OpenCache(
       origin, base::UTF16ToUTF8(cache_name),
-      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageOpenCallback,
-                     this, thread_id, request_id));
+      base::BindOnce(&CacheStorageDispatcherHost::OnOpenCallback, this, origin,
+                     std::move(callback)));
 }
 
-void CacheStorageDispatcherHost::OnCacheStorageDelete(
-    int thread_id,
-    int request_id,
-    const url::Origin& origin,
-    const base::string16& cache_name) {
+void CacheStorageDispatcherHost::Delete(
+    const base::string16& cache_name,
+    blink::mojom::CacheStorage::DeleteCallback callback) {
   TRACE_EVENT0("CacheStorage",
                "CacheStorageDispatcherHost::OnCacheStorageDelete");
+  url::Origin origin = bindings_.dispatch_context();
   if (!OriginCanAccessCacheStorage(origin)) {
-    bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
+    bindings_.ReportBadMessage("CSDH_INVALID_ORIGIN");
     return;
   }
-  context_->cache_manager()->DeleteCache(
-      origin, base::UTF16ToUTF8(cache_name),
-      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageDeleteCallback,
-                     this, thread_id, request_id));
+  if (!ValidState())
+    return;
+  context_->cache_manager()->DeleteCache(origin, base::UTF16ToUTF8(cache_name),
+                                         std::move(callback));
 }
 
-void CacheStorageDispatcherHost::OnCacheStorageKeys(int thread_id,
-                                                    int request_id,
-                                                    const url::Origin& origin) {
+void CacheStorageDispatcherHost::Keys(
+    blink::mojom::CacheStorage::KeysCallback callback) {
   TRACE_EVENT0("CacheStorage",
                "CacheStorageDispatcherHost::OnCacheStorageKeys");
+  url::Origin origin = bindings_.dispatch_context();
+
   if (!OriginCanAccessCacheStorage(origin)) {
-    bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
+    bindings_.ReportBadMessage("CSDH_INVALID_ORIGIN");
     return;
   }
+  if (!ValidState())
+    return;
   context_->cache_manager()->EnumerateCaches(
-      origin,
-      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageKeysCallback,
-                     this, thread_id, request_id));
+      origin, base::BindOnce(&CacheStorageDispatcherHost::OnKeysCallback, this,
+                             std::move(callback)));
 }
 
-void CacheStorageDispatcherHost::OnCacheStorageMatch(
-    int thread_id,
-    int request_id,
-    const url::Origin& origin,
-    const ServiceWorkerFetchRequest& request,
-    const CacheStorageCacheQueryParams& match_params) {
+void CacheStorageDispatcherHost::Match(
+    const content::ServiceWorkerFetchRequest& request,
+    const content::CacheStorageCacheQueryParams& match_params,
+    blink::mojom::CacheStorage::MatchCallback callback) {
   TRACE_EVENT0("CacheStorage",
                "CacheStorageDispatcherHost::OnCacheStorageMatch");
+  url::Origin origin = bindings_.dispatch_context();
   if (!OriginCanAccessCacheStorage(origin)) {
-    bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
+    bindings_.ReportBadMessage("CSDH_INVALID_ORIGIN");
     return;
   }
-  std::unique_ptr<ServiceWorkerFetchRequest> scoped_request(
-      new ServiceWorkerFetchRequest(request.url, request.method,
-                                    request.headers, request.referrer,
-                                    request.is_reload));
+  if (!ValidState())
+    return;
+  auto scoped_request = std::make_unique<ServiceWorkerFetchRequest>(
+      request.url, request.method, request.headers, request.referrer,
+      request.is_reload);
 
   if (match_params.cache_name.is_null()) {
     context_->cache_manager()->MatchAllCaches(
-        origin, std::move(scoped_request), match_params,
-        base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageMatchCallback,
-                       this, thread_id, request_id));
+        origin, std::move(scoped_request), std::move(match_params),
+        base::BindOnce(&CacheStorageDispatcherHost::OnMatchCallback, this,
+                       std::move(callback)));
     return;
   }
   context_->cache_manager()->MatchCache(
       origin, base::UTF16ToUTF8(match_params.cache_name.string()),
-      std::move(scoped_request), match_params,
-      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageMatchCallback,
-                     this, thread_id, request_id));
-}
-
-void CacheStorageDispatcherHost::OnCacheMatch(
-    int thread_id,
-    int request_id,
-    int cache_id,
-    const ServiceWorkerFetchRequest& request,
-    const CacheStorageCacheQueryParams& match_params) {
-  IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
-  if (it == id_to_cache_map_.end() || !it->second.value()) {
-    Send(new CacheStorageMsg_CacheMatchError(
-        thread_id, request_id, CacheStorageError::kErrorNotFound));
-    return;
-  }
-
-  CacheStorageCache* cache = it->second.value();
-  std::unique_ptr<ServiceWorkerFetchRequest> scoped_request(
-      new ServiceWorkerFetchRequest(request.url, request.method,
-                                    request.headers, request.referrer,
-                                    request.is_reload));
-  cache->Match(std::move(scoped_request), match_params,
-               base::BindOnce(&CacheStorageDispatcherHost::OnCacheMatchCallback,
-                              this, thread_id, request_id, it->second.Clone()));
-}
-
-void CacheStorageDispatcherHost::OnCacheMatchAll(
-    int thread_id,
-    int request_id,
-    int cache_id,
-    const ServiceWorkerFetchRequest& request,
-    const CacheStorageCacheQueryParams& match_params) {
-  IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
-  if (it == id_to_cache_map_.end() || !it->second.value()) {
-    Send(new CacheStorageMsg_CacheMatchError(
-        thread_id, request_id, CacheStorageError::kErrorNotFound));
-    return;
-  }
-
-  CacheStorageCache* cache = it->second.value();
-  if (request.url.is_empty()) {
-    cache->MatchAll(
-        std::unique_ptr<ServiceWorkerFetchRequest>(), match_params,
-        base::BindOnce(&CacheStorageDispatcherHost::OnCacheMatchAllCallback,
-                       this, thread_id, request_id, it->second.Clone()));
-    return;
-  }
-
-  std::unique_ptr<ServiceWorkerFetchRequest> scoped_request(
-      new ServiceWorkerFetchRequest(request.url, request.method,
-                                    request.headers, request.referrer,
-                                    request.is_reload));
-  if (match_params.ignore_search) {
-    cache->MatchAll(
-        std::move(scoped_request), match_params,
-        base::BindOnce(&CacheStorageDispatcherHost::OnCacheMatchAllCallback,
-                       this, thread_id, request_id, it->second.Clone()));
-    return;
-  }
-  cache->Match(std::move(scoped_request), match_params,
-               base::BindOnce(
-                   &CacheStorageDispatcherHost::OnCacheMatchAllCallbackAdapter,
-                   this, thread_id, request_id, it->second.Clone()));
-}
-
-void CacheStorageDispatcherHost::OnCacheKeys(
-    int thread_id,
-    int request_id,
-    int cache_id,
-    const ServiceWorkerFetchRequest& request,
-    const CacheStorageCacheQueryParams& match_params) {
-  IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
-  if (it == id_to_cache_map_.end() || !it->second.value()) {
-    Send(new CacheStorageMsg_CacheKeysError(thread_id, request_id,
-                                            CacheStorageError::kErrorNotFound));
-    return;
-  }
-
-  CacheStorageCache* cache = it->second.value();
-  std::unique_ptr<ServiceWorkerFetchRequest> request_ptr(
-      new ServiceWorkerFetchRequest(request.url, request.method,
-                                    request.headers, request.referrer,
-                                    request.is_reload));
-  cache->Keys(std::move(request_ptr), match_params,
-              base::BindOnce(&CacheStorageDispatcherHost::OnCacheKeysCallback,
-                             this, thread_id, request_id, it->second.Clone()));
-}
-
-void CacheStorageDispatcherHost::OnCacheBatch(
-    int thread_id,
-    int request_id,
-    int cache_id,
-    const std::vector<CacheStorageBatchOperation>& operations) {
-  IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
-  if (it == id_to_cache_map_.end() || !it->second.value()) {
-    Send(new CacheStorageMsg_CacheBatchError(
-        thread_id, request_id, CacheStorageError::kErrorNotFound));
-    return;
-  }
-
-  CacheStorageCache* cache = it->second.value();
-  cache->BatchOperation(
-      operations,
-      base::BindOnce(&CacheStorageDispatcherHost::OnCacheBatchCallback, this,
-                     thread_id, request_id, it->second.Clone()),
-      base::BindOnce(&CacheStorageDispatcherHost::OnBadMessage, this));
-}
-
-void CacheStorageDispatcherHost::OnCacheClosed(int cache_id) {
-  DropCacheReference(cache_id);
-}
-
-void CacheStorageDispatcherHost::OnBlobDataHandled(const std::string& uuid) {
-  DropBlobDataHandle(uuid);
+      std::move(scoped_request), std::move(match_params),
+      base::BindOnce(&CacheStorageDispatcherHost::OnMatchCallback, this,
+                     std::move(callback)));
 }
 
-void CacheStorageDispatcherHost::OnCacheStorageHasCallback(
-    int thread_id,
-    int request_id,
+void CacheStorageDispatcherHost::OnHasCallback(
+    blink::mojom::CacheStorage::HasCallback callback,
     bool has_cache,
     CacheStorageError error) {
-  if (error != CacheStorageError::kSuccess) {
-    Send(
-        new CacheStorageMsg_CacheStorageHasError(thread_id, request_id, error));
-    return;
-  }
-  if (!has_cache) {
-    Send(new CacheStorageMsg_CacheStorageHasError(
-        thread_id, request_id, CacheStorageError::kErrorNotFound));
-    return;
-  }
-  Send(new CacheStorageMsg_CacheStorageHasSuccess(thread_id, request_id));
+  if (!has_cache)
+    error = CacheStorageError::kErrorNotFound;
+  std::move(callback).Run(error);
 }
 
-void CacheStorageDispatcherHost::OnCacheStorageOpenCallback(
-    int thread_id,
-    int request_id,
+void CacheStorageDispatcherHost::OnOpenCallback(
+    url::Origin origin,
+    blink::mojom::CacheStorage::OpenCallback callback,
     CacheStorageCacheHandle cache_handle,
     CacheStorageError error) {
   if (error != CacheStorageError::kSuccess) {
-    Send(new CacheStorageMsg_CacheStorageOpenError(thread_id, request_id,
-                                                   error));
+    std::move(callback).Run(blink::mojom::OpenResult::NewStatus(error));
     return;
   }
 
@@ -341,174 +369,53 @@ void CacheStorageDispatcherHost::OnCacheStorageOpenCallback(
       FROM_HERE, base::BindOnce(&StopPreservingCache, cache_handle.Clone()),
       base::TimeDelta::FromSeconds(kCachePreservationSeconds));
 
-  CacheID cache_id = StoreCacheReference(std::move(cache_handle));
-  Send(new CacheStorageMsg_CacheStorageOpenSuccess(thread_id, request_id,
-                                                   cache_id));
-}
+  blink::mojom::CacheStorageCacheAssociatedPtrInfo ptr_info;
+  auto request = mojo::MakeRequest(&ptr_info);
+  auto cache_impl = std::make_unique<CacheImpl>(std::move(cache_handle), this);
+  cache_bindings_.AddBinding(std::move(cache_impl), std::move(request));
 
-void CacheStorageDispatcherHost::OnCacheStorageDeleteCallback(
-    int thread_id,
-    int request_id,
-    bool deleted,
-    CacheStorageError error) {
-  if (!deleted || error != CacheStorageError::kSuccess) {
-    Send(new CacheStorageMsg_CacheStorageDeleteError(thread_id, request_id,
-                                                     error));
-    return;
-  }
-  Send(new CacheStorageMsg_CacheStorageDeleteSuccess(thread_id, request_id));
+  std::move(callback).Run(
+      blink::mojom::OpenResult::NewCache(std::move(ptr_info)));
 }
 
-void CacheStorageDispatcherHost::OnCacheStorageKeysCallback(
-    int thread_id,
-    int request_id,
+void CacheStorageDispatcherHost::OnKeysCallback(
+    blink::mojom::CacheStorage::KeysCallback callback,
     const CacheStorageIndex& cache_index) {
   std::vector<base::string16> string16s;
-  for (const auto& metadata : cache_index.ordered_cache_metadata())
+  for (const auto& metadata : cache_index.ordered_cache_metadata()) {
     string16s.push_back(base::UTF8ToUTF16(metadata.name));
-  Send(new CacheStorageMsg_CacheStorageKeysSuccess(thread_id, request_id,
-                                                   string16s));
-}
-
-void CacheStorageDispatcherHost::OnCacheStorageMatchCallback(
-    int thread_id,
-    int request_id,
-    CacheStorageError error,
-    std::unique_ptr<ServiceWorkerResponse> response,
-    std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
-  if (error != CacheStorageError::kSuccess) {
-    Send(new CacheStorageMsg_CacheStorageMatchError(thread_id, request_id,
-                                                    error));
-    return;
   }
 
-  if (blob_data_handle)
-    StoreBlobDataHandle(*blob_data_handle);
-
-  Send(new CacheStorageMsg_CacheStorageMatchSuccess(thread_id, request_id,
-                                                    *response));
+  std::move(callback).Run(string16s);
 }
 
-void CacheStorageDispatcherHost::OnCacheMatchCallback(
-    int thread_id,
-    int request_id,
-    CacheStorageCacheHandle cache_handle,
+void CacheStorageDispatcherHost::OnMatchCallback(
+    blink::mojom::CacheStorage::MatchCallback callback,
     CacheStorageError error,
-    std::unique_ptr<ServiceWorkerResponse> response,
-    std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
+    std::unique_ptr<ServiceWorkerResponse> response) {
   if (error != CacheStorageError::kSuccess) {
-    Send(new CacheStorageMsg_CacheMatchError(thread_id, request_id, error));
-    return;
-  }
-
-  if (blob_data_handle)
-    StoreBlobDataHandle(*blob_data_handle);
-
-  Send(new CacheStorageMsg_CacheMatchSuccess(thread_id, request_id, *response));
-}
-
-void CacheStorageDispatcherHost::OnCacheMatchAllCallbackAdapter(
-    int thread_id,
-    int request_id,
-    CacheStorageCacheHandle cache_handle,
-    CacheStorageError error,
-    std::unique_ptr<ServiceWorkerResponse> response,
-    std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
-  std::vector<ServiceWorkerResponse> responses;
-  std::unique_ptr<CacheStorageCache::BlobDataHandles> blob_data_handles(
-      new CacheStorageCache::BlobDataHandles);
-  if (error == CacheStorageError::kSuccess) {
-    DCHECK(response);
-    responses.push_back(*response);
-    if (blob_data_handle)
-      blob_data_handles->push_back(std::move(blob_data_handle));
-  }
-  OnCacheMatchAllCallback(thread_id, request_id, std::move(cache_handle), error,
-                          std::move(responses), std::move(blob_data_handles));
-}
-
-void CacheStorageDispatcherHost::OnCacheMatchAllCallback(
-    int thread_id,
-    int request_id,
-    CacheStorageCacheHandle cache_handle,
-    CacheStorageError error,
-    std::vector<ServiceWorkerResponse> responses,
-    std::unique_ptr<CacheStorageCache::BlobDataHandles> blob_data_handles) {
-  if (error != CacheStorageError::kSuccess &&
-      error != CacheStorageError::kErrorNotFound) {
-    Send(new CacheStorageMsg_CacheMatchAllError(thread_id, request_id, error));
+    std::move(callback).Run(blink::mojom::MatchResult::NewStatus(error));
     return;
   }
 
-  for (const auto& handle : *blob_data_handles) {
-    if (handle)
-      StoreBlobDataHandle(*handle);
-  }
-
-  Send(new CacheStorageMsg_CacheMatchAllSuccess(thread_id, request_id,
-                                                responses));
+  std::move(callback).Run(
+      blink::mojom::MatchResult::NewResponse(std::move(*response)));
 }
 
-void CacheStorageDispatcherHost::OnCacheKeysCallback(
-    int thread_id,
-    int request_id,
-    CacheStorageCacheHandle cache_handle,
-    CacheStorageError error,
-    std::unique_ptr<CacheStorageCache::Requests> requests) {
-  if (error != CacheStorageError::kSuccess) {
-    Send(new CacheStorageMsg_CacheKeysError(thread_id, request_id, error));
-    return;
-  }
-
-  Send(new CacheStorageMsg_CacheKeysSuccess(thread_id, request_id, *requests));
+void CacheStorageDispatcherHost::AddBinding(
+    blink::mojom::CacheStorageRequest request,
+    const url::Origin& origin) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  bindings_.AddBinding(this, std::move(request), origin);
 }
 
-void CacheStorageDispatcherHost::OnCacheBatchCallback(
-    int thread_id,
-    int request_id,
-    CacheStorageCacheHandle cache_handle,
-    CacheStorageError error) {
-  if (error != CacheStorageError::kSuccess) {
-    Send(new CacheStorageMsg_CacheBatchError(thread_id, request_id, error));
-    return;
+bool CacheStorageDispatcherHost::ValidState() {
+  // cache_manager() can return nullptr when process is shutting down.
+  if (!(context_ && context_->cache_manager())) {
+    bindings_.CloseAllBindings();
+    return false;
   }
-
-  Send(new CacheStorageMsg_CacheBatchSuccess(thread_id, request_id));
-}
-
-void CacheStorageDispatcherHost::OnBadMessage(
-    bad_message::BadMessageReason reason) {
-  bad_message::ReceivedBadMessage(this, reason);
-}
-
-CacheStorageDispatcherHost::CacheID
-CacheStorageDispatcherHost::StoreCacheReference(
-    CacheStorageCacheHandle cache_handle) {
-  int cache_id = next_cache_id_++;
-  id_to_cache_map_[cache_id] = std::move(cache_handle);
-  return cache_id;
-}
-
-void CacheStorageDispatcherHost::DropCacheReference(CacheID cache_id) {
-  id_to_cache_map_.erase(cache_id);
-}
-
-void CacheStorageDispatcherHost::StoreBlobDataHandle(
-    const storage::BlobDataHandle& blob_data_handle) {
-  std::pair<UUIDToBlobDataHandleList::iterator, bool> rv =
-      blob_handle_store_.insert(std::make_pair(
-          blob_data_handle.uuid(), std::list<storage::BlobDataHandle>()));
-  rv.first->second.push_front(storage::BlobDataHandle(blob_data_handle));
-}
-
-void CacheStorageDispatcherHost::DropBlobDataHandle(const std::string& uuid) {
-  UUIDToBlobDataHandleList::iterator it = blob_handle_store_.find(uuid);
-  if (it == blob_handle_store_.end())
-    return;
-  DCHECK(!it->second.empty());
-  it->second.pop_front();
-  if (it->second.empty())
-    blob_handle_store_.erase(it);
+  return true;
 }
 
 }  // namespace content