Cleanup: Make quota dispatcher code independent from WebKit types

content/browser/renderer_host/quota_dispatcher_host.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/quota_dispatcher_host.h"
 
 #include "base/memory/scoped_callback_factory.h"
 #include "content/browser/quota_permission_context.h"
 #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
 // sends back the response to the renderer/worker.
 class QuotaDispatcherHost::RequestDispatcher {
  public:
   RequestDispatcher(QuotaDispatcherHost* dispatcher_host,
                     int request_id)
       : dispatcher_host_(dispatcher_host),
         request_id_(request_id) {
@@ skipping 36 matching lines @@
     quota_manager()->GetUsageAndQuota(origin, type,
         callback_factory_.NewCallback(
             &QueryUsageAndQuotaDispatcher::DidQueryStorageUsageAndQuota));
   }
 
  private:
   void DidQueryStorageUsageAndQuota(
       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));
     }
     Completed();
   }
 
   base::ScopedCallbackFactory<QueryUsageAndQuotaDispatcher> callback_factory_;
 };
 
@@ skipping 81 matching lines @@
                        StorageType type,
                        int64 new_quota) {
     DCHECK_EQ(host_, host);
     DCHECK_EQ(type_, type);
     DidFinish(status, new_quota);
   }
 
   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));
     }
     Completed();
   }
 
   const GURL origin_;
   const std::string host_;
   const StorageType type_;
@@ skipping 17 matching lines @@
 
 bool QuotaDispatcherHost::OnMessageReceived(
     const IPC::Message& message, bool* message_was_ok) {
   *message_was_ok = true;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(QuotaDispatcherHost, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(QuotaHostMsg_QueryStorageUsageAndQuota,
                         OnQueryStorageUsageAndQuota)
     IPC_MESSAGE_HANDLER(QuotaHostMsg_RequestStorageQuota,
                         OnRequestStorageQuota)
+    IPC_MESSAGE_HANDLER(QuotaHostMsg_NotifyStorageModified,
+                        OnNotifyStorageModified)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 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.
     Send(new QuotaMsg_DidGrantStorageQuota(request_id, requested_size));
     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);
+void QuotaDispatcherHost::OnNotifyStorageModified(
+    quota::QuotaClient::ID client_id,
+    const GURL& origin_url,
+    StorageType type,
+    int64 growth) {
+  quota_manager_->NotifyStorageModified(client_id, origin_url, type, growth);
+}