Move storage-related files from webkit/ to new top-level directory storage/

storage/browser/quota/quota_manager.cc

 // Copyright 2013 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/browser/quota/quota_manager.h"
+#include "storage/browser/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <functional>
 #include <set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "net/base/net_util.h"
-#include "webkit/browser/quota/quota_database.h"
-#include "webkit/browser/quota/quota_manager_proxy.h"
-#include "webkit/browser/quota/quota_temporary_storage_evictor.h"
-#include "webkit/browser/quota/storage_monitor.h"
-#include "webkit/browser/quota/usage_tracker.h"
-#include "webkit/common/quota/quota_types.h"
+#include "storage/browser/quota/quota_database.h"
+#include "storage/browser/quota/quota_manager_proxy.h"
+#include "storage/browser/quota/quota_temporary_storage_evictor.h"
+#include "storage/browser/quota/storage_monitor.h"
+#include "storage/browser/quota/usage_tracker.h"
+#include "storage/common/quota/quota_types.h"
 
-#define UMA_HISTOGRAM_MBYTES(name, sample)          \
-  UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
-      (name), static_cast<int>((sample) / kMBytes), \
-      1, 10 * 1024 * 1024 /* 10TB */, 100)
+#define UMA_HISTOGRAM_MBYTES(name, sample)                          \
+  UMA_HISTOGRAM_CUSTOM_COUNTS((name),                               \
+                              static_cast<int>((sample) / kMBytes), \
+                              1,                                    \
+                              10 * 1024 * 1024 /* 10TB */,          \
+                              100)
 
 namespace quota {
 
 namespace {
 
 const int64 kMBytes = 1024 * 1024;
 const int kMinutesInMilliSeconds = 60 * 1000;
 
 const int64 kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
-const double kTemporaryQuotaRatioToAvail = 1.0 / 3.0;  // 33%
+const double kTemporaryQuotaRatioToAvail = 1.0 / 3.0;   // 33%
 
 }  // namespace
 
 // Arbitrary for now, but must be reasonably small so that
 // in-memory databases can fit.
 // TODO(kinuko): Refer SysInfo::AmountOfPhysicalMemory() to determine this.
 const int64 QuotaManager::kIncognitoDefaultQuotaLimit = 100 * kMBytes;
 
 const int64 QuotaManager::kNoLimit = kint64max;
 
@@ skipping 42 matching lines @@
     if (policy->IsStorageProtected(*itr))
       ++*protected_origins;
     if (policy->IsStorageUnlimited(*itr))
       ++*unlimited_origins;
   }
 }
 
 bool SetTemporaryGlobalOverrideQuotaOnDBThread(int64* new_quota,
                                                QuotaDatabase* database) {
   DCHECK(database);
-  if (!database->SetQuotaConfigValue(
-          QuotaDatabase::kTemporaryQuotaOverrideKey, *new_quota)) {
+  if (!database->SetQuotaConfigValue(QuotaDatabase::kTemporaryQuotaOverrideKey,
+                                     *new_quota)) {
     *new_quota = -1;
     return false;
   }
   return true;
 }
 
 bool GetPersistentHostQuotaOnDBThread(const std::string& host,
                                       int64* quota,
                                       QuotaDatabase* database) {
   DCHECK(database);
@@ skipping 93 matching lines @@
 
 void DispatchTemporaryGlobalQuotaCallback(
     const QuotaCallback& callback,
     QuotaStatusCode status,
     const UsageAndQuota& usage_and_quota) {
   if (status != kQuotaStatusOk) {
     callback.Run(status, 0);
     return;
   }
 
-  callback.Run(status, CalculateTemporaryGlobalQuota(
-      usage_and_quota.global_limited_usage,
-      usage_and_quota.available_disk_space));
+  callback.Run(
+      status,
+      CalculateTemporaryGlobalQuota(usage_and_quota.global_limited_usage,
+                                    usage_and_quota.available_disk_space));
 }
 
-int64 CalculateQuotaWithDiskSpace(
-    int64 available_disk_space, int64 usage, int64 quota) {
+int64 CalculateQuotaWithDiskSpace(int64 available_disk_space,
+                                  int64 usage,
+                                  int64 quota) {
   if (available_disk_space < QuotaManager::kMinimumPreserveForSystem) {
     LOG(WARNING)
         << "Running out of disk space for profile."
         << " QuotaManager starts forbidding further quota consumption.";
     return usage;
   }
 
   if (quota < usage) {
     // No more space; cap the quota to the current usage.
     return usage;
@@ skipping 41 matching lines @@
     quota = std::min(quota, QuotaManager::kIncognitoDefaultQuotaLimit);
     callback.Run(status, usage, quota);
     return;
   }
 
   // For apps with unlimited permission or can_query_disk_size is true (and not
   // in incognito mode).
   // We assume we can expose the actual disk size for them and cap the quota by
   // the available disk space.
   if (is_unlimited || can_query_disk_size) {
-    callback.Run(
-        status, usage,
-        CalculateQuotaWithDiskSpace(
-            usage_and_quota.available_disk_space,
-            usage, quota));
+    callback.Run(status,
+                 usage,
+                 CalculateQuotaWithDiskSpace(
+                     usage_and_quota.available_disk_space, usage, quota));
     return;
   }
 
   callback.Run(status, usage, quota);
 }
 
 }  // namespace
 
 UsageAndQuota::UsageAndQuota()
-    : usage(0),
-      global_limited_usage(0),
-      quota(0),
-      available_disk_space(0) {
+    : usage(0), global_limited_usage(0), quota(0), available_disk_space(0) {
 }
 
-UsageAndQuota::UsageAndQuota(
-    int64 usage,
-    int64 global_limited_usage,
-    int64 quota,
-    int64 available_disk_space)
+UsageAndQuota::UsageAndQuota(int64 usage,
+                             int64 global_limited_usage,
+                             int64 quota,
+                             int64 available_disk_space)
     : usage(usage),
       global_limited_usage(global_limited_usage),
       quota(quota),
       available_disk_space(available_disk_space) {
 }
 
 class UsageAndQuotaCallbackDispatcher
     : public QuotaTask,
       public base::SupportsWeakPtr<UsageAndQuotaCallbackDispatcher> {
  public:
@@ skipping 131 matching lines @@
   QuotaStatusCode status_;
   UsageAndQuota usage_and_quota_;
   QuotaManager::UsageAndQuotaCallback callback_;
   int waiting_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaCallbackDispatcher);
 };
 
 class QuotaManager::GetUsageInfoTask : public QuotaTask {
  public:
-  GetUsageInfoTask(
-      QuotaManager* manager,
-      const GetUsageInfoCallback& callback)
-      : QuotaTask(manager),
-        callback_(callback),
-        weak_factory_(this) {
-  }
+  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(),
                    kStorageTypeTemporary));
     manager()->GetUsageTracker(kStorageTypePersistent)->GetGlobalUsage(
@@ skipping 61 matching lines @@
         remaining_clients_(-1),
         skipped_clients_(0),
         callback_(callback),
         weak_factory_(this) {}
 
  protected:
   virtual void Run() OVERRIDE {
     error_count_ = 0;
     remaining_clients_ = manager()->clients_.size();
     for (QuotaClientList::iterator iter = manager()->clients_.begin();
-         iter != manager()->clients_.end(); ++iter) {
+         iter != manager()->clients_.end();
+         ++iter) {
       if (quota_client_mask_ & (*iter)->id()) {
         (*iter)->DeleteOriginData(
-            origin_, type_,
+            origin_,
+            type_,
             base::Bind(&OriginDataDeleter::DidDeleteOriginData,
                        weak_factory_.GetWeakPtr()));
       } else {
         ++skipped_clients_;
         if (--remaining_clients_ == 0)
           CallCompleted();
       }
     }
   }
 
@@ skipping 56 matching lines @@
         remaining_clients_(-1),
         remaining_deleters_(-1),
         callback_(callback),
         weak_factory_(this) {}
 
  protected:
   virtual void Run() OVERRIDE {
     error_count_ = 0;
     remaining_clients_ = manager()->clients_.size();
     for (QuotaClientList::iterator iter = manager()->clients_.begin();
-         iter != manager()->clients_.end(); ++iter) {
-      (*iter)->GetOriginsForHost(
-          type_, host_,
-          base::Bind(&HostDataDeleter::DidGetOriginsForHost,
-                     weak_factory_.GetWeakPtr()));
+         iter != manager()->clients_.end();
+         ++iter) {
+      (*iter)
+          ->GetOriginsForHost(type_,
+                              host_,
+                              base::Bind(&HostDataDeleter::DidGetOriginsForHost,
+                                         weak_factory_.GetWeakPtr()));
     }
   }
 
   virtual void Completed() OVERRIDE {
     if (error_count_ == 0) {
       callback_.Run(kQuotaStatusOk);
     } else {
       callback_.Run(kQuotaErrorInvalidModification);
     }
     DeleteSoon();
@@ skipping 16 matching lines @@
       else
         CallCompleted();
     }
   }
 
   void ScheduleOriginsDeletion() {
     remaining_deleters_ = origins_.size();
     for (std::set<GURL>::const_iterator p = origins_.begin();
          p != origins_.end();
          ++p) {
-      OriginDataDeleter* deleter =
-          new OriginDataDeleter(
-              manager(), *p, type_, quota_client_mask_,
-              base::Bind(&HostDataDeleter::DidDeleteOriginData,
-                         weak_factory_.GetWeakPtr()));
+      OriginDataDeleter* deleter = new OriginDataDeleter(
+          manager(),
+          *p,
+          type_,
+          quota_client_mask_,
+          base::Bind(&HostDataDeleter::DidDeleteOriginData,
+                     weak_factory_.GetWeakPtr()));
       deleter->Start();
     }
   }
 
   void DidDeleteOriginData(QuotaStatusCode status) {
     DCHECK_GT(remaining_deleters_, 0);
 
     if (status != kQuotaStatusOk)
       ++error_count_;
 
@@ skipping 70 matching lines @@
     return true;
   }
 
   QuotaTableEntries entries_;
 };
 
 class QuotaManager::DumpOriginInfoTableHelper {
  public:
   bool DumpOriginInfoTableOnDBThread(QuotaDatabase* database) {
     DCHECK(database);
-    return database->DumpOriginInfoTable(
-        base::Bind(&DumpOriginInfoTableHelper::AppendEntry,
-                   base::Unretained(this)));
+    return database->DumpOriginInfoTable(base::Bind(
+        &DumpOriginInfoTableHelper::AppendEntry, base::Unretained(this)));
   }
 
   void DidDumpOriginInfoTable(const base::WeakPtr<QuotaManager>& manager,
                               const DumpOriginInfoTableCallback& callback,
                               bool success) {
     if (!manager) {
       // The operation was aborted.
       callback.Run(OriginInfoTableEntries());
       return;
     }
@@ skipping 10 matching lines @@
   OriginInfoTableEntries entries_;
 };
 
 // QuotaManager ---------------------------------------------------------------
 
 QuotaManager::QuotaManager(bool is_incognito,
                            const base::FilePath& profile_path,
                            base::SingleThreadTaskRunner* io_thread,
                            base::SequencedTaskRunner* db_thread,
                            SpecialStoragePolicy* special_storage_policy)
-  : is_incognito_(is_incognito),
-    profile_path_(profile_path),
-    proxy_(new QuotaManagerProxy(
-        this, io_thread)),
-    db_disabled_(false),
-    eviction_disabled_(false),
-    io_thread_(io_thread),
-    db_thread_(db_thread),
-    temporary_quota_initialized_(false),
-    temporary_quota_override_(-1),
-    desired_available_space_(-1),
-    special_storage_policy_(special_storage_policy),
-    get_disk_space_fn_(&CallSystemGetAmountOfFreeDiskSpace),
-    storage_monitor_(new StorageMonitor(this)),
-    weak_factory_(this) {
+    : is_incognito_(is_incognito),
+      profile_path_(profile_path),
+      proxy_(new QuotaManagerProxy(this, io_thread)),
+      db_disabled_(false),
+      eviction_disabled_(false),
+      io_thread_(io_thread),
+      db_thread_(db_thread),
+      temporary_quota_initialized_(false),
+      temporary_quota_override_(-1),
+      desired_available_space_(-1),
+      special_storage_policy_(special_storage_policy),
+      get_disk_space_fn_(&CallSystemGetAmountOfFreeDiskSpace),
+      storage_monitor_(new StorageMonitor(this)),
+      weak_factory_(this) {
 }
 
 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,
     const GetUsageAndQuotaCallback& callback) {
-  if (type != kStorageTypeTemporary &&
-      type != kStorageTypePersistent &&
+  if (type != kStorageTypeTemporary && type != kStorageTypePersistent &&
       type != kStorageTypeSyncable) {
     callback.Run(kQuotaErrorNotSupported, 0, 0);
     return;
   }
 
   DCHECK(origin == origin.GetOrigin());
   LazyInitialize();
 
   bool unlimited = IsStorageUnlimited(origin, type);
   bool can_query_disk_size = CanQueryDiskSize(origin);
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
 
   UsageAndQuota usage_and_quota;
   if (unlimited) {
     dispatcher->set_quota(kNoLimit);
   } else {
     if (type == kStorageTypeTemporary) {
-      GetUsageTracker(type)->GetGlobalLimitedUsage(
-          dispatcher->GetGlobalLimitedUsageCallback());
+      GetUsageTracker(type)
+          ->GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
       GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
     } else if (type == kStorageTypePersistent) {
       GetPersistentHostQuota(net::GetHostOrSpecFromURL(origin),
                              dispatcher->GetQuotaCallback());
     } else {
       dispatcher->set_quota(kSyncableStorageDefaultHostQuota);
     }
   }
 
   DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->GetHostUsage(net::GetHostOrSpecFromURL(origin),
                                       dispatcher->GetHostUsageCallback());
 
   if (!is_incognito_ && (unlimited || can_query_disk_size))
     GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
 
-  dispatcher->WaitForResults(base::Bind(
-      &DispatchUsageAndQuotaForWebApps,
-      type, is_incognito_, unlimited, can_query_disk_size,
-      callback));
+  dispatcher->WaitForResults(base::Bind(&DispatchUsageAndQuotaForWebApps,
+                                        type,
+                                        is_incognito_,
+                                        unlimited,
+                                        can_query_disk_size,
+                                        callback));
 }
 
-void QuotaManager::GetUsageAndQuota(
-    const GURL& origin, StorageType type,
-    const GetUsageAndQuotaCallback& callback) {
+void QuotaManager::GetUsageAndQuota(const GURL& origin,
+                                    StorageType type,
+                                    const GetUsageAndQuotaCallback& callback) {
   DCHECK(origin == origin.GetOrigin());
 
   if (IsStorageUnlimited(origin, type)) {
     callback.Run(kQuotaStatusOk, 0, kNoLimit);
     return;
   }
 
   GetUsageAndQuotaForWebApps(origin, type, callback);
 }
 
-void QuotaManager::NotifyStorageAccessed(
-    QuotaClient::ID client_id,
-    const GURL& origin, StorageType type) {
+void QuotaManager::NotifyStorageAccessed(QuotaClient::ID client_id,
+                                         const GURL& origin,
+                                         StorageType type) {
   DCHECK(origin == origin.GetOrigin());
   NotifyStorageAccessedInternal(client_id, origin, type, base::Time::Now());
 }
 
-void QuotaManager::NotifyStorageModified(
-    QuotaClient::ID client_id,
-    const GURL& origin, StorageType type, int64 delta) {
+void QuotaManager::NotifyStorageModified(QuotaClient::ID client_id,
+                                         const GURL& origin,
+                                         StorageType type,
+                                         int64 delta) {
   DCHECK(origin == origin.GetOrigin());
-  NotifyStorageModifiedInternal(client_id, origin, type, delta,
-                                base::Time::Now());
+  NotifyStorageModifiedInternal(
+      client_id, origin, type, delta, base::Time::Now());
 }
 
 void QuotaManager::NotifyOriginInUse(const GURL& origin) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   origins_in_use_[origin]++;
 }
 
 void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK(IsOriginInUse(origin));
   int& count = origins_in_use_[origin];
   if (--count == 0)
     origins_in_use_.erase(origin);
 }
 
 void QuotaManager::SetUsageCacheEnabled(QuotaClient::ID client_id,
                                         const GURL& origin,
                                         StorageType type,
                                         bool enabled) {
   LazyInitialize();
   DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->SetUsageCacheEnabled(client_id, origin, enabled);
 }
 
-void QuotaManager::DeleteOriginData(
-    const GURL& origin, StorageType type, int quota_client_mask,
-    const StatusCallback& callback) {
+void QuotaManager::DeleteOriginData(const GURL& origin,
+                                    StorageType type,
+                                    int quota_client_mask,
+                                    const StatusCallback& callback) {
   LazyInitialize();
 
   if (origin.is_empty() || clients_.empty()) {
     callback.Run(kQuotaStatusOk);
     return;
   }
 
   DCHECK(origin == origin.GetOrigin());
   OriginDataDeleter* deleter =
       new OriginDataDeleter(this, origin, type, quota_client_mask, callback);
@@ skipping 23 matching lines @@
   PostTaskAndReplyWithResult(db_thread_.get(),
                              FROM_HERE,
                              base::Bind(get_disk_space_fn_, profile_path_),
                              base::Bind(&QuotaManager::DidGetAvailableSpace,
                                         weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
   LazyInitialize();
   if (!temporary_quota_initialized_) {
-    db_initialization_callbacks_.Add(base::Bind(
-        &QuotaManager::GetTemporaryGlobalQuota,
-        weak_factory_.GetWeakPtr(), callback));
+    db_initialization_callbacks_.Add(
+        base::Bind(&QuotaManager::GetTemporaryGlobalQuota,
+                   weak_factory_.GetWeakPtr(),
+                   callback));
     return;
   }
 
   if (temporary_quota_override_ > 0) {
     callback.Run(kQuotaStatusOk, temporary_quota_override_);
     return;
   }
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
-  GetUsageTracker(kStorageTypeTemporary)->
-      GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
+  GetUsageTracker(kStorageTypeTemporary)
+      ->GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(
       base::Bind(&DispatchTemporaryGlobalQuotaCallback, callback));
 }
 
 void QuotaManager::SetTemporaryGlobalOverrideQuota(
-    int64 new_quota, const QuotaCallback& callback) {
+    int64 new_quota,
+    const QuotaCallback& callback) {
   LazyInitialize();
 
   if (new_quota < 0) {
     if (!callback.is_null())
       callback.Run(kQuotaErrorInvalidModification, -1);
     return;
   }
 
   if (db_disabled_) {
     if (!callback.is_null())
@@ skipping 22 matching lines @@
     callback.Run(kQuotaStatusOk, 0);
     return;
   }
 
   if (!persistent_host_quota_callbacks_.Add(host, callback))
     return;
 
   int64* quota_ptr = new int64(0);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
-      base::Bind(&GetPersistentHostQuotaOnDBThread,
-                 host,
-                 base::Unretained(quota_ptr)),
+      base::Bind(
+          &GetPersistentHostQuotaOnDBThread, host, base::Unretained(quota_ptr)),
       base::Bind(&QuotaManager::DidGetPersistentHostQuota,
                  weak_factory_.GetWeakPtr(),
                  host,
                  base::Owned(quota_ptr)));
 }
 
 void QuotaManager::SetPersistentHostQuota(const std::string& host,
                                           int64 new_quota,
                                           const QuotaCallback& callback) {
   LazyInitialize();
@@ skipping 109 matching lines @@
                  callback,
                  type));
 }
 
 bool QuotaManager::ResetUsageTracker(StorageType type) {
   DCHECK(GetUsageTracker(type));
   if (GetUsageTracker(type)->IsWorking())
     return false;
   switch (type) {
     case kStorageTypeTemporary:
-      temporary_usage_tracker_.reset(new UsageTracker(
-          clients_, kStorageTypeTemporary, special_storage_policy_.get(),
-          storage_monitor_.get()));
+      temporary_usage_tracker_.reset(
+          new UsageTracker(clients_,
+                           kStorageTypeTemporary,
+                           special_storage_policy_.get(),
+                           storage_monitor_.get()));
       return true;
     case kStorageTypePersistent:
-      persistent_usage_tracker_.reset(new UsageTracker(
-          clients_, kStorageTypePersistent, special_storage_policy_.get(),
-          storage_monitor_.get()));
+      persistent_usage_tracker_.reset(
+          new UsageTracker(clients_,
+                           kStorageTypePersistent,
+                           special_storage_policy_.get(),
+                           storage_monitor_.get()));
       return true;
     case kStorageTypeSyncable:
-      syncable_usage_tracker_.reset(new UsageTracker(
-          clients_, kStorageTypeSyncable, special_storage_policy_.get(),
-          storage_monitor_.get()));
+      syncable_usage_tracker_.reset(
+          new UsageTracker(clients_,
+                           kStorageTypeSyncable,
+                           special_storage_policy_.get(),
+                           storage_monitor_.get()));
       return true;
     default:
       NOTREACHED();
   }
   return true;
 }
 
 void QuotaManager::AddStorageObserver(
-    StorageObserver* observer, const StorageObserver::MonitorParams& params) {
+    StorageObserver* observer,
+    const StorageObserver::MonitorParams& params) {
   DCHECK(observer);
   storage_monitor_->AddObserver(observer, params);
 }
 
 void QuotaManager::RemoveStorageObserver(StorageObserver* observer) {
   DCHECK(observer);
   storage_monitor_->RemoveObserver(observer);
 }
 
 void QuotaManager::RemoveStorageObserverForFilter(
-    StorageObserver* observer, const StorageObserver::Filter& filter) {
+    StorageObserver* observer,
+    const StorageObserver::Filter& filter) {
   DCHECK(observer);
   storage_monitor_->RemoveObserverForFilter(observer, filter);
 }
 
 QuotaManager::~QuotaManager() {
   proxy_->manager_ = NULL;
-  std::for_each(clients_.begin(), clients_.end(),
+  std::for_each(clients_.begin(),
+                clients_.end(),
                 std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
   if (database_)
     db_thread_->DeleteSoon(FROM_HERE, database_.release());
 }
 
 QuotaManager::EvictionContext::EvictionContext()
     : evicted_type(kStorageTypeUnknown) {
 }
 
 QuotaManager::EvictionContext::~EvictionContext() {
 }
 
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_) {
     // Initialization seems to be done already.
     return;
   }
 
   // Use an empty path to open an in-memory only databse for incognito.
-  database_.reset(new QuotaDatabase(is_incognito_ ? base::FilePath() :
-      profile_path_.AppendASCII(kDatabaseName)));
+  database_.reset(new QuotaDatabase(
+      is_incognito_ ? base::FilePath()
+                    : profile_path_.AppendASCII(kDatabaseName)));
 
-  temporary_usage_tracker_.reset(new UsageTracker(
-      clients_, kStorageTypeTemporary, special_storage_policy_.get(),
-      storage_monitor_.get()));
-  persistent_usage_tracker_.reset(new UsageTracker(
-      clients_, kStorageTypePersistent, special_storage_policy_.get(),
-      storage_monitor_.get()));
-  syncable_usage_tracker_.reset(new UsageTracker(
-      clients_, kStorageTypeSyncable, special_storage_policy_.get(),
-      storage_monitor_.get()));
+  temporary_usage_tracker_.reset(new UsageTracker(clients_,
+                                                  kStorageTypeTemporary,
+                                                  special_storage_policy_.get(),
+                                                  storage_monitor_.get()));
+  persistent_usage_tracker_.reset(
+      new UsageTracker(clients_,
+                       kStorageTypePersistent,
+                       special_storage_policy_.get(),
+                       storage_monitor_.get()));
+  syncable_usage_tracker_.reset(new UsageTracker(clients_,
+                                                 kStorageTypeSyncable,
+                                                 special_storage_policy_.get(),
+                                                 storage_monitor_.get()));
 
   int64* temporary_quota_override = new int64(-1);
   int64* desired_available_space = new int64(-1);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&InitializeOnDBThread,
                  base::Unretained(temporary_quota_override),
                  base::Unretained(desired_available_space)),
       base::Bind(&QuotaManager::DidInitialize,
                  weak_factory_.GetWeakPtr(),
@@ skipping 15 matching lines @@
     case kStorageTypeSyncable:
       return syncable_usage_tracker_.get();
     case kStorageTypeQuotaNotManaged:
       return NULL;
     case kStorageTypeUnknown:
       NOTREACHED();
   }
   return NULL;
 }
 
-void QuotaManager::GetCachedOrigins(
-    StorageType type, std::set<GURL>* origins) {
+void QuotaManager::GetCachedOrigins(StorageType type, std::set<GURL>* origins) {
   DCHECK(origins);
   LazyInitialize();
   DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->GetCachedOrigins(origins);
 }
 
-void QuotaManager::NotifyStorageAccessedInternal(
-    QuotaClient::ID client_id,
-    const GURL& origin, StorageType type,
-    base::Time accessed_time) {
+void QuotaManager::NotifyStorageAccessedInternal(QuotaClient::ID client_id,
+                                                 const GURL& origin,
+                                                 StorageType type,
+                                                 base::Time accessed_time) {
   LazyInitialize();
   if (type == kStorageTypeTemporary && !lru_origin_callback_.is_null()) {
     // Record the accessed origins while GetLRUOrigin task is runing
     // to filter out them from eviction.
     access_notified_origins_.insert(origin);
   }
 
   if (db_disabled_)
     return;
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&UpdateAccessTimeOnDBThread, origin, type, accessed_time),
-      base::Bind(&QuotaManager::DidDatabaseWork,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&QuotaManager::DidDatabaseWork, weak_factory_.GetWeakPtr()));
 }
 
-void QuotaManager::NotifyStorageModifiedInternal(
-    QuotaClient::ID client_id,
-    const GURL& origin,
-    StorageType type,
-    int64 delta,
-    base::Time modified_time) {
+void QuotaManager::NotifyStorageModifiedInternal(QuotaClient::ID client_id,
+                                                 const GURL& origin,
+                                                 StorageType type,
+                                                 int64 delta,
+                                                 base::Time modified_time) {
   LazyInitialize();
   DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->UpdateUsageCache(client_id, origin, delta);
 
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&UpdateModifiedTimeOnDBThread, origin, type, modified_time),
-      base::Bind(&QuotaManager::DidDatabaseWork,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&QuotaManager::DidDatabaseWork, weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DumpQuotaTable(const DumpQuotaTableCallback& callback) {
   DumpQuotaTableHelper* helper = new DumpQuotaTableHelper;
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&DumpQuotaTableHelper::DumpQuotaTableOnDBThread,
                  base::Unretained(helper)),
       base::Bind(&DumpQuotaTableHelper::DidDumpQuotaTable,
                  base::Owned(helper),
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void QuotaManager::DumpOriginInfoTable(
     const DumpOriginInfoTableCallback& callback) {
   DumpOriginInfoTableHelper* helper = new DumpOriginInfoTableHelper;
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&DumpOriginInfoTableHelper::DumpOriginInfoTableOnDBThread,
                  base::Unretained(helper)),
       base::Bind(&DumpOriginInfoTableHelper::DidDumpOriginInfoTable,
                  base::Owned(helper),
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void QuotaManager::StartEviction() {
   DCHECK(!temporary_storage_evictor_.get());
-  temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
-      this, kEvictionIntervalInMilliSeconds));
+  temporary_storage_evictor_.reset(
+      new QuotaTemporaryStorageEvictor(this, kEvictionIntervalInMilliSeconds));
   if (desired_available_space_ >= 0)
     temporary_storage_evictor_->set_min_available_disk_space_to_start_eviction(
         desired_available_space_);
   temporary_storage_evictor_->Start();
 }
 
-void QuotaManager::DeleteOriginFromDatabase(
-    const GURL& origin, StorageType type) {
+void QuotaManager::DeleteOriginFromDatabase(const GURL& origin,
+                                            StorageType type) {
   LazyInitialize();
   if (db_disabled_)
     return;
 
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&DeleteOriginInfoOnDBThread, origin, type),
-      base::Bind(&QuotaManager::DidDatabaseWork,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&QuotaManager::DidDatabaseWork, weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidOriginDataEvicted(QuotaStatusCode status) {
   DCHECK(io_thread_->BelongsToCurrentThread());
 
   // We only try evict origins that are not in use, so basically
   // deletion attempt for eviction should not fail.  Let's record
   // the origin if we get error and exclude it from future eviction
   // if the error happens consistently (> kThresholdOfErrorsToBeBlacklisted).
   if (status != kQuotaStatusOk)
     origins_in_error_[eviction_context_.evicted_origin]++;
 
   eviction_context_.evict_origin_data_callback.Run(status);
   eviction_context_.evict_origin_data_callback.Reset();
 }
 
 void QuotaManager::ReportHistogram() {
-  GetGlobalUsage(kStorageTypeTemporary,
-                 base::Bind(
-                     &QuotaManager::DidGetTemporaryGlobalUsageForHistogram,
-                     weak_factory_.GetWeakPtr()));
-  GetGlobalUsage(kStorageTypePersistent,
-                 base::Bind(
-                     &QuotaManager::DidGetPersistentGlobalUsageForHistogram,
-                     weak_factory_.GetWeakPtr()));
+  GetGlobalUsage(
+      kStorageTypeTemporary,
+      base::Bind(&QuotaManager::DidGetTemporaryGlobalUsageForHistogram,
+                 weak_factory_.GetWeakPtr()));
+  GetGlobalUsage(
+      kStorageTypePersistent,
+      base::Bind(&QuotaManager::DidGetPersistentGlobalUsageForHistogram,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetTemporaryGlobalUsageForHistogram(
     int64 usage,
     int64 unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfTemporaryStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(kStorageTypeTemporary, &origins);
 
   size_t num_origins = origins.size();
   size_t protected_origins = 0;
   size_t unlimited_origins = 0;
   CountOriginType(origins,
                   special_storage_policy_.get(),
                   &protected_origins,
                   &unlimited_origins);
 
-  UMA_HISTOGRAM_COUNTS("Quota.NumberOfTemporaryStorageOrigins",
-                       num_origins);
+  UMA_HISTOGRAM_COUNTS("Quota.NumberOfTemporaryStorageOrigins", num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedTemporaryStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedTemporaryStorageOrigins",
                        unlimited_origins);
 }
 
 void QuotaManager::DidGetPersistentGlobalUsageForHistogram(
     int64 usage,
     int64 unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfPersistentStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(kStorageTypePersistent, &origins);
 
   size_t num_origins = origins.size();
   size_t protected_origins = 0;
   size_t unlimited_origins = 0;
   CountOriginType(origins,
                   special_storage_policy_.get(),
                   &protected_origins,
                   &unlimited_origins);
 
-  UMA_HISTOGRAM_COUNTS("Quota.NumberOfPersistentStorageOrigins",
-                       num_origins);
+  UMA_HISTOGRAM_COUNTS("Quota.NumberOfPersistentStorageOrigins", num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedPersistentStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedPersistentStorageOrigins",
                        unlimited_origins);
 }
 
-void QuotaManager::GetLRUOrigin(
-    StorageType type,
-    const GetLRUOriginCallback& callback) {
+void QuotaManager::GetLRUOrigin(StorageType type,
+                                const GetLRUOriginCallback& callback) {
   LazyInitialize();
   // This must not be called while there's an in-flight task.
   DCHECK(lru_origin_callback_.is_null());
   lru_origin_callback_ = callback;
   if (db_disabled_) {
     lru_origin_callback_.Run(GURL());
     lru_origin_callback_.Reset();
     return;
   }
 
@@ skipping 17 matching lines @@
       base::Bind(&GetLRUOriginOnDBThread,
                  type,
                  base::Owned(exceptions),
                  special_storage_policy_,
                  base::Unretained(url)),
       base::Bind(&QuotaManager::DidGetLRUOrigin,
                  weak_factory_.GetWeakPtr(),
                  base::Owned(url)));
 }
 
-void QuotaManager::EvictOriginData(
-    const GURL& origin,
-    StorageType type,
-    const EvictOriginDataCallback& callback) {
+void QuotaManager::EvictOriginData(const GURL& origin,
+                                   StorageType type,
+                                   const EvictOriginDataCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK_EQ(type, kStorageTypeTemporary);
 
   eviction_context_.evicted_origin = origin;
   eviction_context_.evicted_type = type;
   eviction_context_.evict_origin_data_callback = callback;
 
-  DeleteOriginData(origin, type, QuotaClient::kAllClientsMask,
-      base::Bind(&QuotaManager::DidOriginDataEvicted,
-                 weak_factory_.GetWeakPtr()));
+  DeleteOriginData(origin,
+                   type,
+                   QuotaClient::kAllClientsMask,
+                   base::Bind(&QuotaManager::DidOriginDataEvicted,
+                              weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::GetUsageAndQuotaForEviction(
     const UsageAndQuotaCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   LazyInitialize();
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
-  GetUsageTracker(kStorageTypeTemporary)->
-      GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
+  GetUsageTracker(kStorageTypeTemporary)
+      ->GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(callback);
 }
 
 void QuotaManager::DidSetTemporaryGlobalOverrideQuota(
     const QuotaCallback& callback,
     const int64* new_quota,
     bool success) {
   QuotaStatusCode status = kQuotaErrorInvalidAccess;
   DidDatabaseWork(success);
   if (success) {
     temporary_quota_override_ = *new_quota;
     status = kQuotaStatusOk;
   }
 
   if (callback.is_null())
     return;
 
   callback.Run(status, *new_quota);
 }
 
 void QuotaManager::DidGetPersistentHostQuota(const std::string& host,
                                              const int64* quota,
                                              bool success) {
   DidDatabaseWork(success);
-  persistent_host_quota_callbacks_.Run(
-      host, MakeTuple(kQuotaStatusOk, *quota));
+  persistent_host_quota_callbacks_.Run(host, MakeTuple(kQuotaStatusOk, *quota));
 }
 
 void QuotaManager::DidSetPersistentHostQuota(const std::string& host,
                                              const QuotaCallback& callback,
                                              const int64* new_quota,
                                              bool success) {
   DidDatabaseWork(success);
   callback.Run(success ? kQuotaStatusOk : kQuotaErrorInvalidAccess, *new_quota);
 }
 
 void QuotaManager::DidInitialize(int64* temporary_quota_override,
                                  int64* desired_available_space,
                                  bool success) {
   temporary_quota_override_ = *temporary_quota_override;
   desired_available_space_ = *desired_available_space;
   temporary_quota_initialized_ = true;
   DidDatabaseWork(success);
 
-  histogram_timer_.Start(FROM_HERE,
-                         base::TimeDelta::FromMilliseconds(
-                             kReportHistogramInterval),
-                         this, &QuotaManager::ReportHistogram);
+  histogram_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromMilliseconds(kReportHistogramInterval),
+      this,
+      &QuotaManager::ReportHistogram);
 
   db_initialization_callbacks_.Run(MakeTuple());
   GetTemporaryGlobalQuota(
       base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
                  weak_factory_.GetWeakPtr()));
 }
 
-void QuotaManager::DidGetLRUOrigin(const GURL* origin,
-                                   bool success) {
+void QuotaManager::DidGetLRUOrigin(const GURL* origin, bool success) {
   DidDatabaseWork(success);
   // Make sure the returned origin is (still) not in the origin_in_use_ set
   // and has not been accessed since we posted the task.
   if (origins_in_use_.find(*origin) != origins_in_use_.end() ||
       access_notified_origins_.find(*origin) != access_notified_origins_.end())
     lru_origin_callback_.Run(GURL());
   else
     lru_origin_callback_.Run(*origin);
   access_notified_origins_.clear();
   lru_origin_callback_.Reset();
 }
 
-void QuotaManager::DidGetInitialTemporaryGlobalQuota(
-    QuotaStatusCode status, int64 quota_unused) {
+void QuotaManager::DidGetInitialTemporaryGlobalQuota(QuotaStatusCode status,
+                                                     int64 quota_unused) {
   if (eviction_disabled_)
     return;
 
   std::set<GURL>* origins = new std::set<GURL>;
   temporary_usage_tracker_->GetCachedOrigins(origins);
   // This will call the StartEviction() when initial origin registration
   // is completed.
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&InitializeTemporaryOriginsInfoOnDBThread,
@@ skipping 32 matching lines @@
   // |database_|, therefore we can be sure that database_ is alive when this
   // task runs.
   base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       from_here,
       base::Bind(task, base::Unretained(database_.get())),
       reply);
 }
 
 }  // namespace quota