Update To 11.40.268.0

[platform/framework/web/crosswalk.git] / src / content / browser / service_worker / service_worker_cache_listener.h

diff --git a/src/content/browser/service_worker/service_worker_cache_listener.h b/src/content/browser/service_worker/service_worker_cache_listener.h
index 4f1f4a4..d0364f3 100644 (file)
--- a/src/content/browser/service_worker/service_worker_cache_listener.h
+++ b/src/content/browser/service_worker/service_worker_cache_listener.h
@@ -5,9 +5,13 @@
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CACHE_LISTENER_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CACHE_LISTENER_H_
 
+#include <list>
+#include <map>
+
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
+#include "content/browser/service_worker/service_worker_cache.h"
 #include "content/browser/service_worker/service_worker_cache_storage.h"
 
 namespace content {
@@ -24,10 +28,10 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
  public:
   ServiceWorkerCacheListener(ServiceWorkerVersion* version,
                              base::WeakPtr<ServiceWorkerContextCore> context);
-  virtual ~ServiceWorkerCacheListener();
+  ~ServiceWorkerCacheListener() override;
 
   // From EmbeddedWorkerInstance::Listener:
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  bool OnMessageReceived(const IPC::Message& message) override;
 
  private:
   // The message receiver functions for the CacheStorage API:
@@ -35,6 +39,7 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
   void OnCacheStorageHas(int request_id, const base::string16& cache_name);
   void OnCacheStorageCreate(int request_id,
                           const base::string16& cache_name);
+  void OnCacheStorageOpen(int request_id, const base::string16& cache_name);
   void OnCacheStorageDelete(int request_id,
                            const base::string16& cache_name);
   void OnCacheStorageKeys(int request_id);
@@ -56,13 +61,17 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
                     int cache_id,
                     const std::vector<ServiceWorkerBatchOperation>& operations);
   void OnCacheClosed(int cache_id);
+  void OnBlobDataHandled(const std::string& uuid);
 
  private:
   typedef int32_t CacheID;  // TODO(jkarlin): Bump to 64 bit.
-  typedef std::map<CacheID, scoped_refptr<ServiceWorkerCache> > IDToCacheMap;
+  typedef std::map<CacheID, scoped_refptr<ServiceWorkerCache>> IDToCacheMap;
+  typedef std::map<std::string, std::list<storage::BlobDataHandle>>
+      UUIDToBlobDataHandleList;
 
   void Send(const IPC::Message& message);
 
+  // CacheStorageManager callbacks
   void OnCacheStorageGetCallback(
       int request_id,
       const scoped_refptr<ServiceWorkerCache>& cache,
@@ -75,6 +84,10 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
       int request_id,
       const scoped_refptr<ServiceWorkerCache>& cache,
       ServiceWorkerCacheStorage::CacheStorageError error);
+  void OnCacheStorageOpenCallback(
+      int request_id,
+      const scoped_refptr<ServiceWorkerCache>& cache,
+      ServiceWorkerCacheStorage::CacheStorageError error);
   void OnCacheStorageDeleteCallback(
       int request_id,
       bool deleted,
@@ -84,12 +97,38 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
       const std::vector<std::string>& strings,
       ServiceWorkerCacheStorage::CacheStorageError error);
 
+  // Cache callbacks
+  void OnCacheMatchCallback(
+      int request_id,
+      const scoped_refptr<ServiceWorkerCache>& cache,
+      ServiceWorkerCache::ErrorType error,
+      scoped_ptr<ServiceWorkerResponse> response,
+      scoped_ptr<storage::BlobDataHandle> blob_data_handle);
+  void OnCacheKeysCallback(int request_id,
+                           const scoped_refptr<ServiceWorkerCache>& cache,
+                           ServiceWorkerCache::ErrorType error,
+                           scoped_ptr<ServiceWorkerCache::Requests> requests);
+  void OnCacheDeleteCallback(int request_id,
+                             const scoped_refptr<ServiceWorkerCache>& cache,
+                             ServiceWorkerCache::ErrorType error);
+  void OnCachePutCallback(int request_id,
+                          const scoped_refptr<ServiceWorkerCache>& cache,
+                          ServiceWorkerCache::ErrorType error,
+                          scoped_ptr<ServiceWorkerResponse> response,
+                          scoped_ptr<storage::BlobDataHandle> blob_data_handle);
+
   // Hangs onto a scoped_refptr for the cache if it isn't already doing so.
   // Returns a unique cache_id. Call DropCacheReference when the client is done
   // with this cache.
   CacheID StoreCacheReference(const scoped_refptr<ServiceWorkerCache>& cache);
   void DropCacheReference(CacheID cache_id);
 
+  // Stores blob handles while waiting for acknowledgement of receipt from the
+  // renderer.
+  void StoreBlobDataHandle(
+      scoped_ptr<storage::BlobDataHandle> blob_data_handle);
+  void DropBlobDataHandle(std::string uuid);
+
   // The ServiceWorkerVersion to use for messaging back to the renderer thread.
   ServiceWorkerVersion* version_;
 
@@ -99,6 +138,8 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
   IDToCacheMap id_to_cache_map_;
   CacheID next_cache_id_;
 
+  UUIDToBlobDataHandleList blob_handle_store_;
+
   base::WeakPtrFactory<ServiceWorkerCacheListener> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerCacheListener);