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>
+
+using blink::WebServiceWorkerCacheStorage;
 
 namespace WebCore {
 
-PassRefPtrWillBeRawPtr<CacheStorage> CacheStorage::create()
+namespace {
+
+const char* CacheStorageErrorToString(WebServiceWorkerCacheStorage::CacheStorageError reason)
 {
-    return adoptRefWillBeNoop(new CacheStorage());
+    // TODO: Construct correct DOM error objects rather than returning strings.
+    switch (reason) {
+    case WebServiceWorkerCacheStorage::CacheStorageError::CacheStorageErrorNotImplemented:
+        return "not implemented";
+    case WebServiceWorkerCacheStorage::CacheStorageError::CacheStorageErrorNotFound:
+        return "not found";
+    case WebServiceWorkerCacheStorage::CacheStorageError::CacheStorageErrorExists:
+        return "entry already exists";
+    default:
+        ASSERT_NOT_REACHED();
+        return "unknown error";
+    }
 }
 
-// FIXME: Implement every one of these methods.
+class CacheStorageCallbacks : public WebServiceWorkerCacheStorage::CacheStorageCallbacks {
+public:
+    CacheStorageCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(resolver) { }
+    virtual ~CacheStorageCallbacks() { }
+
+    virtual void onSuccess() OVERRIDE
+    {
+        m_resolver->resolve(true);
+    }
+
+    virtual void onError(WebServiceWorkerCacheStorage::CacheStorageError* reason) OVERRIDE
+    {
+        m_resolver->reject(CacheStorageErrorToString(*reason));
+    }
+
+private:
+    const RefPtr<ScriptPromiseResolver> m_resolver;
+};
+
+class CacheStorageWithCacheCallbacks : public WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks {
+public:
+    CacheStorageWithCacheCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(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);
+    }
+
+    virtual void onError(WebServiceWorkerCacheStorage::CacheStorageError* reason) OVERRIDE
+    {
+        m_resolver->reject(CacheStorageErrorToString(*reason));
+    }
+
+private:
+    const RefPtr<ScriptPromiseResolver> m_resolver;
+};
+
+class CacheStorageKeysCallbacks : public WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks {
+public:
+    CacheStorageKeysCallbacks(ScriptState* scriptState, PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(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);
+    }
+
+    virtual void onError(WebServiceWorkerCacheStorage::CacheStorageError* reason) OVERRIDE
+    {
+        m_resolver->reject(CacheStorageErrorToString(*reason));
+    }
+
+private:
+    const RefPtr<ScriptPromiseResolver> m_resolver;
+    const RefPtr<ScriptState> m_scriptState;
+};
+
+}
+
+PassRefPtr<CacheStorage> CacheStorage::create(blink::WebServiceWorkerCacheStorage* webCacheStorage)

[michaeln, 2014/07/25 20:25:19]

shouldn't need the blink:: here

[gavinp, 2014/07/28 02:10:16]

Done, and one more below.

+{
+    return adoptRefWillBeNoop(new CacheStorage(webCacheStorage));
+}
+
 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)

[michaeln, 2014/07/25 20:25:19]

or here

[gavinp, 2014/07/28 02:10:16]

Done.

 {
     ScriptWrappable::init(this);
 }
 
 } // namespace WebCore