Introducing the WebServiceWorkerCache.

public/platform/WebServiceWorkerCache.h

+// 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.
+
+#ifndef WebServiceWorkerCache_h
+#define WebServiceWorkerCache_h
+
+#include "WebCommon.h"
+#include "public/platform/WebCallbacks.h"
+#include "public/platform/WebServiceWorkerCacheError.h"
+#include "public/platform/WebServiceWorkerRequest.h"
+#include "public/platform/WebServiceWorkerResponse.h"
+#include "public/platform/WebString.h"
+#include "public/platform/WebVector.h"
+
+namespace blink {
+
+// The Service Worker Cache API. The embedder provides the implementation of the Cache to Blink. Blink uses the interface
+// to operate on entries.
+// This object is owned by Blink, and should be destroyed as each Cache instance is no longer in use.
+class WebServiceWorkerCache {
+public:
+    typedef WebCallbacks<WebServiceWorkerResponse, WebServiceWorkerCacheError> CacheMatchCallbacks;
+    typedef WebCallbacks<WebVector<WebServiceWorkerResponse>, WebServiceWorkerCacheError> CacheWithResponsesCallbacks;
+    typedef WebCallbacks<WebVector<WebServiceWorkerRequest>, WebServiceWorkerCacheError> CacheWithRequestsCallbacks;
+
+    virtual ~WebServiceWorkerCache() { }
+
+    // The ProxyInterface is used to allow a single object in Blink to serve as its interface in JavaScript; so that == will
+    // always test two interfaces to the same cache as equal.
+    class ProxyInterface {
+    public:
+        virtual inline ~ProxyInterface() = 0;
+    };
+
+    // Options that affect the scope of searches.
+    struct QueryParams {
+        QueryParams() : ignoreSearch(false), ignoreMethod(false), ignoreVary(false), prefixMatch(false) { }
+
+        bool ignoreSearch;
+        bool ignoreMethod;
+        bool ignoreVary;
+        bool prefixMatch;
+    };
+
+    enum WebServiceWorkerCacheOperationType {
+        WebServiceWorkerCacheOperationTypeUndefined,
+        WebServiceWorkerCacheOperationTypePut,
+        WebServiceWorkerCacheOperationTypeDelete,
+        WebServiceWorkerCacheOperationTypeLast = WebServiceWorkerCacheOperationTypeDelete
+    };
+
+    struct BatchOperation {
+        BatchOperation() : operationType(WebServiceWorkerCacheOperationTypeUndefined) { }
+
+        WebServiceWorkerCacheOperationType operationType;
+        WebServiceWorkerRequest request;
+        WebServiceWorkerResponse response;
+        QueryParams matchParams;
+    };
+
+    WebServiceWorkerCache() : m_proxyInterface(0) { }
+
+    void setProxyInterface(ProxyInterface* proxyInterface) { m_proxyInterface = proxyInterface; }
+    ProxyInterface* proxyInterface() { return m_proxyInterface; }
+
+    // Ownership of the Cache*Callbacks methods passes to the WebServiceWorkerCache instance, which will delete it after
+    // calling onSuccess or onFailure.
+    virtual void dispatchMatch(CacheMatchCallbacks*, const WebServiceWorkerRequest&, const QueryParams&) = 0;
+    virtual void dispatchMatchAll(CacheWithResponsesCallbacks*, const WebServiceWorkerRequest&, const QueryParams&) = 0;
+    virtual void dispatchKeys(CacheWithRequestsCallbacks*, const WebServiceWorkerRequest*, const QueryParams&) = 0;
+    virtual void dispatchBatch(CacheWithResponsesCallbacks*, const WebVector<BatchOperation>&) = 0;
+
+private:
+    // The Cache is owned by the embedder, and should not be deleted from within Blink; instead use notifyDone(), above.

[dominicc (has gone to gerrit), 2014/08/14 02:35:12]

Ah... can you clarify what you mean by "the cache" here? I took it to mean the
blink::Cache instance, but that is not right.

[gavinp, 2014/08/14 22:34:07]

This comment is vestigial. Removing it.

+
+    ProxyInterface* m_proxyInterface;
+};
+
+// The pure virtual destructor makes the interface abstract, but we still want an inline destructor for descendents to call. Thus we
+// use the inline keyword and provide an out of line definition.
+inline WebServiceWorkerCache::ProxyInterface::~ProxyInterface() { }
+
+} // namespace blink
+
+#endif // WebServiceWorkerCache_h