Add throttling to corrupt policy extensions reinstall

chrome/browser/extensions/chrome_content_verifier_delegate.cc

 // Copyright 2015 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/chrome_content_verifier_delegate.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
-#include "base/syslog_logging.h"
+#include "base/lazy_instance.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
+#include "base/syslog_logging.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/version.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_url_handlers.h"
+#include "net/base/backoff_entry.h"
 #include "net/base/escape.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/extensions/extension_assets_manager_chromeos.h"
 #endif
 
 namespace {
 
 const char kContentVerificationExperimentName[] =
     "ExtensionContentVerification";
 
+const net::BackoffEntry::Policy kPolicyReinstallBackoffPolicy = {
+    // num_errors_to_ignore
+    1,
+
+    // initial_delay_ms (note that we set 'always_use_initial_delay' to false
+    // below)
+    100,
+
+    // multiply_factor
+    2,
+
+    // jitter_factor
+    0.1,
+
+    // maximum_backoff_ms (30 minutes)
+    1000 * 60 * 30,
+
+    // entry_lifetime_ms (6 hours)
+    1000 * 60 * 60 * 6,
+
+    // always_use_initial_delay
+    false,
+};
+
+base::LazyInstance<base::Callback<void(base::TimeDelta delay)>>

[Devlin, 2016/11/29 22:31:24]

Any need for this to a be a lazy instance rather than just a raw ptr (and then
make sure it doesn't go out of scope in the test)?

[asargent_no_longer_on_chrome, 2016/11/30 00:11:48]

I think I did it this way out of habit because we normally pass Callback's by
value, but a raw pointer works too, so I've switched to that since it's a little
simpler. 

+    g_reinstall_action_for_test = LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 namespace extensions {
 
 // static
 ContentVerifierDelegate::Mode ChromeContentVerifierDelegate::GetDefaultMode() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   Mode experiment_value;
 #if defined(GOOGLE_CHROME_BUILD)
@@ skipping 125 matching lines @@
     if (system->management_policy()->MustRemainEnabled(extension, NULL)) {
       PendingExtensionManager* pending_manager =
           service->pending_extension_manager();
       if (pending_manager->IsPolicyReinstallForCorruptionExpected(extension_id))
         return;
       SYSLOG(WARNING) << "Corruption detected in policy extension "
                       << extension_id << " installed at: "
                       << extension->path().value();
       pending_manager->ExpectPolicyReinstallForCorruption(extension_id);
       service->DisableExtension(extension_id, Extension::DISABLE_CORRUPTED);
-      service->CheckForExternalUpdates();
+
+      net::BackoffEntry* backoff_entry = nullptr;
+      auto iter = policy_reinstall_backoff_.find(extension_id);
+      if (iter != policy_reinstall_backoff_.end()) {
+        backoff_entry = iter->second.get();
+      } else {
+        policy_reinstall_backoff_[extension_id] =
+            base::MakeUnique<net::BackoffEntry>(&kPolicyReinstallBackoffPolicy);
+        backoff_entry = policy_reinstall_backoff_[extension_id].get();

[Devlin, 2016/11/29 22:31:24]

nit: you could avoid a double look-up with either:
auto new_backoff_entry = base::MakeUnique<>(...);
backoff_entry = new_backoff_entry.get();
policy_reinstall_backoff_[extension_id] = std::move(new_backoff_entry)

or

backoff_entry =
    policy_reinstall_backoff_.insert(std::make_pair(
        extension_id, base::MakeUnique<>(...))).first->second;

[asargent_no_longer_on_chrome, 2016/11/30 00:11:48]

Done.

+      }
+      backoff_entry->InformOfRequest(false);
+
+      base::TimeDelta reinstall_delay = backoff_entry->GetTimeUntilRelease();
+      if (!g_reinstall_action_for_test.Get().is_null()) {
+        g_reinstall_action_for_test.Get().Run(reinstall_delay);
+      } else {
+        base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+            FROM_HERE, base::Bind(&ExtensionService::CheckForExternalUpdates,
+                                  service->AsWeakPtr()),
+            reinstall_delay);
+      }
       return;
     }
     DLOG(WARNING) << "Disabling extension " << extension_id << " ('"
                   << extension->name()
                   << "') due to content verification failure. In tests you "
                   << "might want to use a ScopedIgnoreContentVerifierForTest "
                   << "instance to prevent this.";
     service->DisableExtension(extension_id, Extension::DISABLE_CORRUPTED);
     ExtensionPrefs::Get(context_)->IncrementCorruptedDisableCount();
     UMA_HISTOGRAM_BOOLEAN("Extensions.CorruptExtensionBecameDisabled", true);
     UMA_HISTOGRAM_ENUMERATION("Extensions.CorruptExtensionDisabledReason",
                               reason, ContentVerifyJob::FAILURE_REASON_MAX);
   } else if (!base::ContainsKey(would_be_disabled_ids_, extension_id)) {
     UMA_HISTOGRAM_BOOLEAN("Extensions.CorruptExtensionWouldBeDisabled", true);
     would_be_disabled_ids_.insert(extension_id);
   }
 }
 
+// static
+void ChromeContentVerifierDelegate::set_policy_reinstall_action_for_test(
+    base::Callback<void(base::TimeDelta delay)> action) {
+  g_reinstall_action_for_test.Get() = action;
+}
 
 }  // namespace extensions