Revert of Rate limit programmatic update checks for extensions

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 <stdint.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 42 matching lines @@
 // 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;
 
 // For sanity checking on update frequency - enforced in release mode only.
 #if defined(NDEBUG)
 const int kMinUpdateFrequencySeconds = 30;
 #endif
 const int kMaxUpdateFrequencySeconds = 60 * 60 * 24 * 7;  // 7 days
 
+// Require at least 5 seconds between consecutive non-succesful extension update
+// checks.
+const int kMinUpdateThrottleTime = 5;
+
 // When we've computed a days value, we want to make sure we don't send a
 // negative value (due to the system clock being set backwards, etc.), since -1
 // is a special sentinel value that means "never pinged", and other negative
 // values don't make sense.
 int SanitizeDays(int days) {
   if (days < 0)
     return 0;
   return days;
 }
 
@@ skipping 45 matching lines @@
 ExtensionUpdater::FetchedCRXFile::~FetchedCRXFile() {}
 
 ExtensionUpdater::InProgressCheck::InProgressCheck()
     : install_immediately(false) {}
 
 ExtensionUpdater::InProgressCheck::InProgressCheck(
     const InProgressCheck& other) = default;
 
 ExtensionUpdater::InProgressCheck::~InProgressCheck() {}
 
+struct ExtensionUpdater::ThrottleInfo {
+  ThrottleInfo()
+      : in_progress(true),
+        throttle_delay(kMinUpdateThrottleTime),
+        check_start(Time::Now()) {}
+
+  bool in_progress;
+  int throttle_delay;
+  Time check_start;
+};
+
 ExtensionUpdater::ExtensionUpdater(
     ExtensionServiceInterface* service,
     ExtensionPrefs* extension_prefs,
     PrefService* prefs,
     Profile* profile,
     int frequency_seconds,
     ExtensionCache* cache,
     const ExtensionDownloader::Factory& downloader_factory)
     : alive_(false),
       service_(service),
       downloader_factory_(downloader_factory),
       frequency_seconds_(frequency_seconds),
       will_check_soon_(false),
       extension_prefs_(extension_prefs),
       prefs_(prefs),
       profile_(profile),
       next_request_id_(0),
+      extension_registry_observer_(this),
       crx_install_is_running_(false),
       extension_cache_(cache),
       weak_ptr_factory_(this) {
   DCHECK_GE(frequency_seconds_, 5);
   DCHECK_LE(frequency_seconds_, kMaxUpdateFrequencySeconds);
 #if defined(NDEBUG)
   // In Release mode we enforce that update checks don't happen too often.
   frequency_seconds_ = std::max(frequency_seconds_, kMinUpdateFrequencySeconds);
 #endif
   frequency_seconds_ = std::min(frequency_seconds_, kMaxUpdateFrequencySeconds);
+
+  extension_registry_observer_.Add(ExtensionRegistry::Get(profile));
 }
 
 ExtensionUpdater::~ExtensionUpdater() {
   Stop();
 }
 
 void ExtensionUpdater::EnsureDownloaderCreated() {
   if (!downloader_.get()) {
     downloader_ = downloader_factory_.Run(this);
   }
@@ skipping 232 matching lines @@
   bool noChecks = request.in_progress_ids_.empty();
 
   // StartAllPending() will call OnExtensionDownloadFailed or
   // OnExtensionDownloadFinished for each extension that was checked.
   downloader_->StartAllPending(extension_cache_);
 
   if (noChecks)
     NotifyIfFinished(request_id);
 }
 
-void ExtensionUpdater::CheckExtensionSoon(const std::string& extension_id,
+bool ExtensionUpdater::CheckExtensionSoon(const std::string& extension_id,
                                           const FinishedCallback& callback) {
+  bool have_throttle_info = ContainsKey(throttle_info_, extension_id);
+  ThrottleInfo& info = throttle_info_[extension_id];
+  if (have_throttle_info) {
+    // We already had a ThrottleInfo object for this extension, check if the
+    // update check request should be allowed.
+
+    // If another check is in progress, don't start a new check.
+    if (info.in_progress)
+      return false;
+
+    Time now = Time::Now();
+    Time last = info.check_start;
+    // If somehow time moved back, we don't want to infinitely keep throttling.
+    if (now < last) {
+      last = now;
+      info.check_start = now;
+    }
+    Time earliest = last + TimeDelta::FromSeconds(info.throttle_delay);
+    // If check is too soon, throttle.
+    if (now < earliest)
+      return false;
+
+    // TODO(mek): Somehow increase time between allowing checks when checks
+    // are repeatedly throttled and don't result in updates being installed.
+
+    // It's okay to start a check, update values.
+    info.check_start = now;
+    info.in_progress = true;
+  }
+
   CheckParams params;
   params.ids.push_back(extension_id);
-  params.callback = callback;
+  params.callback = base::Bind(&ExtensionUpdater::ExtensionCheckFinished,
+                               weak_ptr_factory_.GetWeakPtr(),
+                               extension_id, callback);
   CheckNow(params);
+  return true;
+}
+
+void ExtensionUpdater::ExtensionCheckFinished(
+    const std::string& extension_id,
+    const FinishedCallback& callback) {
+  std::map<std::string, ThrottleInfo>::iterator it =
+      throttle_info_.find(extension_id);
+  if (it != throttle_info_.end()) {
+    it->second.in_progress = false;
+  }
+  callback.Run();
 }
 
 void ExtensionUpdater::OnExtensionDownloadFailed(
     const std::string& id,
     Error error,
     const PingResult& ping,
     const std::set<int>& request_ids) {
   DCHECK(alive_);
   UpdatePingData(id, ping);
   bool install_immediately = false;
@@ skipping 167 matching lines @@
     }
     if (!crx_file.callback.is_null()) {
       crx_file.callback.Run(false);
     }
   }
 
   // If any files are available to update, start one.
   MaybeInstallCRXFile();
 }
 
+void ExtensionUpdater::OnExtensionWillBeInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update,
+    const std::string& old_name) {
+  throttle_info_.erase(extension->id());
+}
+
 void ExtensionUpdater::NotifyStarted() {
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_UPDATING_STARTED,
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
 }
 
 void ExtensionUpdater::NotifyIfFinished(int request_id) {
   DCHECK(ContainsKey(requests_in_progress_, request_id));
   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