Cleanup: Make quota dispatcher code independent from WebKit types

Preparing for pepper quota support.

Also adding NotifyStorageModified IPC method, which is intended to be used by pepper FileIO code.

BUG=for 86556
TEST=existing tests should pass

Review URL: http://codereview.chromium.org/7438001

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@94638 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 115 insertions, 73 deletions

diff --git a/content/browser/renderer_host/quota_dispatcher_host.cc b/content/browser/renderer_host/quota_dispatcher_host.cc
index ef44939..882a56d 100644
--- a/content/browser/renderer_host/quota_dispatcher_host.cc
+++ b/content/browser/renderer_host/quota_dispatcher_host.cc
@@ -9,13 +9,12 @@
 #include "content/common/quota_messages.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaError.h"
 #include "webkit/quota/quota_manager.h"
 
+using quota::QuotaClient;
 using quota::QuotaManager;
 using quota::QuotaStatusCode;
 using quota::StorageType;
-using WebKit::WebStorageQuotaError;
 
 // Created one per request to carry the request's request_id around.
 // Dispatches requests from renderer/worker to the QuotaManager and
@@ -72,8 +71,7 @@ class QuotaDispatcherHost::QueryUsageAndQuotaDispatcher
       QuotaStatusCode status, int64 usage, int64 quota) {
     DCHECK(dispatcher_host());
     if (status != quota::kQuotaStatusOk) {
-      dispatcher_host()->Send(new QuotaMsg_DidFail(
-          request_id(), static_cast<WebStorageQuotaError>(status)));
+      dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidQueryStorageUsageAndQuota(
           request_id(), usage, quota));
@@ -175,8 +173,7 @@ class QuotaDispatcherHost::RequestQuotaDispatcher
   void DidFinish(QuotaStatusCode status, int64 granted_quota) {
     DCHECK(dispatcher_host());
     if (status != quota::kQuotaStatusOk) {
-      dispatcher_host()->Send(new QuotaMsg_DidFail(
-          request_id(), static_cast<WebStorageQuotaError>(status)));
+      dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidGrantStorageQuota(
           request_id(), granted_quota));
@@ -222,17 +219,17 @@ bool QuotaDispatcherHost::OnMessageReceived(
 void QuotaDispatcherHost::OnQueryStorageUsageAndQuota(
     int request_id,
     const GURL& origin,
-    WebKit::WebStorageQuotaType type) {
+    StorageType type) {
   QueryUsageAndQuotaDispatcher* dispatcher = new QueryUsageAndQuotaDispatcher(
       this, request_id);
-  dispatcher->QueryStorageUsageAndQuota(origin, static_cast<StorageType>(type));
+  dispatcher->QueryStorageUsageAndQuota(origin, type);
 }
 
 void QuotaDispatcherHost::OnRequestStorageQuota(
     int render_view_id,
     int request_id,
     const GURL& origin,
-    WebKit::WebStorageQuotaType type,
+    StorageType type,
     int64 requested_size) {
   if (quota_manager_->IsStorageUnlimited(origin)) {
     // If the origin is marked 'unlimited' we always just return ok.
@@ -240,28 +237,14 @@ void QuotaDispatcherHost::OnRequestStorageQuota(
     return;
   }
 
-  StorageType storage_type = static_cast<StorageType>(type);
-  if (storage_type != quota::kStorageTypeTemporary &&
-      storage_type != quota::kStorageTypePersistent) {
+  if (type != quota::kStorageTypeTemporary &&
+      type != quota::kStorageTypePersistent) {
     // Unsupported storage types.
-    Send(new QuotaMsg_DidFail(
-        request_id,
-        WebKit::WebStorageQuotaErrorNotSupported));
+    Send(new QuotaMsg_DidFail(request_id, quota::kQuotaErrorNotSupported));
     return;
   }
 
   RequestQuotaDispatcher* dispatcher = new RequestQuotaDispatcher(
-      this, request_id, origin, storage_type,
-      requested_size, render_view_id);
+      this, request_id, origin, type, requested_size, render_view_id);
   dispatcher->Start();
 }
-
-COMPILE_ASSERT(int(WebKit::WebStorageQuotaTypeTemporary) == \
-               int(quota::kStorageTypeTemporary), mismatching_enums);
-COMPILE_ASSERT(int(WebKit::WebStorageQuotaTypePersistent) == \
-               int(quota::kStorageTypePersistent), mismatching_enums);
-
-COMPILE_ASSERT(int(WebKit::WebStorageQuotaErrorNotSupported) == \
-               int(quota::kQuotaErrorNotSupported), mismatching_enums);
-COMPILE_ASSERT(int(WebKit::WebStorageQuotaErrorAbort) == \
-               int(quota::kQuotaErrorAbort), mismatching_enums);
diff --git a/content/browser/renderer_host/quota_dispatcher_host.h b/content/browser/renderer_host/quota_dispatcher_host.h
index 49a0a5d..4e44b0f 100644
--- a/content/browser/renderer_host/quota_dispatcher_host.h
+++ b/content/browser/renderer_host/quota_dispatcher_host.h
@@ -8,7 +8,7 @@
 #include "base/basictypes.h"
 #include "base/id_map.h"
 #include "content/browser/browser_message_filter.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaType.h"
+#include "webkit/quota/quota_types.h"
 
 class GURL;
 
@@ -39,12 +39,12 @@ class QuotaDispatcherHost : public BrowserMessageFilter {
   void OnQueryStorageUsageAndQuota(
       int request_id,
       const GURL& origin_url,
-      WebKit::WebStorageQuotaType type);
+      quota::StorageType type);
   void OnRequestStorageQuota(
       int render_view_id,
       int request_id,
       const GURL& origin_url,
-      WebKit::WebStorageQuotaType type,
+      quota::StorageType type,
       int64 requested_size);
 
   // The ID of this process.
diff --git a/content/common/quota_dispatcher.cc b/content/common/quota_dispatcher.cc
index 905edc7..6b7d830 100644
--- a/content/common/quota_dispatcher.cc
+++ b/content/common/quota_dispatcher.cc
@@ -4,22 +4,54 @@
 
 #include "content/common/quota_dispatcher.h"
 
+#include "base/basictypes.h"
 #include "content/common/child_thread.h"
 #include "content/common/quota_messages.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaCallbacks.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaType.h"
+
+using quota::QuotaStatusCode;
+using quota::StorageType;
 
 using WebKit::WebStorageQuotaCallbacks;
 using WebKit::WebStorageQuotaError;
 using WebKit::WebStorageQuotaType;
 
+namespace {
+
+// QuotaDispatcher::Callback implementation for WebStorageQuotaCallbacks.
+class WebStorageQuotaDispatcherCallback : public QuotaDispatcher::Callback {
+ public:
+  WebStorageQuotaDispatcherCallback(WebKit::WebStorageQuotaCallbacks* callback)
+      : callbacks_(callback) {
+    DCHECK(callbacks_);
+  }
+  virtual ~WebStorageQuotaDispatcherCallback() {}
+  virtual void DidQueryStorageUsageAndQuota(int64 usage, int64 quota) OVERRIDE {
+    callbacks_->didQueryStorageUsageAndQuota(usage, quota);
+  }
+  virtual void DidGrantStorageQuota(int64 granted_quota) OVERRIDE {
+    callbacks_->didGrantStorageQuota(granted_quota);
+  }
+  virtual void DidFail(quota::QuotaStatusCode error) OVERRIDE {
+    callbacks_->didFail(static_cast<WebStorageQuotaError>(error));
+  }
+
+ private:
+  // Not owned (self-destructed).
+  WebKit::WebStorageQuotaCallbacks* callbacks_;
+};
+
+}  // namespace
+
 QuotaDispatcher::QuotaDispatcher() {
 }
 
 QuotaDispatcher::~QuotaDispatcher() {
-  IDMap<WebStorageQuotaCallbacks>::iterator iter(&pending_quota_callbacks_);
+  IDMap<Callback, IDMapOwnPointer>::iterator iter(&pending_quota_callbacks_);
   while (!iter.IsAtEnd()) {
-    iter.GetCurrentValue()->didFail(WebKit::WebStorageQuotaErrorAbort);
+    iter.GetCurrentValue()->DidFail(quota::kQuotaErrorAbort);
     iter.Advance();
   }
 }
@@ -39,10 +71,10 @@ bool QuotaDispatcher::OnMessageReceived(const IPC::Message& msg) {
 
 void QuotaDispatcher::QueryStorageUsageAndQuota(
     const GURL& origin_url,
-    WebStorageQuotaType type,
-    WebStorageQuotaCallbacks* callbacks) {
-  DCHECK(callbacks);
-  int request_id = pending_quota_callbacks_.Add(callbacks);
+    StorageType type,
+    Callback* callback) {
+  DCHECK(callback);
+  int request_id = pending_quota_callbacks_.Add(callback);
   ChildThread::current()->Send(new QuotaHostMsg_QueryStorageUsageAndQuota(
       request_id, origin_url, type));
 }
@@ -50,22 +82,28 @@ void QuotaDispatcher::QueryStorageUsageAndQuota(
 void QuotaDispatcher::RequestStorageQuota(
     int render_view_id,
     const GURL& origin_url,
-    WebStorageQuotaType type,
-    unsigned long long requested_size,
-    WebStorageQuotaCallbacks* callbacks) {
-  DCHECK(callbacks);
-  int request_id = pending_quota_callbacks_.Add(callbacks);
+    StorageType type,
+    int64 requested_size,
+    Callback* callback) {
+  DCHECK(callback);
+  int request_id = pending_quota_callbacks_.Add(callback);
   ChildThread::current()->Send(new QuotaHostMsg_RequestStorageQuota(
       render_view_id, request_id, origin_url, type, requested_size));
 }
 
+// static
+QuotaDispatcher::Callback*
+QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(
+    WebKit::WebStorageQuotaCallbacks* callbacks) {
+  return new WebStorageQuotaDispatcherCallback(callbacks);
+}
+
 void QuotaDispatcher::DidGrantStorageQuota(
     int request_id,
     int64 granted_quota) {
-  WebStorageQuotaCallbacks* callbacks = pending_quota_callbacks_.Lookup(
-      request_id);
-  DCHECK(callbacks);
-  callbacks->didGrantStorageQuota(granted_quota);
+  Callback* callback = pending_quota_callbacks_.Lookup(request_id);
+  DCHECK(callback);
+  callback->DidGrantStorageQuota(granted_quota);
   pending_quota_callbacks_.Remove(request_id);
 }
 
@@ -73,19 +111,27 @@ void QuotaDispatcher::DidQueryStorageUsageAndQuota(
     int request_id,
     int64 current_usage,
     int64 current_quota) {
-  WebStorageQuotaCallbacks* callbacks = pending_quota_callbacks_.Lookup(
-      request_id);
-  DCHECK(callbacks);
-  callbacks->didQueryStorageUsageAndQuota(current_usage, current_quota);
+  Callback* callback = pending_quota_callbacks_.Lookup(request_id);
+  DCHECK(callback);
+  callback->DidQueryStorageUsageAndQuota(current_usage, current_quota);
   pending_quota_callbacks_.Remove(request_id);
 }
 
 void QuotaDispatcher::DidFail(
     int request_id,
-    WebStorageQuotaError error) {
-  WebStorageQuotaCallbacks* callbacks = pending_quota_callbacks_.Lookup(
-      request_id);
-  DCHECK(callbacks);
-  callbacks->didFail(error);
+    QuotaStatusCode error) {
+  Callback* callback = pending_quota_callbacks_.Lookup(request_id);
+  DCHECK(callback);
+  callback->DidFail(error);
   pending_quota_callbacks_.Remove(request_id);
 }
+
+COMPILE_ASSERT(int(WebKit::WebStorageQuotaTypeTemporary) == \
+               int(quota::kStorageTypeTemporary), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebStorageQuotaTypePersistent) == \
+               int(quota::kStorageTypePersistent), mismatching_enums);
+
+COMPILE_ASSERT(int(WebKit::WebStorageQuotaErrorNotSupported) == \
+               int(quota::kQuotaErrorNotSupported), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebStorageQuotaErrorAbort) == \
+               int(quota::kQuotaErrorAbort), mismatching_enums);
diff --git a/content/common/quota_dispatcher.h b/content/common/quota_dispatcher.h
index 06b456e..4faa0e1 100644
--- a/content/common/quota_dispatcher.h
+++ b/content/common/quota_dispatcher.h
@@ -11,8 +11,7 @@
 #include "base/basictypes.h"
 #include "base/id_map.h"
 #include "ipc/ipc_channel.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaError.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaType.h"
+#include "webkit/quota/quota_types.h"
 
 class GURL;
 
@@ -29,6 +28,14 @@ class WebStorageQuotaCallbacks;
 // per child process.  Messages are dispatched on the main child thread.
 class QuotaDispatcher : public IPC::Channel::Listener {
  public:
+  class Callback {
+   public:
+    virtual ~Callback() {}
+    virtual void DidQueryStorageUsageAndQuota(int64 usage, int64 quota) = 0;
+    virtual void DidGrantStorageQuota(int64 granted_quota) = 0;
+    virtual void DidFail(quota::QuotaStatusCode status) = 0;
+  };
+
   QuotaDispatcher();
   virtual ~QuotaDispatcher();
 
@@ -36,13 +43,17 @@ class QuotaDispatcher : public IPC::Channel::Listener {
   virtual bool OnMessageReceived(const IPC::Message& msg);
 
   void QueryStorageUsageAndQuota(const GURL& gurl,
-                                 WebKit::WebStorageQuotaType type,
-                                 WebKit::WebStorageQuotaCallbacks* callbacks);
+                                 quota::StorageType type,
+                                 Callback* callback);
   void RequestStorageQuota(int render_view_id,
                            const GURL& gurl,
-                           WebKit::WebStorageQuotaType type,
-                           unsigned long long requested_size,
-                           WebKit::WebStorageQuotaCallbacks* callbacks);
+                           quota::StorageType type,
+                           int64 requested_size,
+                           Callback* callback);
+
+  // Creates a new Callback instance for WebStorageQuotaCallbacks.
+  static Callback* CreateWebStorageQuotaCallbacksWrapper(
+      WebKit::WebStorageQuotaCallbacks* callbacks);
 
  private:
   // Message handlers.
@@ -51,10 +62,9 @@ class QuotaDispatcher : public IPC::Channel::Listener {
                                     int64 current_quota);
   void DidGrantStorageQuota(int request_id,
                             int64 granted_quota);
-  void DidFail(int request_id,
-               WebKit::WebStorageQuotaError error);
+  void DidFail(int request_id, quota::QuotaStatusCode error);
 
-  IDMap<WebKit::WebStorageQuotaCallbacks> pending_quota_callbacks_;
+  IDMap<Callback, IDMapOwnPointer> pending_quota_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaDispatcher);
 };
diff --git a/content/common/quota_messages.h b/content/common/quota_messages.h
index 54a3648..d2965e2 100644
--- a/content/common/quota_messages.h
+++ b/content/common/quota_messages.h
@@ -6,13 +6,12 @@
 
 #include "base/basictypes.h"
 #include "ipc/ipc_message_macros.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaError.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageQuotaType.h"
+#include "webkit/quota/quota_types.h"
 
 #define IPC_MESSAGE_START QuotaMsgStart
 
-IPC_ENUM_TRAITS(WebKit::WebStorageQuotaType)
-IPC_ENUM_TRAITS(WebKit::WebStorageQuotaError)
+IPC_ENUM_TRAITS(quota::StorageType)
+IPC_ENUM_TRAITS(quota::QuotaStatusCode)
 
 // Quota messages sent from the browser to the child process.
 
@@ -27,18 +26,18 @@ IPC_MESSAGE_CONTROL3(QuotaMsg_DidQueryStorageUsageAndQuota,
 
 IPC_MESSAGE_CONTROL2(QuotaMsg_DidFail,
                      int /* request_id */,
-                     WebKit::WebStorageQuotaError /* error */)
+                     quota::QuotaStatusCode /* error */)
 
 // Quota messages sent from the child process to the browser.
 
 IPC_MESSAGE_CONTROL3(QuotaHostMsg_QueryStorageUsageAndQuota,
                      int /* request_id */,
                      GURL /* origin_url */,
-                     WebKit::WebStorageQuotaType /* type */)
+                     quota::StorageType /* type */)
 
 IPC_MESSAGE_CONTROL5(QuotaHostMsg_RequestStorageQuota,
                      int /* render_view_id */,
                      int /* request_id */,
                      GURL /* origin_url */,
-                     WebKit::WebStorageQuotaType /* type */,
+                     quota::StorageType /* type */,
                      int64 /* requested_size */)
diff --git a/content/renderer/render_view.cc b/content/renderer/render_view.cc
index 988328a..fedaf13 100644
--- a/content/renderer/render_view.cc
+++ b/content/renderer/render_view.cc
@@ -2896,7 +2896,9 @@ void RenderView::queryStorageUsageAndQuota(
     return;
   }
   ChildThread::current()->quota_dispatcher()->QueryStorageUsageAndQuota(
-      GURL(origin.toString()), type, callbacks);
+      GURL(origin.toString()),
+      static_cast<quota::StorageType>(type),
+      QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
 }
 
 void RenderView::requestStorageQuota(
@@ -2912,7 +2914,9 @@ void RenderView::requestStorageQuota(
     return;
   }
   ChildThread::current()->quota_dispatcher()->RequestStorageQuota(
-      routing_id(), GURL(origin.toString()), type, requested_size, callbacks);
+      routing_id(), GURL(origin.toString()),
+      static_cast<quota::StorageType>(type), requested_size,
+      QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
 }
 
 // WebKit::WebPageSerializerClient implementation ------------------------------