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

storage/browser/quota/quota_temporary_storage_evictor.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_temporary_storage_evictor.h"
+#include "storage/browser/quota/quota_temporary_storage_evictor.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "url/gurl.h"
-#include "webkit/browser/quota/quota_manager.h"
+#include "storage/browser/quota/quota_manager.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)
 
-#define UMA_HISTOGRAM_MINUTES(name, sample) \
-  UMA_HISTOGRAM_CUSTOM_TIMES(             \
-      (name), (sample),                   \
-      base::TimeDelta::FromMinutes(1),    \
-      base::TimeDelta::FromDays(1), 50)
+#define UMA_HISTOGRAM_MINUTES(name, sample)                   \
+  UMA_HISTOGRAM_CUSTOM_TIMES((name),                          \
+                             (sample),                        \
+                             base::TimeDelta::FromMinutes(1), \
+                             base::TimeDelta::FromDays(1),    \
+                             50)
 
 namespace {
 const int64 kMBytes = 1024 * 1024;
 const double kUsageRatioToStartEviction = 0.7;
 const int kThresholdOfErrorsToStopEviction = 5;
 const int kHistogramReportIntervalMinutes = 60;
 }
 
 namespace quota {
 
@@ skipping 26 matching lines @@
 }
 
 void QuotaTemporaryStorageEvictor::GetStatistics(
     std::map<std::string, int64>* statistics) {
   DCHECK(statistics);
 
   (*statistics)["errors-on-evicting-origin"] =
       statistics_.num_errors_on_evicting_origin;
   (*statistics)["errors-on-getting-usage-and-quota"] =
       statistics_.num_errors_on_getting_usage_and_quota;
-  (*statistics)["evicted-origins"] =
-      statistics_.num_evicted_origins;
-  (*statistics)["eviction-rounds"] =
-      statistics_.num_eviction_rounds;
+  (*statistics)["evicted-origins"] = statistics_.num_evicted_origins;
+  (*statistics)["eviction-rounds"] = statistics_.num_eviction_rounds;
   (*statistics)["skipped-eviction-rounds"] =
       statistics_.num_skipped_eviction_rounds;
 }
 
 void QuotaTemporaryStorageEvictor::ReportPerRoundHistogram() {
   DCHECK(round_statistics_.in_round);
   DCHECK(round_statistics_.is_initialized);
 
   base::Time now = base::Time::Now();
   UMA_HISTOGRAM_TIMES("Quota.TimeSpentToAEvictionRound",
                       now - round_statistics_.start_time);
   if (!time_of_end_of_last_round_.is_null())
     UMA_HISTOGRAM_MINUTES("Quota.TimeDeltaOfEvictionRounds",
                           now - time_of_end_of_last_round_);
   UMA_HISTOGRAM_MBYTES("Quota.UsageOverageOfTemporaryGlobalStorage",
                        round_statistics_.usage_overage_at_round);
   UMA_HISTOGRAM_MBYTES("Quota.DiskspaceShortage",
                        round_statistics_.diskspace_shortage_at_round);
   UMA_HISTOGRAM_MBYTES("Quota.EvictedBytesPerRound",
                        round_statistics_.usage_on_beginning_of_round -
-                       round_statistics_.usage_on_end_of_round);
+                           round_statistics_.usage_on_end_of_round);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfEvictedOriginsPerRound",
                        round_statistics_.num_evicted_origins_in_round);
 }
 
 void QuotaTemporaryStorageEvictor::ReportPerHourHistogram() {
   Statistics stats_in_hour(statistics_);
   stats_in_hour.subtract_assign(previous_statistics_);
   previous_statistics_ = statistics_;
 
   UMA_HISTOGRAM_COUNTS("Quota.ErrorsOnEvictingOriginPerHour",
@@ skipping 29 matching lines @@
 }
 
 void QuotaTemporaryStorageEvictor::Start() {
   DCHECK(CalledOnValidThread());
   StartEvictionTimerWithDelay(0);
 
   if (histogram_timer_.IsRunning())
     return;
 
   histogram_timer_.Start(
-      FROM_HERE, base::TimeDelta::FromMinutes(kHistogramReportIntervalMinutes),
-      this, &QuotaTemporaryStorageEvictor::ReportPerHourHistogram);
+      FROM_HERE,
+      base::TimeDelta::FromMinutes(kHistogramReportIntervalMinutes),
+      this,
+      &QuotaTemporaryStorageEvictor::ReportPerHourHistogram);
 }
 
 void QuotaTemporaryStorageEvictor::StartEvictionTimerWithDelay(int delay_ms) {
   if (eviction_timer_.IsRunning())
     return;
-  eviction_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(delay_ms),
-                        this, &QuotaTemporaryStorageEvictor::ConsiderEviction);
+  eviction_timer_.Start(FROM_HERE,
+                        base::TimeDelta::FromMilliseconds(delay_ms),
+                        this,
+                        &QuotaTemporaryStorageEvictor::ConsiderEviction);
 }
 
 void QuotaTemporaryStorageEvictor::ConsiderEviction() {
   OnEvictionRoundStarted();
 
   // Get usage and disk space, then continue.
   quota_eviction_handler_->GetUsageAndQuotaForEviction(
       base::Bind(&QuotaTemporaryStorageEvictor::OnGotUsageAndQuotaForEviction,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 57 matching lines @@
 void QuotaTemporaryStorageEvictor::OnGotLRUOrigin(const GURL& origin) {
   DCHECK(CalledOnValidThread());
 
   if (origin.is_empty()) {
     if (repeated_eviction_)
       StartEvictionTimerWithDelay(interval_ms_);
     OnEvictionRoundFinished();
     return;
   }
 
-  quota_eviction_handler_->EvictOriginData(origin, kStorageTypeTemporary,
-      base::Bind(
-          &QuotaTemporaryStorageEvictor::OnEvictionComplete,
-          weak_factory_.GetWeakPtr()));
+  quota_eviction_handler_->EvictOriginData(
+      origin,
+      kStorageTypeTemporary,
+      base::Bind(&QuotaTemporaryStorageEvictor::OnEvictionComplete,
+                 weak_factory_.GetWeakPtr()));
 }
 
-void QuotaTemporaryStorageEvictor::OnEvictionComplete(
-    QuotaStatusCode status) {
+void QuotaTemporaryStorageEvictor::OnEvictionComplete(QuotaStatusCode status) {
   DCHECK(CalledOnValidThread());
 
   // Just calling ConsiderEviction() or StartEvictionTimerWithDelay() here is
   // ok.  No need to deal with the case that all of the Delete operations fail
   // for a certain origin.  It doesn't result in trying to evict the same
   // origin permanently.  The evictor skips origins which had deletion errors
   // a few times.
 
   if (status == kQuotaStatusOk) {
     ++statistics_.num_evicted_origins;
     ++round_statistics_.num_evicted_origins_in_round;
     // We many need to get rid of more space so reconsider immediately.
     ConsiderEviction();
   } else {
     ++statistics_.num_errors_on_evicting_origin;
     if (repeated_eviction_) {
       // Sleep for a while and retry again until we see too many errors.
       StartEvictionTimerWithDelay(interval_ms_);
     }
     OnEvictionRoundFinished();
   }
 }
 
 }  // namespace quota