Revert 200817 "[Quota][Cleanup] Drop unused QuotaManager::UsageInfo"

> [Quota][Cleanup] Drop unused QuotaManager::UsageInfo
> 
> Review URL: https://chromiumcodereview.appspot.com/15257005

TBR=tzik@chromium.org

Review URL: https://codereview.chromium.org/15295012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@200827 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 143 insertions, 0 deletions

diff --git a/webkit/quota/quota_manager.cc b/webkit/quota/quota_manager.cc
index 9334ada..387b577 100644
--- a/webkit/quota/quota_manager.cc
+++ b/webkit/quota/quota_manager.cc
@@ -483,6 +483,73 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaDispatcherTask);
 };
 
+class QuotaManager::GetUsageInfoTask : public QuotaTask {
+ private:
+  typedef QuotaManager::GetUsageInfoTask self_type;
+
+ public:
+  GetUsageInfoTask(
+      QuotaManager* manager,
+      const GetUsageInfoCallback& callback)
+      : QuotaTask(manager),
+        callback_(callback),
+        weak_factory_(this) {
+  }
+
+ protected:
+  virtual void Run() OVERRIDE {
+    remaining_trackers_ = 3;
+    // This will populate cached hosts and usage info.
+    manager()->GetUsageTracker(kStorageTypeTemporary)->GetGlobalUsage(
+        base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
+                   weak_factory_.GetWeakPtr()));
+    manager()->GetUsageTracker(kStorageTypePersistent)->GetGlobalUsage(
+        base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
+                   weak_factory_.GetWeakPtr()));
+    manager()->GetUsageTracker(kStorageTypeSyncable)->GetGlobalUsage(
+        base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
+                   weak_factory_.GetWeakPtr()));
+  }
+
+  virtual void Completed() OVERRIDE {
+    callback_.Run(entries_);
+    DeleteSoon();
+  }
+
+  virtual void Aborted() OVERRIDE {
+    callback_.Run(UsageInfoEntries());
+    DeleteSoon();
+  }
+
+ private:
+  void AddEntries(StorageType type, UsageTracker* tracker) {
+    std::map<std::string, int64> host_usage;
+    tracker->GetCachedHostsUsage(&host_usage);
+    for (std::map<std::string, int64>::const_iterator iter = host_usage.begin();
+         iter != host_usage.end();
+         ++iter) {
+      entries_.push_back(UsageInfo(iter->first, type, iter->second));
+    }
+    if (--remaining_trackers_ == 0)
+      CallCompleted();
+  }
+
+  void DidGetGlobalUsage(StorageType type, int64, int64) {
+    AddEntries(type, manager()->GetUsageTracker(type));
+  }
+
+  QuotaManager* manager() const {
+    return static_cast<QuotaManager*>(observer());
+  }
+
+  GetUsageInfoCallback callback_;
+  UsageInfoEntries entries_;
+  base::WeakPtrFactory<GetUsageInfoTask> weak_factory_;
+  int remaining_trackers_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetUsageInfoTask);
+};
+
 class QuotaManager::UsageAndQuotaDispatcherTaskForTemporary
     : public QuotaManager::UsageAndQuotaDispatcherTask {
  public:
@@ -902,6 +969,12 @@ QuotaManager::QuotaManager(bool is_incognito,
     get_disk_space_fn_(&CallSystemGetAmountOfFreeDiskSpace) {
 }
 
+void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
+  LazyInitialize();
+  GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
+  get_usage_info->Start();
+}
+
 void QuotaManager::GetUsageAndQuotaForWebApps(
     const GURL& origin,
     StorageType type,
diff --git a/webkit/quota/quota_manager.h b/webkit/quota/quota_manager.h
index 31f64c6..af6f69d 100644
--- a/webkit/quota/quota_manager.h
+++ b/webkit/quota/quota_manager.h
@@ -87,6 +87,16 @@ class WEBKIT_STORAGE_EXPORT QuotaEvictionHandler {
   virtual ~QuotaEvictionHandler() {}
 };
 
+struct UsageInfo {
+  UsageInfo(const std::string& host, StorageType type, int64 usage)
+      : host(host),
+        type(type),
+        usage(usage) {}
+  std::string host;
+  StorageType type;
+  int64 usage;
+};
+
 // The quota manager class.  This class is instantiated per profile and
 // held by the profile.  With the exception of the constructor and the
 // proxy() method, all methods should only be called on the IO thread.
@@ -112,6 +122,9 @@ class WEBKIT_STORAGE_EXPORT QuotaManager
   // Returns a proxy object that can be used on any thread.
   QuotaManagerProxy* proxy() { return proxy_.get(); }
 
+  // Called by clients or webapps. Returns usage per host.
+  void GetUsageInfo(const GetUsageInfoCallback& callback);
+
   // Called by Web Apps.
   // This method is declared as virtual to allow test code to override it.
   virtual void GetUsageAndQuotaForWebApps(
@@ -238,6 +251,7 @@ class WEBKIT_STORAGE_EXPORT QuotaManager
   friend class QuotaTemporaryStorageEvictor;
   friend struct QuotaManagerDeleter;
 
+  class GetUsageInfoTask;
   class UsageAndQuotaDispatcherTask;
   class UsageAndQuotaDispatcherTaskForTemporary;
   class UsageAndQuotaDispatcherTaskForPersistent;
diff --git a/webkit/quota/quota_manager_unittest.cc b/webkit/quota/quota_manager_unittest.cc
index a8fb030..9848770 100644
--- a/webkit/quota/quota_manager_unittest.cc
+++ b/webkit/quota/quota_manager_unittest.cc
@@ -99,6 +99,13 @@ class QuotaManagerTest : public testing::Test {
     quota_manager_->proxy()->RegisterClient(client);
   }
 
+  void GetUsageInfo() {
+    usage_info_.clear();
+    quota_manager_->GetUsageInfo(
+        base::Bind(&QuotaManagerTest::DidGetUsageInfo,
+                   weak_factory_.GetWeakPtr()));
+  }
+
   void GetUsageAndQuotaForWebApps(const GURL& origin,
                                   StorageType type) {
     quota_status_ = kQuotaStatusUnknown;
@@ -301,6 +308,10 @@ class QuotaManagerTest : public testing::Test {
                    weak_factory_.GetWeakPtr()));
   }
 
+  void DidGetUsageInfo(const UsageInfoEntries& entries) {
+    usage_info_.insert(usage_info_.begin(), entries.begin(), entries.end());
+  }
+
   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
     quota_status_ = status;
     usage_ = usage;
@@ -391,6 +402,7 @@ class QuotaManagerTest : public testing::Test {
   }
 
   QuotaStatusCode status() const { return quota_status_; }
+  const UsageInfoEntries& usage_info() const { return usage_info_; }
   const std::string& host() const { return host_; }
   StorageType type() const { return type_; }
   int64 usage() const { return usage_; }
@@ -422,6 +434,7 @@ class QuotaManagerTest : public testing::Test {
   scoped_refptr<MockSpecialStoragePolicy> mock_special_storage_policy_;
 
   QuotaStatusCode quota_status_;
+  UsageInfoEntries usage_info_;
   std::string host_;
   StorageType type_;
   int64 usage_;
@@ -442,6 +455,45 @@ class QuotaManagerTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerTest);
 };
 
+TEST_F(QuotaManagerTest, GetUsageInfo) {
+  static const MockOriginData kData1[] = {
+    { "http://foo.com/",       kTemp,  10 },
+    { "http://foo.com:8080/",  kTemp,  15 },
+    { "http://bar.com/",       kTemp,  20 },
+    { "http://bar.com/",       kPerm,  50 },
+  };
+  static const MockOriginData kData2[] = {
+    { "https://foo.com/",      kTemp,  30 },
+    { "https://foo.com:8081/", kTemp,  35 },
+    { "http://bar.com/",       kPerm,  40 },
+    { "http://example.com/",   kPerm,  40 },
+  };
+  RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+      QuotaClient::kFileSystem));
+  RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+      QuotaClient::kDatabase));
+
+  GetUsageInfo();
+  base::MessageLoop::current()->RunUntilIdle();
+
+  EXPECT_EQ(4U, usage_info().size());
+  for (size_t i = 0; i < usage_info().size(); ++i) {
+    const UsageInfo& info = usage_info()[i];
+    if (info.host == "foo.com" && info.type == kTemp) {
+      EXPECT_EQ(10 + 15 + 30 + 35, info.usage);
+    } else if (info.host == "bar.com" && info.type == kTemp) {
+      EXPECT_EQ(20, info.usage);
+    } else if (info.host == "bar.com" && info.type == kPerm) {
+      EXPECT_EQ(50 + 40, info.usage);
+    } else if (info.host == "example.com" && info.type == kPerm) {
+      EXPECT_EQ(40, info.usage);
+    } else {
+      ADD_FAILURE()
+          << "Unexpected host, type: " << info.host << ", " << info.type;
+    }
+  }
+}
+
 TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/", kTemp, 10 },
diff --git a/webkit/quota/quota_types.h b/webkit/quota/quota_types.h
index ce6d05f..8ba3746 100644
--- a/webkit/quota/quota_types.h
+++ b/webkit/quota/quota_types.h
@@ -32,6 +32,9 @@ enum QuotaLimitType {
   kQuotaLimitTypeUnlimited,
 };
 
+struct UsageInfo;
+typedef std::vector<UsageInfo> UsageInfoEntries;
+
 // Common callback types that are used throughout in the quota module.
 typedef base::Callback<void(StorageType status,
                             int64 usage,
@@ -42,6 +45,7 @@ typedef base::Callback<void(QuotaStatusCode, int64)> AvailableSpaceCallback;
 typedef base::Callback<void(QuotaStatusCode)> StatusCallback;
 typedef base::Callback<void(const std::set<GURL>& origins,
                             StorageType type)> GetOriginsCallback;
+typedef base::Callback<void(const UsageInfoEntries&)> GetUsageInfoCallback;
 
 // Simple template wrapper for a callback queue.
 template <typename CallbackType>