Converted GetOriginsForHostTask to use base::PostTaskAndReply(). Deleted superclasses GetOriginsTas…

content/browser/in_process_webkit/indexed_db_quota_client.cc

 // Copyright (c) 2012 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_quota_client.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 24 matching lines @@
 }
 
 void GetAllOriginsOnWebKitThread(
     IndexedDBContextImpl* context,
     std::set<GURL>* origins_to_return) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   std::vector<GURL> all_origins = context->GetAllOrigins();
   origins_to_return->insert(all_origins.begin(), all_origins.end());
 }
 
-void DidGetAllOrigins(
+void DidGetOrigins(
     const IndexedDBQuotaClient::GetOriginsCallback& callback,
     const std::set<GURL>* origins,
     quota::StorageType storage_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   callback.Run(*origins, storage_type);
 }
 
+void GetOriginsForHostOnWebKitThread(
+    IndexedDBContextImpl* context,
+    const std::string& host,
+    std::set<GURL>* origins_to_return) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+  std::vector<GURL> all_origins = context->GetAllOrigins();
+  for (std::vector<GURL>::const_iterator iter = all_origins.begin();
+       iter != all_origins.end(); ++iter) {
+    if (host == net::GetHostOrSpecFromURL(*iter))
+      origins_to_return->insert(*iter);
+  }
+}
+
 }  // namespace
 
-// Helper tasks ---------------------------------------------------------------
-
-class IndexedDBQuotaClient::HelperTask : public quota::QuotaThreadTask {
- protected:
-  HelperTask(
-      IndexedDBQuotaClient* client,
-      base::MessageLoopProxy* webkit_thread_message_loop)
-      : QuotaThreadTask(client, webkit_thread_message_loop),
-        client_(client), indexed_db_context_(client->indexed_db_context_) {
-  }
-
-  IndexedDBQuotaClient* client_;
-  scoped_refptr<IndexedDBContextImpl> indexed_db_context_;
-
- protected:
-  virtual ~HelperTask() {}
-};
-
-class IndexedDBQuotaClient::GetOriginsTaskBase : public HelperTask {
- protected:
-  GetOriginsTaskBase(
-      IndexedDBQuotaClient* client,
-      base::MessageLoopProxy* webkit_thread_message_loop)
-      : HelperTask(client, webkit_thread_message_loop) {
-  }
-
-  virtual bool ShouldAddOrigin(const GURL& origin) = 0;
-
-  virtual void RunOnTargetThread() OVERRIDE {
-    std::vector<GURL> origins =  indexed_db_context_->GetAllOrigins();
-    for (std::vector<GURL>::const_iterator iter = origins.begin();
-         iter != origins.end(); ++iter) {
-      if (ShouldAddOrigin(*iter))
-        origins_.insert(*iter);
-    }
-  }
-
-  std::set<GURL> origins_;
-
- protected:
-  virtual ~GetOriginsTaskBase() {}
-};
-
-class IndexedDBQuotaClient::GetOriginsForHostTask : public GetOriginsTaskBase {
- public:
-  GetOriginsForHostTask(
-      IndexedDBQuotaClient* client,
-      base::MessageLoopProxy* webkit_thread_message_loop,
-      const std::string& host,
-      quota::StorageType type)
-      : GetOriginsTaskBase(client, webkit_thread_message_loop),
-        host_(host),
-        type_(type) {
-  }
-
- private:
-  virtual ~GetOriginsForHostTask() {}
-
-  virtual bool ShouldAddOrigin(const GURL& origin) OVERRIDE {
-    return host_ == net::GetHostOrSpecFromURL(origin);
-  }
-
-  virtual void Completed() OVERRIDE {
-    client_->DidGetOriginsForHost(host_, origins_, type_);
-  }
-
-  std::string host_;
-  quota::StorageType type_;
-};
-
 // IndexedDBQuotaClient --------------------------------------------------------
 
 IndexedDBQuotaClient::IndexedDBQuotaClient(
     base::MessageLoopProxy* webkit_thread_message_loop,
     IndexedDBContextImpl* indexed_db_context)
     : webkit_thread_message_loop_(webkit_thread_message_loop),
       indexed_db_context_(indexed_db_context) {
 }
 
 IndexedDBQuotaClient::~IndexedDBQuotaClient() {
@@ skipping 40 matching lines @@
     callback.Run(std::set<GURL>(), type);
     return;
   }
 
   std::set<GURL>* origins_to_return = new std::set<GURL>();
   webkit_thread_message_loop_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&GetAllOriginsOnWebKitThread,
                  indexed_db_context_,
                  base::Unretained(origins_to_return)),
-      base::Bind(&DidGetAllOrigins,
+      base::Bind(&DidGetOrigins,
                  callback,
                  base::Owned(origins_to_return),
                  type));
 }
 
 void IndexedDBQuotaClient::GetOriginsForHost(
     quota::StorageType type,
     const std::string& host,
     const GetOriginsCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(indexed_db_context_.get());
 
   // All databases are in the temp namespace for now.
   if (type != quota::kStorageTypeTemporary) {
     callback.Run(std::set<GURL>(), type);
     return;
   }
 
-  if (origins_for_host_callbacks_.Add(host, callback)) {
-    scoped_refptr<GetOriginsForHostTask> task(
-        new GetOriginsForHostTask(
-            this, webkit_thread_message_loop_, host, type));
-    task->Start();
-  }
+  std::set<GURL>* origins_to_return = new std::set<GURL>();
+  webkit_thread_message_loop_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&GetOriginsForHostOnWebKitThread,
+                 indexed_db_context_,
+                 host,
+                 base::Unretained(origins_to_return)),
+      base::Bind(&DidGetOrigins,
+                 callback,
+                 base::Owned(origins_to_return),
+                 type));
 }
 
 void IndexedDBQuotaClient::DeleteOriginData(
     const GURL& origin,
     quota::StorageType type,
     const DeletionCallback& callback) {
   if (type != quota::kStorageTypeTemporary) {
     callback.Run(quota::kQuotaErrorNotSupported);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       webkit_thread_message_loop_,
       FROM_HERE,
       base::Bind(&DeleteOriginDataOnWebKitThread,
                  indexed_db_context_,
                  origin),
       callback);
 }
-
-void IndexedDBQuotaClient::DidGetOriginsForHost(
-    const std::string& host, const std::set<GURL>& origins,
-    quota::StorageType type) {
-  DCHECK(origins_for_host_callbacks_.HasCallbacks(host));
-  origins_for_host_callbacks_.Run(host, origins, type);
-}