Introducing the WebServiceWorkerCacheStorage.

Source/modules/serviceworkers/CacheStorage.cpp

Index: Source/modules/serviceworkers/CacheStorage.cpp
diff --git a/Source/modules/serviceworkers/CacheStorage.cpp b/Source/modules/serviceworkers/CacheStorage.cpp
index f0d8aebfe66bba2c3f0abf4235de8f179b9e9696..4ec6e883bb0c884fdd05be905413c55c86f48cd9 100644
--- a/Source/modules/serviceworkers/CacheStorage.cpp
+++ b/Source/modules/serviceworkers/CacheStorage.cpp
@@ -7,25 +7,108 @@
 
 #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;
 }
@@ -35,7 +118,10 @@ ScriptPromise CacheStorage::rename(ScriptState* scriptState, const String& oldKe
     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;
 }
@@ -45,7 +131,10 @@ 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;
 }
@@ -55,7 +144,10 @@ ScriptPromise CacheStorage::deleteFunction(ScriptState* scriptState, const Strin
     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;
 }
@@ -65,12 +157,15 @@ 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);
 }