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

content/browser/in_process_webkit/indexed_db_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 "content/browser/in_process_webkit/indexed_db_quota_client.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
@@ skipping 66 matching lines @@
     }
   }
 
   std::set<GURL> origins_;
 };
 
 class IndexedDBQuotaClient::GetAllOriginsTask : public GetOriginsTaskBase {
  public:
   GetAllOriginsTask(
       IndexedDBQuotaClient* client,
-      base::MessageLoopProxy* webkit_thread_message_loop)
-      : GetOriginsTaskBase(client, webkit_thread_message_loop) {
+      base::MessageLoopProxy* webkit_thread_message_loop,
+      quota::StorageType type)
+      : GetOriginsTaskBase(client, webkit_thread_message_loop),
+        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 IndexedDBQuotaClient::GetOriginsForHostTask : public GetOriginsTaskBase {
  public:
   GetOriginsForHostTask(
       IndexedDBQuotaClient* client,
       base::MessageLoopProxy* webkit_thread_message_loop,
-      const std::string& host)
+      const std::string& host,
+      quota::StorageType type)
       : GetOriginsTaskBase(client, webkit_thread_message_loop),
-        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_;
 };
 
 // IndexedDBQuotaClient --------------------------------------------------------
 
 IndexedDBQuotaClient::IndexedDBQuotaClient(
     base::MessageLoopProxy* webkit_thread_message_loop,
     IndexedDBContext* indexed_db_context)
     : webkit_thread_message_loop_(webkit_thread_message_loop),
       indexed_db_context_(indexed_db_context) {
 }
@@ skipping 32 matching lines @@
 
 void IndexedDBQuotaClient::GetOriginsForType(
     quota::StorageType type,
     GetOriginsCallback* callback_ptr) {
   DCHECK(callback_ptr);
   DCHECK(indexed_db_context_.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, webkit_thread_message_loop_));
+        new GetAllOriginsTask(this, webkit_thread_message_loop_, type));
     task->Start();
   }
 }
 
 void IndexedDBQuotaClient::GetOriginsForHost(
     quota::StorageType type,
     const std::string& host,
     GetOriginsCallback* callback_ptr) {
   DCHECK(callback_ptr);
   DCHECK(indexed_db_context_.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, webkit_thread_message_loop_, host));
+        new GetOriginsForHostTask(
+            this, webkit_thread_message_loop_, host, type));
     task->Start();
   }
 }
 
 void IndexedDBQuotaClient::DeleteOriginData(const GURL& origin,
                                            quota::StorageType type,
                                            DeletionCallback* callback) {
   // TODO(tzik): implement me
   callback->Run(quota::kQuotaErrorNotSupported);
   delete callback;
 }
 
 void IndexedDBQuotaClient::DidGetOriginUsage(
     const GURL& origin_url, int64 usage) {
   DCHECK(usage_for_origin_callbacks_.HasCallbacks(origin_url));
   usage_for_origin_callbacks_.Run(origin_url, usage);
 }
 
-void IndexedDBQuotaClient::DidGetAllOrigins(const std::set<GURL>& origins) {
+void IndexedDBQuotaClient::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 IndexedDBQuotaClient::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);
 }