Use base::Callback in Quota related code.

content/browser/in_process_webkit/indexed_db_context.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/in_process_webkit/indexed_db_context.h"
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/in_process_webkit/indexed_db_quota_client.h"
 #include "content/browser/in_process_webkit/webkit_context.h"
@@ skipping 63 matching lines @@
 }
 
 }  // namespace
 
 const FilePath::CharType IndexedDBContext::kIndexedDBDirectory[] =
     FILE_PATH_LITERAL("IndexedDB");
 
 const FilePath::CharType IndexedDBContext::kIndexedDBExtension[] =
     FILE_PATH_LITERAL(".leveldb");
 
-class IndexedDBContext::IndexedDBGetUsageAndQuotaCallback :
-    public quota::QuotaManager::GetUsageAndQuotaCallback {
- public:
-  IndexedDBGetUsageAndQuotaCallback(IndexedDBContext* context,
-                                    const GURL& origin_url)
-      : context_(context),
-        origin_url_(origin_url) {
-  }
-
-  void Run(quota::QuotaStatusCode status, int64 usage, int64 quota) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    DCHECK(status == quota::kQuotaStatusOk || status == quota::kQuotaErrorAbort)
-        << "status was " << status;
-    if (status == quota::kQuotaErrorAbort) {
-      // We seem to no longer care to wait around for the answer.
-      return;
-    }
-    BrowserThread::PostTask(BrowserThread::WEBKIT, FROM_HERE,
-        NewRunnableMethod(context_.get(),
-                          &IndexedDBContext::GotUpdatedQuota,
-                          origin_url_,
-                          usage,
-                          quota));
-  }
-
-  virtual void RunWithParams(
-        const Tuple3<quota::QuotaStatusCode, int64, int64>& params) {
-    Run(params.a, params.b, params.c);
-  }
-
- private:
-  scoped_refptr<IndexedDBContext> context_;
-  const GURL origin_url_;
-};
-
 IndexedDBContext::IndexedDBContext(
     WebKitContext* webkit_context,
     quota::SpecialStoragePolicy* special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::MessageLoopProxy* webkit_thread_loop)
     : clear_local_state_on_exit_(false),
       special_storage_policy_(special_storage_policy),
       quota_manager_proxy_(quota_manager_proxy) {
   if (!webkit_context->is_incognito())
     data_path_ = webkit_context->data_path().Append(kIndexedDBDirectory);
@@ skipping 174 matching lines @@
     // quota_manager_proxy() is NULL in unit tests.
     if (quota_manager_proxy())
       quota_manager_proxy()->NotifyStorageModified(
           quota::QuotaClient::kIndexedDatabase,
           origin_url,
           quota::kStorageTypeTemporary,
           difference);
   }
 }
 
+void IndexedDBContext::GotUsageAndQuota(const GURL& origin_url,
+                                        quota::QuotaStatusCode status,
+                                        int64 usage, int64 quota) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(status == quota::kQuotaStatusOk || status == quota::kQuotaErrorAbort)
+      << "status was " << status;
+  if (status == quota::kQuotaErrorAbort) {
+    // We seem to no longer care to wait around for the answer.
+    return;
+  }
+  BrowserThread::PostTask(
+      BrowserThread::WEBKIT, FROM_HERE,
+      NewRunnableMethod(this,
+                        &IndexedDBContext::GotUpdatedQuota,
+                        origin_url,
+                        usage,
+                        quota));
+}
+
 void IndexedDBContext::GotUpdatedQuota(const GURL& origin_url, int64 usage,
                                        int64 quota) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   space_available_map_[origin_url] = quota - usage;
 }
 
 void IndexedDBContext::QueryAvailableQuota(const GURL& origin_url) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
     if (quota_manager_proxy())
       BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
           NewRunnableMethod(this, &IndexedDBContext::QueryAvailableQuota,
                             origin_url));
     return;
   }
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!quota_manager_proxy()->quota_manager())
     return;
-  IndexedDBGetUsageAndQuotaCallback* callback =
-      new IndexedDBGetUsageAndQuotaCallback(this, origin_url);
   quota_manager_proxy()->quota_manager()->GetUsageAndQuota(
       origin_url,
       quota::kStorageTypeTemporary,
-      callback);
+      base::Bind(&IndexedDBContext::GotUsageAndQuota,
+                 this, origin_url));
 }
 
 std::set<GURL>* IndexedDBContext::GetOriginSet() {
   if (!origin_set_.get()) {
     origin_set_.reset(new std::set<GURL>);
     std::vector<GURL> origins;
     GetAllOriginsAndPaths(data_path_, &origins, NULL);
     for (std::vector<GURL>::const_iterator iter = origins.begin();
          iter != origins.end(); ++iter) {
       origin_set_->insert(*iter);
     }
   }
   return origin_set_.get();
 }
 
 void IndexedDBContext::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }