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

storage/browser/quota/quota_manager.cc

Index: storage/browser/quota/quota_manager.cc
diff --git a/webkit/browser/quota/quota_manager.cc b/storage/browser/quota/quota_manager.cc
similarity index 82%
rename from webkit/browser/quota/quota_manager.cc
rename to storage/browser/quota/quota_manager.cc
index e468822054847f50cc41385e7642f96062116b30..e4b962912ec210080719d25ab615e856e3dfbc03 100644
--- a/webkit/browser/quota/quota_manager.cc
+++ b/storage/browser/quota/quota_manager.cc
@@ -2,7 +2,7 @@
 // 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>
@@ -23,17 +23,19 @@
 #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"
-
-#define UMA_HISTOGRAM_MBYTES(name, sample)          \
-  UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
-      (name), static_cast<int>((sample) / kMBytes), \
-      1, 10 * 1024 * 1024 /* 10TB */, 100)
+#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)
 
 namespace quota {
 
@@ -43,7 +45,7 @@ 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
 
@@ -106,8 +108,8 @@ void CountOriginType(const std::set<GURL>& 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;
   }
@@ -221,13 +223,15 @@ void DispatchTemporaryGlobalQuotaCallback(
     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."
@@ -289,11 +293,10 @@ void DispatchUsageAndQuotaForWebApps(
   // 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;
   }
 
@@ -303,17 +306,13 @@ void DispatchUsageAndQuotaForWebApps(
 }  // 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),
@@ -465,13 +464,8 @@ class 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 {
@@ -553,10 +547,12 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
     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 {
@@ -633,11 +629,13 @@ class QuotaManager::HostDataDeleter : public QuotaTask {
     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()));
     }
   }
 
@@ -674,11 +672,13 @@ class QuotaManager::HostDataDeleter : public QuotaTask {
     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();
     }
   }
@@ -769,9 +769,8 @@ 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,
@@ -802,21 +801,20 @@ QuotaManager::QuotaManager(bool is_incognito,
                            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) {
@@ -829,8 +827,7 @@ 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;
@@ -850,8 +847,8 @@ void QuotaManager::GetUsageAndQuotaForWebApps(
     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),
@@ -868,15 +865,17 @@ void QuotaManager::GetUsageAndQuotaForWebApps(
   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)) {
@@ -887,19 +886,20 @@ void QuotaManager::GetUsageAndQuota(
   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) {
@@ -924,9 +924,10 @@ void QuotaManager::SetUsageCacheEnabled(QuotaClient::ID client_id,
   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()) {
@@ -970,9 +971,10 @@ void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
 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;
   }
 
@@ -983,15 +985,16 @@ void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
 
   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) {
@@ -1034,9 +1037,8 @@ void QuotaManager::GetPersistentHostQuota(const std::string& host,
   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,
@@ -1166,19 +1168,25 @@ bool QuotaManager::ResetUsageTracker(StorageType type) {
     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();
@@ -1187,7 +1195,8 @@ bool QuotaManager::ResetUsageTracker(StorageType type) {
 }
 
 void QuotaManager::AddStorageObserver(
-    StorageObserver* observer, const StorageObserver::MonitorParams& params) {
+    StorageObserver* observer,
+    const StorageObserver::MonitorParams& params) {
   DCHECK(observer);
   storage_monitor_->AddObserver(observer, params);
 }
@@ -1198,14 +1207,16 @@ void QuotaManager::RemoveStorageObserver(StorageObserver* 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());
@@ -1226,18 +1237,23 @@ void QuotaManager::LazyInitialize() {
   }
 
   // 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)));
-
-  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()));
+  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()));
 
   int64* temporary_quota_override = new int64(-1);
   int64* desired_available_space = new int64(-1);
@@ -1273,18 +1289,17 @@ UsageTracker* QuotaManager::GetUsageTracker(StorageType type) const {
   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
@@ -1297,16 +1312,14 @@ void QuotaManager::NotifyStorageAccessedInternal(
   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);
@@ -1314,8 +1327,7 @@ void QuotaManager::NotifyStorageModifiedInternal(
   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) {
@@ -1345,16 +1357,16 @@ void QuotaManager::DumpOriginInfoTable(
 
 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;
@@ -1362,8 +1374,7 @@ void QuotaManager::DeleteOriginFromDatabase(
   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) {
@@ -1381,14 +1392,14 @@ void QuotaManager::DidOriginDataEvicted(QuotaStatusCode status) {
 }
 
 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(
@@ -1407,8 +1418,7 @@ void QuotaManager::DidGetTemporaryGlobalUsageForHistogram(
                   &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",
@@ -1431,17 +1441,15 @@ void QuotaManager::DidGetPersistentGlobalUsageForHistogram(
                   &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());
@@ -1479,10 +1487,9 @@ void QuotaManager::GetLRUOrigin(
                  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);
 
@@ -1490,9 +1497,11 @@ void QuotaManager::EvictOriginData(
   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(
@@ -1502,8 +1511,8 @@ void QuotaManager::GetUsageAndQuotaForEviction(
 
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
-  GetUsageTracker(kStorageTypeTemporary)->
-      GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
+  GetUsageTracker(kStorageTypeTemporary)
+      ->GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(callback);
@@ -1530,8 +1539,7 @@ 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,
@@ -1550,10 +1558,11 @@ void QuotaManager::DidInitialize(int64* temporary_quota_override,
   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(
@@ -1561,8 +1570,7 @@ void QuotaManager::DidInitialize(int64* temporary_quota_override,
                  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.
@@ -1575,8 +1583,8 @@ void QuotaManager::DidGetLRUOrigin(const GURL* origin,
   lru_origin_callback_.Reset();
 }
 
-void QuotaManager::DidGetInitialTemporaryGlobalQuota(
-    QuotaStatusCode status, int64 quota_unused) {
+void QuotaManager::DidGetInitialTemporaryGlobalQuota(QuotaStatusCode status,
+                                                     int64 quota_unused) {
   if (eviction_disabled_)
     return;