Attempt to repair corrupt enterprise policy force-installed 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 <set>
-#include <string>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/version.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 75 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()) {}
 
 ChromeContentVerifierDelegate::~ChromeContentVerifierDelegate() {
 }
 
 ContentVerifierDelegate::Mode ChromeContentVerifierDelegate::ShouldBeVerified(
     const Extension& extension) {
 #if defined(OS_CHROMEOS)
   if (ExtensionAssetsManagerChromeOS::IsSharedInstall(&extension))
     return ContentVerifierDelegate::ENFORCE_STRICT;
 #endif
@@ skipping 47 matching lines @@
 
 void ChromeContentVerifierDelegate::VerifyFailed(
     const std::string& extension_id,
     ContentVerifyJob::FailureReason reason) {
   ExtensionRegistry* registry = ExtensionRegistry::Get(context_);
   const Extension* extension =
       registry->enabled_extensions().GetByID(extension_id);
   if (!extension)
     return;
   ExtensionSystem* system = ExtensionSystem::Get(context_);
+  ExtensionService* service = system->extension_service();
   Mode mode = ShouldBeVerified(*extension);
   if (mode >= ContentVerifierDelegate::ENFORCE) {
     if (!system->management_policy()->UserMayModifySettings(extension, NULL)) {
-      LogFailureForPolicyForceInstall(extension_id);
+      PendingExtensionManager* pending_manager =
+          service->pending_extension_manager();
+      if (pending_manager->IsPolicyReinstallForCorruptionExpected(extension_id))
+        return;
+      LOG(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();
       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.";
-    system->extension_service()->DisableExtension(extension_id,
-                                                  Extension::DISABLE_CORRUPTED);
+    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);
   }
 }
 
-void ChromeContentVerifierDelegate::LogFailureForPolicyForceInstall(
-    const std::string& extension_id) {
-  if (!base::ContainsKey(corrupt_policy_extensions_, extension_id)) {
-    corrupt_policy_extensions_.insert(extension_id);
-    UMA_HISTOGRAM_BOOLEAN("Extensions.CorruptPolicyExtensionWouldBeDisabled",
-                          true);
-  }
-}
 
 }  // namespace extensions