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

[Devlin, 2016/04/15 17:57:38]

heh... 5 seconds should be enough, right? ;)

[asargent_no_longer_on_chrome, 2016/04/19 17:56:53]

Well, it did get us this far. =)

-// 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);
 }
 
-bool ExtensionUpdater::CheckExtensionSoon(const std::string& extension_id,
+void 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 = base::Bind(&ExtensionUpdater::ExtensionCheckFinished,
-                               weak_ptr_factory_.GetWeakPtr(),
-                               extension_id, callback);
+  params.callback = 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