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 67 matching lines @@
     false,
 };
 
 const char kAuthUserQueryKey[] = "authuser";
 
 const int kMaxAuthUserValue = 10;
 const int kMaxOAuth2Attempts = 3;
 
 const char kNotFromWebstoreInstallSource[] = "notfromwebstore";
 const char kDefaultInstallSource[] = "";
+const char kReinstallInstallSource[] = "reinstall";
 
 const char kGoogleDotCom[] = "google.com";
 const char kTokenServiceConsumerId[] = "extension_downloader";
 const char kWebstoreOAuth2Scope[] =
     "https://www.googleapis.com/auth/chromewebstore.readonly";
 
 ExtensionDownloaderTestDelegate* g_test_delegate = nullptr;
 
 #define RETRY_HISTOGRAM(name, retry_count, url)                           \
   if ((url).DomainIs(kGoogleDotCom)) {                                    \
@@ skipping 75 matching lines @@
       package_hash(package_hash),
       version(version),
       request_ids(request_ids),
       credentials(CREDENTIALS_NONE),
       oauth2_attempt_count(0) {
 }
 
 ExtensionDownloader::ExtensionFetch::~ExtensionFetch() {
 }
 
+ExtensionDownloader::ExtraParams::ExtraParams() : is_corrupt_reinstall(false) {}
+
 ExtensionDownloader::ExtensionDownloader(
     ExtensionDownloaderDelegate* delegate,
     net::URLRequestContextGetter* request_context)
     : OAuth2TokenService::Consumer(kTokenServiceConsumerId),
       delegate_(delegate),
       request_context_(request_context),
       manifests_queue_(&kDefaultBackoffPolicy,
                        base::Bind(&ExtensionDownloader::CreateManifestFetcher,
                                   base::Unretained(this))),
       extensions_queue_(&kDefaultBackoffPolicy,
@@ skipping 10 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;
   }
 
+  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());
+  ExtraParams extra;
+  if (is_corrupt_reinstall)
+    extra.is_corrupt_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 36 matching lines @@
 // 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,
+                                           const 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.
@@ skipping 37 matching lines @@
       ++url_stats_.pending_count;
       break;
   }
 
   DCHECK(!update_url.is_empty());
   DCHECK(update_url.is_valid());
 
   std::string install_source = extension_urls::IsWebstoreUpdateUrl(update_url)
                                    ? kDefaultInstallSource
                                    : kNotFromWebstoreInstallSource;
+  if (extra.is_corrupt_reinstall)
+    install_source = kReinstallInstallSource;
 
   ManifestFetchData::PingData ping_data;
   ManifestFetchData::PingData* optional_ping_data = NULL;
   if (delegate_->GetPingDataForExtension(id, &ping_data))
     optional_ping_data = &ping_data;
 
   // 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,
+                                     optional_ping_data, extra.update_url_data,
                                      install_source)) {
       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);
+                                    extra.update_url_data, install_source);
     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