Quota: Add quota::StorageType to the GetOriginsCallback definition.

webkit/database/database_quota_client.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 "webkit/database/database_quota_client.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
@@ skipping 71 matching lines @@
     }
   }
 
   std::set<GURL> origins_;
 };
 
 class DatabaseQuotaClient::GetAllOriginsTask : public GetOriginsTaskBase {
  public:
   GetAllOriginsTask(
       DatabaseQuotaClient* client,
-      base::MessageLoopProxy* db_tracker_thread)
-      : GetOriginsTaskBase(client, db_tracker_thread) {
+      base::MessageLoopProxy* db_tracker_thread,
+      quota::StorageType type)
+      : GetOriginsTaskBase(client, db_tracker_thread),
+        type_(type) {
   }
 
  protected:
   virtual bool ShouldAddOrigin(const GURL& origin) OVERRIDE {
     return true;
   }
   virtual void Completed() OVERRIDE {
-    client_->DidGetAllOrigins(origins_);
+    client_->DidGetAllOrigins(origins_, type_);
   }
+
+ private:
+  quota::StorageType type_;
 };
 
 class DatabaseQuotaClient::GetOriginsForHostTask : public GetOriginsTaskBase {
  public:
   GetOriginsForHostTask(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread,
-      const std::string& host)
+      const std::string& host,
+      quota::StorageType type)
       : GetOriginsTaskBase(client, db_tracker_thread),
-        host_(host) {
+        host_(host),
+        type_(type) {
   }
 
  private:
   virtual bool ShouldAddOrigin(const GURL& origin) OVERRIDE {
     return host_ == net::GetHostOrSpecFromURL(origin);
   }
   virtual void Completed() OVERRIDE {
-    client_->DidGetOriginsForHost(host_, origins_);
+    client_->DidGetOriginsForHost(host_, origins_, type_);
   }
   std::string host_;
+  quota::StorageType type_;
 };
 
 class DatabaseQuotaClient::DeleteOriginTask : public HelperTask {
  public:
   DeleteOriginTask(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread,
       const GURL& origin_url,
       DeletionCallback* caller_callback)
       : HelperTask(client, db_tracker_thread),
@@ skipping 82 matching lines @@
 
 void DatabaseQuotaClient::GetOriginsForType(
     quota::StorageType type,
     GetOriginsCallback* callback_ptr) {
   DCHECK(callback_ptr);
   DCHECK(db_tracker_.get());
   scoped_ptr<GetOriginsCallback> callback(callback_ptr);
 
   // All databases are in the temp namespace for now.
   if (type != quota::kStorageTypeTemporary) {
-    callback->Run(std::set<GURL>());
+    callback->Run(std::set<GURL>(), type);
     return;
   }
 
   if (origins_for_type_callbacks_.Add(callback.release())) {
     scoped_refptr<GetAllOriginsTask> task(
-        new GetAllOriginsTask(this, db_tracker_thread_));
+        new GetAllOriginsTask(this, db_tracker_thread_, type));
     task->Start();
   }
 }
 
 void DatabaseQuotaClient::GetOriginsForHost(
     quota::StorageType type,
     const std::string& host,
     GetOriginsCallback* callback_ptr) {
   DCHECK(callback_ptr);
   DCHECK(db_tracker_.get());
   scoped_ptr<GetOriginsCallback> callback(callback_ptr);
 
   // All databases are in the temp namespace for now.
   if (type != quota::kStorageTypeTemporary) {
-    callback->Run(std::set<GURL>());
+    callback->Run(std::set<GURL>(), type);
     return;
   }
 
   if (origins_for_host_callbacks_.Add(host, callback.release())) {
     scoped_refptr<GetOriginsForHostTask> task(
-        new GetOriginsForHostTask(this, db_tracker_thread_, host));
+        new GetOriginsForHostTask(this, db_tracker_thread_, host, type));
     task->Start();
   }
 }
 
 void DatabaseQuotaClient::DeleteOriginData(const GURL& origin,
                                            quota::StorageType type,
                                            DeletionCallback* callback_ptr) {
   DCHECK(callback_ptr);
   DCHECK(db_tracker_.get());
   scoped_ptr<DeletionCallback> callback(callback_ptr);
 
   // All databases are in the temp namespace for now, so nothing to delete.
   if (type != quota::kStorageTypeTemporary) {
     callback->Run(quota::kQuotaStatusOk);
     return;
   }
 
   scoped_refptr<DeleteOriginTask> task(
       new DeleteOriginTask(this, db_tracker_thread_,
                            origin, callback.release()));
   task->Start();
 }
 
 void DatabaseQuotaClient::DidGetOriginUsage(
     const GURL& origin_url, int64 usage) {
   DCHECK(usage_for_origin_callbacks_.HasCallbacks(origin_url));
   usage_for_origin_callbacks_.Run(origin_url, usage);
 }
 
-void DatabaseQuotaClient::DidGetAllOrigins(const std::set<GURL>& origins) {
+void DatabaseQuotaClient::DidGetAllOrigins(const std::set<GURL>& origins,
+    quota::StorageType type) {
   DCHECK(origins_for_type_callbacks_.HasCallbacks());
-  origins_for_type_callbacks_.Run(origins);
+  origins_for_type_callbacks_.Run(origins, type);
 }
 
 void DatabaseQuotaClient::DidGetOriginsForHost(
-    const std::string& host, const std::set<GURL>& origins) {
+    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);
+  origins_for_host_callbacks_.Run(host, origins, type);
 }
 
 }  // namespace webkit_database