Attempt to repair corrupt enterprise policy force-installed extensions

extensions/browser/updater/extension_downloader.cc

 // Copyright (c) 2012 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 "extensions/browser/updater/extension_downloader.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 192 matching lines @@
 
 bool ExtensionDownloader::AddExtension(const Extension& extension,
                                        int request_id) {
   // Skip extensions with empty update URLs converted from user
   // scripts.
   if (extension.converted_from_user_script() &&
       ManifestURL::GetUpdateURL(&extension).is_empty()) {
     return false;
   }
 
+  ManifestFetchData::ExtraParams extra;
+
   // If the extension updates itself from the gallery, ignore any update URL
   // data.  At the moment there is no extra data that an extension can
   // communicate to the the gallery update servers.
   std::string update_url_data;
   if (!ManifestURL::UpdatesFromGallery(&extension))
-    update_url_data = delegate_->GetUpdateUrlData(extension.id());
+    extra.update_url_data = delegate_->GetUpdateUrlData(extension.id());
 
   return AddExtensionData(
       extension.id(), *extension.version(), extension.GetType(),
-      ManifestURL::GetUpdateURL(&extension), update_url_data, request_id);
+      ManifestURL::GetUpdateURL(&extension), &extra, request_id);
 }
 
 bool ExtensionDownloader::AddPendingExtension(const std::string& id,
                                               const GURL& update_url,
+                                              bool is_corrupt_reinstall,
                                               int request_id) {
   // Use a zero version to ensure that a pending extension will always
   // be updated, and thus installed (assuming all extensions have
   // non-zero versions).
   base::Version version("0.0.0.0");
   DCHECK(version.IsValid());
+  ManifestFetchData::ExtraParams extra;
+  if (is_corrupt_reinstall)
+    extra.is_corrupt_policy_reinstall = true;
 
   return AddExtensionData(id, version, Manifest::TYPE_UNKNOWN, update_url,
-                          std::string(), request_id);
+                          &extra, request_id);
 }
 
 void ExtensionDownloader::StartAllPending(ExtensionCache* cache) {
   if (cache) {
     extension_cache_ = cache;
     extension_cache_->Start(base::Bind(&ExtensionDownloader::DoStartAllPending,
                                        weak_ptr_factory_.GetWeakPtr()));
   } else {
     DoStartAllPending();
   }
@@ skipping 17 matching lines @@
     const std::string& version,
     const ManifestFetchData::PingData& ping_data,
     int request_id) {
   // Note: it is very important that we use the https version of the update
   // url here to avoid DNS hijacking of the blacklist, which is not validated
   // by a public key signature like .crx files are.
   std::unique_ptr<ManifestFetchData> blacklist_fetch(CreateManifestFetchData(
       extension_urls::GetWebstoreUpdateUrl(), request_id));
   DCHECK(blacklist_fetch->base_url().SchemeIsCryptographic());
   blacklist_fetch->AddExtension(kBlacklistAppID, version, &ping_data,
-                                std::string(), kDefaultInstallSource);
+                                kDefaultInstallSource, nullptr);
   StartUpdateCheck(std::move(blacklist_fetch));
 }
 
 void ExtensionDownloader::SetWebstoreIdentityProvider(
     std::unique_ptr<IdentityProvider> identity_provider) {
   identity_provider_.swap(identity_provider);
 }
 
 // static
 void ExtensionDownloader::set_test_delegate(
     ExtensionDownloaderTestDelegate* delegate) {
   g_test_delegate = delegate;
 }
 
-bool ExtensionDownloader::AddExtensionData(const std::string& id,
-                                           const base::Version& version,
-                                           Manifest::Type extension_type,
-                                           const GURL& extension_update_url,
-                                           const std::string& update_url_data,
-                                           int request_id) {
+bool ExtensionDownloader::AddExtensionData(
+    const std::string& id,
+    const base::Version& version,
+    Manifest::Type extension_type,
+    const GURL& extension_update_url,
+    const ManifestFetchData::ExtraParams* extra,
+    int request_id) {
   GURL update_url(extension_update_url);
   // Skip extensions with non-empty invalid update URLs.
   if (!update_url.is_empty() && !update_url.is_valid()) {
     DLOG(WARNING) << "Extension " << id << " has invalid update url "
                   << update_url;
     return false;
   }
 
   // Make sure we use SSL for store-hosted extensions.
   if (extension_urls::IsWebstoreUpdateUrl(update_url) &&
@@ skipping 51 matching lines @@
 
   // Find or create a ManifestFetchData to add this extension to.
   bool added = false;
   FetchMap::iterator existing_iter =
       fetches_preparing_.find(std::make_pair(request_id, update_url));
   if (existing_iter != fetches_preparing_.end() &&
       !existing_iter->second.empty()) {
     // Try to add to the ManifestFetchData at the end of the list.
     ManifestFetchData* existing_fetch = existing_iter->second.back().get();
     if (existing_fetch->AddExtension(id, version.GetString(),
-                                     optional_ping_data, update_url_data,
-                                     install_source)) {
+                                     optional_ping_data, install_source,
+                                     extra)) {
       added = true;
     }
   }
   if (!added) {
     // Otherwise add a new element to the list, if the list doesn't exist or
     // if its last element is already full.
     std::unique_ptr<ManifestFetchData> fetch(
         CreateManifestFetchData(update_url, request_id));
     ManifestFetchData* fetch_ptr = fetch.get();
     fetches_preparing_[std::make_pair(request_id, update_url)].push_back(
         std::move(fetch));
     added = fetch_ptr->AddExtension(id, version.GetString(), optional_ping_data,
-                                    update_url_data, install_source);
+                                    install_source, extra);
     DCHECK(added);
   }
 
   return true;
 }
 
 void ExtensionDownloader::ReportStats() const {
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckExtension",
                            url_stats_.extension_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckTheme",
@@ skipping 551 matching lines @@
     const GURL& update_url,
     int request_id) {
   ManifestFetchData::PingMode ping_mode = ManifestFetchData::NO_PING;
   if (update_url.DomainIs(ping_enabled_domain_.c_str()))
     ping_mode = ManifestFetchData::PING_WITH_ENABLED_STATE;
   return new ManifestFetchData(
       update_url, request_id, brand_code_, manifest_query_params_, ping_mode);
 }
 
 }  // namespace extensions