Retry reinstallation of corrupted policy extensions.

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/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_piece.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/browser/extensions/policy_extension_reinstaller.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::Callback<void(base::TimeDelta delay)>* g_reinstall_action_for_test =
-    nullptr;
 
 }  // namespace
 
 namespace extensions {
 
 // static
 ContentVerifierDelegate::Mode ChromeContentVerifierDelegate::GetDefaultMode() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   Mode experiment_value;
@@ skipping 44 matching lines @@
   }
 
   // We don't want to allow the command-line flags to eg disable enforcement
   // if the experiment group says it should be on, or malware may just modify
   // the command line flags. So return the more restrictive of the 2 values.
   return std::max(experiment_value, cmdline_value);
 }
 
 ChromeContentVerifierDelegate::ChromeContentVerifierDelegate(
     content::BrowserContext* context)
-    : context_(context), default_mode_(GetDefaultMode()) {}
+    : context_(context),
+      default_mode_(GetDefaultMode()),
+      policy_extension_reinstaller_(
+          base::MakeUnique<PolicyExtensionReinstaller>(context_)) {}
 
 ChromeContentVerifierDelegate::~ChromeContentVerifierDelegate() {
 }
 
 ContentVerifierDelegate::Mode ChromeContentVerifierDelegate::ShouldBeVerified(
     const Extension& extension) {
 #if defined(OS_CHROMEOS)
   if (ExtensionAssetsManagerChromeOS::IsSharedInstall(&extension))
     return ContentVerifierDelegate::ENFORCE_STRICT;
 #endif
@@ skipping 60 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);
-
-      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 {
-        auto new_backoff_entry =
-            base::MakeUnique<net::BackoffEntry>(&kPolicyReinstallBackoffPolicy);
-        backoff_entry = new_backoff_entry.get();
-        policy_reinstall_backoff_[extension_id] = std::move(new_backoff_entry);
-      }
-      backoff_entry->InformOfRequest(false);
-
-      base::TimeDelta reinstall_delay = backoff_entry->GetTimeUntilRelease();
-      if (g_reinstall_action_for_test) {
-        g_reinstall_action_for_test->Run(reinstall_delay);
-      } else {
-        base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-            FROM_HERE, base::Bind(&ExtensionService::CheckForExternalUpdates,
-                                  service->AsWeakPtr()),
-            reinstall_delay);
-      }
+      // Attempt to reinstall.
+      policy_extension_reinstaller_->NotifyExtensionDisabledDueToCorruption();
       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 = action;
+void ChromeContentVerifierDelegate::Shutdown() {
+  // Shut down |policy_extension_reinstaller_| on its creation thread. |this|
+  // can be destroyed through InfoMap on IO thread, we do not want to destroy
+  // |policy_extension_reinstaller_| there.
+  policy_extension_reinstaller_.reset();
 }
 
 }  // namespace extensions