Rate limit programmatic update checks for extensions (reland)

chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc

 // Copyright 2014 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/api/runtime/chrome_runtime_api_delegate.h"
 
+#include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
+#include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "components/update_client/update_query_params.h"
 #include "content/public/browser/notification_service.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/warning_service.h"
 #include "extensions/browser/warning_set.h"
 #include "extensions/common/api/runtime.h"
+#include "extensions/common/constants.h"
+#include "net/base/backoff_entry.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "components/user_manager/user_manager.h"
 #endif
 
 using extensions::Extension;
 using extensions::ExtensionSystem;
 using extensions::ExtensionUpdater;
 
 using extensions::api::runtime::PlatformInfo;
 
 namespace {
 
 const char kUpdateThrottled[] = "throttled";
 const char kUpdateNotFound[] = "no_update";
 const char kUpdateFound[] = "update_available";
 
 // If an extension reloads itself within this many miliseconds of reloading
 // itself, the reload is considered suspiciously fast.
 const int kFastReloadTime = 10000;
 
 // After this many suspiciously fast consecutive reloads, an extension will get
 // disabled.
 const int kFastReloadCount = 5;
 
+// A holder class for the policy we use for exponential backoff of update check
+// requests.
+class BackoffPolicy {
+ public:
+  BackoffPolicy();
+  ~BackoffPolicy();
+
+  // Gets the single lazy instance.
+  static BackoffPolicy* Get();
+
+  // Returns the actual policy to use.
+  const net::BackoffEntry::Policy* policy() { return &policy_; }

[Devlin, 2016/04/20 22:09:31]

nit: maybe just have Get() return this?

static net::BackoffEntry::Policy* Get() {
  return &g_backoff_policy.Pointer()->policy_;
}

[asargent_no_longer_on_chrome, 2016/04/20 22:44:59]

Good idea, done. 

+
+ private:
+  net::BackoffEntry::Policy policy_;
+};
+
+// We use a LazyInstance since one of the the policy values references an
+// extern symbol, which would cause a static initializer to be generated if we
+// just declared the policy struct as a static variable.
+base::LazyInstance<BackoffPolicy> g_backoff_policy = LAZY_INSTANCE_INITIALIZER;
+
+BackoffPolicy::BackoffPolicy() {
+  policy_ = {
+      // num_errors_to_ignore
+      0,
+
+      // initial_delay_ms (note that we set 'always_use_initial_delay' to false
+      // below)
+      1000 * extensions::kDefaultUpdateFrequencySeconds,
+
+      // multiply_factor
+      1,
+
+      // jitter_factor
+      0.1,
+
+      // maximum_backoff_ms (-1 means no maximum)
+      -1,
+
+      // entry_lifetime_ms (-1 means never discard)
+      -1,
+
+      // always_use_initial_delay
+      false,
+  };
+}
+
+BackoffPolicy::~BackoffPolicy() {}
+
+BackoffPolicy* BackoffPolicy::Get() {
+  return g_backoff_policy.Pointer();
+}
+
+base::TickClock* g_test_clock = nullptr;
+
 }  // namespace
 
+struct ChromeRuntimeAPIDelegate::UpdateCheckInfo {
+ public:
+  UpdateCheckInfo() {
+    if (g_test_clock)
+      backoff.reset(
+          new net::BackoffEntry(BackoffPolicy::Get()->policy(), g_test_clock));
+    else
+      backoff.reset(new net::BackoffEntry(BackoffPolicy::Get()->policy()));
+  }
+
+  std::unique_ptr<net::BackoffEntry> backoff;
+  std::vector<UpdateCheckCallback> callbacks;
+};
+
 ChromeRuntimeAPIDelegate::ChromeRuntimeAPIDelegate(
     content::BrowserContext* context)
-    : browser_context_(context), registered_for_updates_(false) {
+    : browser_context_(context),
+      registered_for_updates_(false),
+      extension_registry_observer_(this) {
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_UPDATE_FOUND,
                  content::NotificationService::AllSources());
+  extension_registry_observer_.Add(
+      extensions::ExtensionRegistry::Get(browser_context_));
 }
 
 ChromeRuntimeAPIDelegate::~ChromeRuntimeAPIDelegate() {
 }
 
+// static
+void ChromeRuntimeAPIDelegate::set_tick_clock_for_tests(
+    base::TickClock* clock) {
+  g_test_clock = clock;
+}
+
 void ChromeRuntimeAPIDelegate::AddUpdateObserver(
     extensions::UpdateObserver* observer) {
   registered_for_updates_ = true;
   ExtensionSystem::Get(browser_context_)
       ->extension_service()
       ->AddUpdateObserver(observer);
 }
 
 void ChromeRuntimeAPIDelegate::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
@@ skipping 64 matching lines @@
 
 bool ChromeRuntimeAPIDelegate::CheckForUpdates(
     const std::string& extension_id,
     const UpdateCheckCallback& callback) {
   ExtensionSystem* system = ExtensionSystem::Get(browser_context_);
   ExtensionService* service = system->extension_service();
   ExtensionUpdater* updater = service->updater();
   if (!updater) {
     return false;
   }
-  if (!updater->CheckExtensionSoon(
-          extension_id,
-          base::Bind(&ChromeRuntimeAPIDelegate::UpdateCheckComplete,
-                     base::Unretained(this),
-                     extension_id))) {
+
+  UpdateCheckInfo& info = update_check_info_[extension_id];
+
+  // If not enough time has elapsed, or we have 10 or more outstanding calls,
+  // return a status of throttled.
+  if (info.backoff->ShouldRejectRequest() || info.callbacks.size() >= 10) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, UpdateCheckResult(true, kUpdateThrottled, "")));
   } else {
-    UpdateCallbackList& callbacks = pending_update_checks_[extension_id];
-    callbacks.push_back(callback);
+    info.callbacks.push_back(callback);
+    updater->CheckExtensionSoon(
+        extension_id, base::Bind(&ChromeRuntimeAPIDelegate::UpdateCheckComplete,
+                                 base::Unretained(this), extension_id));
   }
   return true;
 }
 
 void ChromeRuntimeAPIDelegate::OpenURL(const GURL& uninstall_url) {
   Profile* profile = Profile::FromBrowserContext(browser_context_);
   Browser* browser = chrome::FindLastActiveWithProfile(profile);
   if (!browser)
     browser = new Browser(Browser::CreateParams(profile));
 
@@ skipping 76 matching lines @@
   DCHECK(type == extensions::NOTIFICATION_EXTENSION_UPDATE_FOUND);
   typedef const std::pair<std::string, Version> UpdateDetails;
   const std::string& id = content::Details<UpdateDetails>(details)->first;
   const Version& version = content::Details<UpdateDetails>(details)->second;
   if (version.IsValid()) {
     CallUpdateCallbacks(
         id, UpdateCheckResult(true, kUpdateFound, version.GetString()));
   }
 }
 
+void ChromeRuntimeAPIDelegate::OnExtensionInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update) {
+  if (!is_update)
+    return;
+  auto info = update_check_info_.find(extension->id());
+  if (info != update_check_info_.end()) {
+    info->second.backoff->Reset();
+  }
+}
+
 void ChromeRuntimeAPIDelegate::UpdateCheckComplete(
     const std::string& extension_id) {
   ExtensionSystem* system = ExtensionSystem::Get(browser_context_);
   ExtensionService* service = system->extension_service();
   const Extension* update = service->GetPendingExtensionUpdate(extension_id);
+  UpdateCheckInfo& info = update_check_info_[extension_id];
+
+  // We always inform the BackoffEntry of a "failure" here, because we only
+  // want to consider an update check request a success from a throttling
+  // standpoint once the extension goes on to actually update to a new
+  // version. See OnExtensionInstalled for where we reset the BackoffEntry.
+  info.backoff->InformOfRequest(false);
+
   if (update) {
     CallUpdateCallbacks(
         extension_id,
         UpdateCheckResult(true, kUpdateFound, update->VersionString()));
   } else {
     CallUpdateCallbacks(extension_id,
                         UpdateCheckResult(true, kUpdateNotFound, ""));
   }
 }
 
 void ChromeRuntimeAPIDelegate::CallUpdateCallbacks(
     const std::string& extension_id,
     const UpdateCheckResult& result) {
-  UpdateCallbackList callbacks = pending_update_checks_[extension_id];
-  pending_update_checks_.erase(extension_id);
-  for (UpdateCallbackList::const_iterator iter = callbacks.begin();
-       iter != callbacks.end();
-       ++iter) {
-    const UpdateCheckCallback& callback = *iter;
+  auto it = update_check_info_.find(extension_id);
+  if (it == update_check_info_.end())
+    return;
+  std::vector<UpdateCheckCallback> callbacks;
+  it->second.callbacks.swap(callbacks);
+  for (const auto& callback : callbacks) {
     callback.Run(result);
   }
 }