extensions: Relocate pref name constants.

chrome/browser/extensions/updater/extension_updater.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/updater/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 11 matching lines @@
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "crypto/sha2.h"
 #include "extensions/browser/pending_extension_manager.h"
+#include "extensions/browser/pref_names.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest.h"
 
 using base::RandDouble;
 using base::RandInt;
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
-using prefs::kLastExtensionsUpdateCheck;
-using prefs::kNextExtensionsUpdateCheck;
 
 typedef extensions::ExtensionDownloaderDelegate::Error Error;
 typedef extensions::ExtensionDownloaderDelegate::PingResult PingResult;
 
 namespace {
 
 // Wait at least 5 minutes after browser startup before we do any checks. If you
 // change this value, make sure to update comments where it is used.
 const int kStartupWaitSeconds = 60 * 5;
 
@@ skipping 104 matching lines @@
 
 // The overall goal here is to balance keeping clients up to date while
 // avoiding a thundering herd against update servers.
 TimeDelta ExtensionUpdater::DetermineFirstCheckDelay() {
   DCHECK(alive_);
   // If someone's testing with a quick frequency, just allow it.
   if (frequency_seconds_ < kStartupWaitSeconds)
     return TimeDelta::FromSeconds(frequency_seconds_);
 
   // If we've never scheduled a check before, start at frequency_seconds_.
-  if (!prefs_->HasPrefPath(kNextExtensionsUpdateCheck))
+  if (!prefs_->HasPrefPath(pref_names::kNextUpdateCheck))
     return TimeDelta::FromSeconds(frequency_seconds_);
 
   // If it's been a long time since our last actual check, we want to do one
   // relatively soon.
   Time now = Time::Now();
   Time last = Time::FromInternalValue(prefs_->GetInt64(
-      kLastExtensionsUpdateCheck));
+      pref_names::kLastUpdateCheck));
   int days = (now - last).InDays();
   if (days >= 30) {
     // Wait 5-10 minutes.
     return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds,
                                           kStartupWaitSeconds * 2));
   } else if (days >= 14) {
     // Wait 10-20 minutes.
     return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds * 2,
                                           kStartupWaitSeconds * 4));
   } else if (days >= 3) {
     // Wait 20-40 minutes.
     return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds * 4,
                                           kStartupWaitSeconds * 8));
   }
 
   // Read the persisted next check time, and use that if it isn't too soon.
   // Otherwise pick something random.
   Time saved_next = Time::FromInternalValue(prefs_->GetInt64(
-      kNextExtensionsUpdateCheck));
+      pref_names::kNextUpdateCheck));
   Time earliest = now + TimeDelta::FromSeconds(kStartupWaitSeconds);
   if (saved_next >= earliest) {
     return saved_next - now;
   } else {
     return TimeDelta::FromSeconds(RandInt(kStartupWaitSeconds,
                                           frequency_seconds_));
   }
 }
 
 void ExtensionUpdater::Start() {
@@ skipping 29 matching lines @@
 
   // Add +/- 10% random jitter.
   double delay_ms = target_delay.InMillisecondsF();
   double jitter_factor = (RandDouble() * .2) - 0.1;
   delay_ms += delay_ms * jitter_factor;
   TimeDelta actual_delay = TimeDelta::FromMilliseconds(
       static_cast<int64>(delay_ms));
 
   // Save the time of next check.
   Time next = Time::Now() + actual_delay;
-  prefs_->SetInt64(kNextExtensionsUpdateCheck, next.ToInternalValue());
+  prefs_->SetInt64(pref_names::kNextUpdateCheck, next.ToInternalValue());
 
   timer_.Start(FROM_HERE, actual_delay, this, &ExtensionUpdater::TimerFired);
 }
 
 void ExtensionUpdater::TimerFired() {
   DCHECK(alive_);
   CheckNow(default_params_);
 
   // If the user has overridden the update frequency, don't bother reporting
   // this.
   if (frequency_seconds_ == extensions::kDefaultUpdateFrequencySeconds) {
     Time last = Time::FromInternalValue(prefs_->GetInt64(
-        kLastExtensionsUpdateCheck));
+        pref_names::kLastUpdateCheck));
     if (last.ToInternalValue() != 0) {
       // Use counts rather than time so we can use minutes rather than millis.
       UMA_HISTOGRAM_CUSTOM_COUNTS("Extensions.UpdateCheckGap",
           (Time::Now() - last).InMinutes(),
           TimeDelta::FromSeconds(kStartupWaitSeconds).InMinutes(),
           TimeDelta::FromDays(40).InMinutes(),
           50);  // 50 buckets seems to be the default.
     }
   }
 
   // Save the last check time, and schedule the next check.
   int64 now = Time::Now().ToInternalValue();
-  prefs_->SetInt64(kLastExtensionsUpdateCheck, now);
+  prefs_->SetInt64(pref_names::kLastUpdateCheck, now);
   ScheduleNextCheck(TimeDelta::FromSeconds(frequency_seconds_));
 }
 
 void ExtensionUpdater::CheckSoon() {
   DCHECK(alive_);
   if (will_check_soon_)
     return;
   if (BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&ExtensionUpdater::DoCheckSoon,
@@ skipping 354 matching lines @@
   const InProgressCheck& request = requests_in_progress_[request_id];
   if (request.in_progress_ids_.empty()) {
     VLOG(2) << "Finished update check " << request_id;
     if (!request.callback.is_null())
       request.callback.Run();
     requests_in_progress_.erase(request_id);
   }
 }
 
 }  // namespace extensions