Enable forced extension updates on NaCl arch mismatch

chrome/browser/extensions/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 "chrome/browser/extensions/updater/extension_downloader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 10 matching lines @@
 #include "base/version.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/updater/extension_cache.h"
 #include "chrome/browser/extensions/updater/request_queue_impl.h"
 #include "chrome/browser/extensions/updater/safe_manifest_parser.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
+#include "components/omaha_query_params/omaha_query_params.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "google_apis/gaia/identity_provider.h"
 #include "net/base/backoff_entry.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
+using omaha_query_params::OmahaQueryParams;
 
 namespace extensions {
 
 const char ExtensionDownloader::kBlacklistAppID[] = "com.google.crx.blacklist";
 
 namespace {
 
 const net::BackoffEntry::Policy kDefaultBackoffPolicy = {
   // Number of initial errors (in sequence) to ignore before applying
   // exponential back-off rules.
@@ skipping 20 matching lines @@
   false,
 };
 
 const char kAuthUserQueryKey[] = "authuser";
 
 const int kMaxAuthUserValue = 10;
 const int kMaxOAuth2Attempts = 3;
 
 const char kNotFromWebstoreInstallSource[] = "notfromwebstore";
 const char kDefaultInstallSource[] = "";
+const char kWrongMultiCrxInstallSource[] = "wrong_multi_crx";
 
 const char kGoogleDotCom[] = "google.com";
 const char kTokenServiceConsumerId[] = "extension_downloader";
 const char kWebstoreOAuth2Scope[] =
     "https://www.googleapis.com/auth/chromewebstore.readonly";
 
 #define RETRY_HISTOGRAM(name, retry_count, url)                           \
   if ((url).DomainIs(kGoogleDotCom)) {                                    \
     UMA_HISTOGRAM_CUSTOM_COUNTS("Extensions." name "RetryCountGoogleUrl", \
                                 retry_count,                              \
@@ skipping 106 matching lines @@
     return false;
   }
 
   // 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());
 
-  return AddExtensionData(extension.id(), *extension.version(),
+  // If the browser's native architecture has changed since this extension was
+  // installed, we need to force an update.
+  bool force_update = false;
+  std::string install_source;
+  if (extension.HasPlatformSpecificResources() &&

[Sorin Jianu, 2014/09/02 20:06:39]

Do we need both conditions?

[Ken Rockot(use gerrit already), 2014/09/02 20:19:20]

Yes. Many extensions don't have any platform-specific resources.

For force-update to kick in, it is necessary that an extension uses
platform-specific resources AND doesn't have resources for the current platform.

I thought it would be better to expose these two interfaces separately on
Extension and combine them here, rather than define a single interface that
specifically addresses this condition.

+      !extension.HasResourcesForPlatform(OmahaQueryParams::GetNaclArch())) {
+    force_update = true;
+    install_source = kWrongMultiCrxInstallSource;
+  }
+
+  return AddExtensionData(extension.id(),
+                          *extension.version(),
                           extension.GetType(),
                           ManifestURL::GetUpdateURL(&extension),
-                          update_url_data, request_id);
+                          update_url_data,
+                          request_id,
+                          force_update,
+                          install_source);
 }
 
 bool ExtensionDownloader::AddPendingExtension(const std::string& id,
                                               const GURL& update_url,
                                               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).
   Version version("0.0.0.0");
   DCHECK(version.IsValid());
 
   return AddExtensionData(id,
                           version,
                           Manifest::TYPE_UNKNOWN,
                           update_url,
                           std::string(),
-                          request_id);
+                          request_id,
+                          false,
+                          "");
 }
 
 void ExtensionDownloader::StartAllPending(ExtensionCache* cache) {
   if (cache) {
     extension_cache_ = cache;
     extension_cache_->Start(base::Bind(
         &ExtensionDownloader::DoStartAllPending,
         weak_ptr_factory_.GetWeakPtr()));
   } else {
     DoStartAllPending();
@@ skipping 22 matching lines @@
   // url here to avoid DNS hijacking of the blacklist, which is not validated
   // by a public key signature like .crx files are.
   scoped_ptr<ManifestFetchData> blacklist_fetch(
       new ManifestFetchData(extension_urls::GetWebstoreUpdateUrl(),
                             request_id));
   DCHECK(blacklist_fetch->base_url().SchemeIsSecure());
   blacklist_fetch->AddExtension(kBlacklistAppID,
                                 version,
                                 &ping_data,
                                 std::string(),
-                                kDefaultInstallSource);
+                                kDefaultInstallSource,
+                                false);
   StartUpdateCheck(blacklist_fetch.Pass());
 }
 
 void ExtensionDownloader::SetWebstoreIdentityProvider(
     scoped_ptr<IdentityProvider> identity_provider) {
   identity_provider_.swap(identity_provider);
 }
 
-bool ExtensionDownloader::AddExtensionData(const std::string& id,
-                                           const 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 Version& version,
+    Manifest::Type extension_type,
+    const GURL& extension_update_url,
+    const std::string& update_url_data,
+    int request_id,
+    bool force_update,
+    const std::string& install_source_override) {
   GURL update_url(extension_update_url);
   // Skip extensions with non-empty invalid update URLs.
   if (!update_url.is_empty() && !update_url.is_valid()) {
     LOG(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 45 matching lines @@
       ChromeMetricsServiceAccessor::IsMetricsReportingEnabled()) {
     update_urls.push_back(extension_urls::GetWebstoreUpdateUrl());
   }
 
   for (size_t i = 0; i < update_urls.size(); ++i) {
     DCHECK(!update_urls[i].is_empty());
     DCHECK(update_urls[i].is_valid());
 
     std::string install_source = i == 0 ?
         kDefaultInstallSource : kNotFromWebstoreInstallSource;
+    if (!install_source_override.empty()) {
+      install_source = install_source_override;
+    }
 
     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_urls[i]));
     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)) {
+                                       install_source,
+                                       force_update)) {
         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.
       linked_ptr<ManifestFetchData> fetch(
           new ManifestFetchData(update_urls[i], request_id));
       fetches_preparing_[std::make_pair(request_id, update_urls[i])].
           push_back(fetch);
       added = fetch->AddExtension(id, version.GetString(),
                                   optional_ping_data,
                                   update_url_data,
-                                  install_source);
+                                  install_source,
+                                  force_update);
       DCHECK(added);
     }
   }
 
   return true;
 }
 
 void ExtensionDownloader::ReportStats() const {
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckExtension",
                            url_stats_.extension_count);
@@ skipping 238 matching lines @@
       if (!delegate_->GetExtensionExistingVersion(id, &version)) {
         VLOG(2) << id << " is not installed";
         continue;
       }
 
       VLOG(2) << id << " is at '" << version << "'";
 
       Version existing_version(version);
       Version update_version(update->version);
 
-      if (!update_version.IsValid() ||
-          update_version.CompareTo(existing_version) <= 0) {
-        continue;
+      // We should skip the version check if update was forced.
+      if (!fetch_data.DidForceUpdate(id)) {

[Yoyo Zhou, 2014/09/02 19:30:04]

This could be at 669.

[Ken Rockot(use gerrit already), 2014/09/02 20:04:30]

Doh! Done.

+        if (!update_version.IsValid() ||
+            update_version.CompareTo(existing_version) <= 0) {
+          continue;
+        }
       }
     }
 
     // If the update specifies a browser minimum version, do we qualify?
     if (update->browser_min_version.length() > 0) {
       // First determine the browser version if we haven't already.
       if (!browser_version.IsValid()) {
         chrome::VersionInfo version_info;
         if (version_info.is_valid())
           browser_version = Version(version_info.Version());
@@ skipping 264 matching lines @@
 
 void ExtensionDownloader::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   // If we fail to get an access token, kick the pending fetch and let it fall
   // back on cookies.
   extension_fetcher_->Start();
 }
 
 }  // namespace extensions