Introducing the WebServiceWorkerCacheStorage.

Source/modules/serviceworkers/CacheStorage.cpp

 // Copyright 2014 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 "config.h"
 #include "modules/serviceworkers/CacheStorage.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
+#include "public/platform/WebServiceWorkerCacheStorage.h"
+#include <v8.h>
 
 namespace WebCore {
 
-PassRefPtr<CacheStorage> CacheStorage::create()
+namespace {
+
+class BaseCacheStorageCallbacks {
+protected:
+    typedef blink::WebServiceWorkerCacheStorage::ErrorReason ErrorReason;
+
+    BaseCacheStorageCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(resolver) { }
+
+    void onError(ErrorReason* reason)
+    {
+        // TODO: Construct correct DOM error objects.
+        const char* errorReasonString = 0;
+        switch (*reason) {
+        case ErrorReason::CacheStorageErrorNotImplemented:
+            errorReasonString = "not implemented";
+            break;
+        case ErrorReason::CacheStorageErrorNotFound:
+            errorReasonString = "not found";
+            break;
+        case ErrorReason::CacheStorageErrorExists:
+            errorReasonString = "entry already exists";
+            break;
+        }
+
+        m_resolver->reject(errorReasonString);
+    }
+
+    RefPtr<ScriptPromiseResolver> m_resolver;
+};
+
+class CacheStorageCallbacks : public BaseCacheStorageCallbacks, public blink::WebServiceWorkerCacheStorage::CacheStorageCallbacks {
+public:
+    CacheStorageCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : BaseCacheStorageCallbacks(resolver) { }
+    virtual ~CacheStorageCallbacks() { }
+
+    virtual void onSuccess() OVERRIDE
+    {
+        m_resolver->resolve(true);
+    }
+
+    using BaseCacheStorageCallbacks::onError;
+};
+
+class CacheStorageWithCacheCallbacks : public BaseCacheStorageCallbacks, public blink::WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks {
+public:
+    CacheStorageWithCacheCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : BaseCacheStorageCallbacks(resolver) { }
+    virtual ~CacheStorageWithCacheCallbacks() { }
+
+    virtual void onSuccess(int* cacheId) OVERRIDE
+    {
+        // TODO: There should be a blink side of the Cache object implementation here, rather than
+        // this nonsensical pass through.
+        m_resolver->resolve(*cacheId);
+    }
+
+    using BaseCacheStorageCallbacks::onError;
+};
+
+class CacheStorageKeysCallbacks : public BaseCacheStorageCallbacks, public blink::WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks {
+public:
+    CacheStorageKeysCallbacks(ScriptState* scriptState, PassRefPtr<ScriptPromiseResolver> resolver) : BaseCacheStorageCallbacks(resolver), m_scriptState(scriptState) { }
+    virtual ~CacheStorageKeysCallbacks() { }
+
+    virtual void onSuccess(blink::WebVector<blink::WebString>* keys) OVERRIDE
+    {
+        Vector<String> wtfKeys;
+        for (size_t i = 0; i < keys->size(); ++i)
+            wtfKeys.append((*keys)[i]);
+        m_resolver->resolve(wtfKeys);
+    }
+
+    using BaseCacheStorageCallbacks::onError;
+
+private:
+    const RefPtr<ScriptState> m_scriptState;
+};
+
+}
+
+PassRefPtr<CacheStorage> CacheStorage::create(blink::WebServiceWorkerCacheStorage* webCacheStorage)
 {
-    return adoptRef(new CacheStorage());
+    return adoptRef(new CacheStorage(webCacheStorage));
 }
 
 CacheStorage::~CacheStorage()
 {
 }
 
-// FIXME: Implement every one of these methods.
 ScriptPromise CacheStorage::createFunction(ScriptState* scriptState, const String& key)
 {
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
 
-    resolver->reject("not implemented");
+    if (m_webCacheStorage)
+        m_webCacheStorage->dispatchCreate(new CacheStorageWithCacheCallbacks(resolver), key);
+    else
+        resolver->reject("no implementation provided");
 
     return promise;
 }
 
 ScriptPromise CacheStorage::rename(ScriptState* scriptState, const String& oldKey, const String& newKey)
 {
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
 
-    resolver->reject("not implemented");
+    if (m_webCacheStorage)
+        m_webCacheStorage->dispatchRename(new CacheStorageCallbacks(resolver), oldKey, newKey);
+    else
+        resolver->reject("no implementation provided");
 
     return promise;
 }
 
 ScriptPromise CacheStorage::get(ScriptState* scriptState, const String& key)
 {
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
 
-    resolver->reject("not implemented");
+    if (m_webCacheStorage)
+        m_webCacheStorage->dispatchGet(new CacheStorageWithCacheCallbacks(resolver), key);
+    else
+        resolver->reject("no implementation provided");
 
     return promise;
 }
 
 ScriptPromise CacheStorage::deleteFunction(ScriptState* scriptState, const String& key)
 {
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
 
-    resolver->reject("not implemented");
+    if (m_webCacheStorage)
+        m_webCacheStorage->dispatchDelete(new CacheStorageCallbacks(resolver), key);
+    else
+        resolver->reject("no implementation provided");
 
     return promise;
 }
 
 ScriptPromise CacheStorage::keys(ScriptState* scriptState)
 {
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
 
-    resolver->reject("not implemented");
+    if (m_webCacheStorage)
+        m_webCacheStorage->dispatchKeys(new CacheStorageKeysCallbacks(scriptState, resolver));
+    else
+        resolver->reject("no implementation provided");
 
     return promise;
 }
 
-CacheStorage::CacheStorage()
+CacheStorage::CacheStorage(blink::WebServiceWorkerCacheStorage* webCacheStorage) : m_webCacheStorage(webCacheStorage)
 {
     ScriptWrappable::init(this);
 }
 
 } // namespace WebCore