Rate limit programmatic update checks for extensions

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 "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;
 
+// The policy we use for exponential backoff of update check requests.
+const net::BackoffEntry::Policy kBackoffPolicy = {

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

I think this causes problems with static initializers.

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

I think this is actually ok because net::BackoffEntry::Policy is just a struct
of PODs. (Also there are several other Policy instances instantiated like this.)


https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables

"Objects with static storage duration, including global variables, static
variables, static class member variables, and function static variables, must be
Plain Old Data (POD): only ints, chars, floats, or pointers, or arrays/structs
of POD."

+    // 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

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

might be worth commenting that -1 == no maximum

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

Done.

+    -1,
+
+    // entry_lifetime_ms (-1 means never discard)
+    -1,
+
+    // always_use_initial_delay
+    false,
+};
+
+base::TickClock* g_test_clock = nullptr;
+
 }  // namespace
 
+struct ChromeRuntimeAPIDelegate::UpdateCheckInfo {
+ public:
+  UpdateCheckInfo() {
+    if (g_test_clock)
+      backoff.reset(new net::BackoffEntry(&kBackoffPolicy, g_test_clock));
+    else
+      backoff.reset(new net::BackoffEntry(&kBackoffPolicy));
+  }
+
+  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 (info.backoff->ShouldRejectRequest() || info.callbacks.size() >= 10) {

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

document what 10 is supposed to signify here.

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

Done.

     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())

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

Can this happen?

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

Yep, CallUpdateCallbacks gets called from ChromeRuntimeAPIDelegate::Observe when
a regularly scheduled extension autoupdate check (ie not one triggered by the
runtime.requestUpdateCheck method) found an update.

+    return;
+  UpdateCheckInfo& info = it->second;
+  std::vector<UpdateCheckCallback> callbacks = std::move(info.callbacks);
+  info.callbacks.clear();
+  for (const auto& callback : callbacks) {
     callback.Run(result);
   }
 }