Send traffic-management headers from extension updater.

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>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/version.h"
+#include "components/update_client/update_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 "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/updater/extension_cache.h"
 #include "extensions/browser/updater/extension_downloader_test_delegate.h"
 #include "extensions/browser/updater/request_queue_impl.h"
 #include "extensions/browser/updater/safe_manifest_parser.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/manifest_url_handlers.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 update_client::UpdateQueryParams;
 
 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 87 matching lines @@
   std::string new_query_string = base::JoinString(new_query_parts, "&");
   url::Component new_query(0, new_query_string.size());
   url::Replacements<char> replacements;
   replacements.SetQuery(new_query_string.c_str(), new_query);
   *url = url->ReplaceComponents(replacements);
   return true;
 }
 
 }  // namespace
 
+const char ExtensionDownloader::kUpdateInteractivityHeader[] =
+    "X-GoogleUpdate-Interactivity";
+const char ExtensionDownloader::kUpdateAppIdHeader[] = "X-GoogleUpdate-AppId";
+const char ExtensionDownloader::kUpdateUpdaterHeader[] =
+    "X-GoogleUpdate-Updater";
+
+const char ExtensionDownloader::kUpdateInteractivityForeground[] = "fg";
+const char ExtensionDownloader::kUpdateInteractivityBackground[] = "bg";
+
 UpdateDetails::UpdateDetails(const std::string& id,
                              const base::Version& version)
     : id(id), version(version) {}
 
 UpdateDetails::~UpdateDetails() {
 }
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch()
     : url(), credentials(CREDENTIALS_NONE) {
 }
@@ skipping 32 matching lines @@
                                    base::Unretained(this))),
       extension_cache_(NULL),
       weak_ptr_factory_(this) {
   DCHECK(delegate_);
   DCHECK(request_context_.get());
 }
 
 ExtensionDownloader::~ExtensionDownloader() {
 }
 
-bool ExtensionDownloader::AddExtension(const Extension& extension,
-                                       int request_id) {
+bool ExtensionDownloader::AddExtension(
+    const Extension& extension,
+    int request_id,
+    ManifestFetchData::FetchPriority fetch_priority) {
   // 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))
     extra.update_url_data = delegate_->GetUpdateUrlData(extension.id());
 
   return AddExtensionData(
       extension.id(), *extension.version(), extension.GetType(),
-      ManifestURL::GetUpdateURL(&extension), extra, request_id);
+      ManifestURL::GetUpdateURL(&extension), extra, request_id, fetch_priority);
 }
 
-bool ExtensionDownloader::AddPendingExtension(const std::string& id,
-                                              const GURL& update_url,
-                                              bool is_corrupt_reinstall,
-                                              int request_id) {
+bool ExtensionDownloader::AddPendingExtension(
+    const std::string& id,
+    const GURL& update_url,
+    bool is_corrupt_reinstall,
+    int request_id,
+    ManifestFetchData::FetchPriority fetch_priority) {
   // 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,
-                          extra, request_id);
+                          extra, request_id, fetch_priority);
 }
 
 void ExtensionDownloader::StartAllPending(ExtensionCache* cache) {
   if (cache) {
     extension_cache_ = cache;
     extension_cache_->Start(base::Bind(&ExtensionDownloader::DoStartAllPending,
                                        weak_ptr_factory_.GetWeakPtr()));
   } else {
     DoStartAllPending();
   }
@@ skipping 13 matching lines @@
   fetches_preparing_.clear();
 }
 
 void ExtensionDownloader::StartBlacklistUpdate(
     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));
+  std::unique_ptr<ManifestFetchData> blacklist_fetch(
+      CreateManifestFetchData(extension_urls::GetWebstoreUpdateUrl(),
+                              request_id, ManifestFetchData::BACKGROUND));
   DCHECK(blacklist_fetch->base_url().SchemeIsCryptographic());
   blacklist_fetch->AddExtension(kBlacklistAppID, version, &ping_data,
-                                std::string(), kDefaultInstallSource);
+                                std::string(), kDefaultInstallSource,
+                                ManifestFetchData::FetchPriority::BACKGROUND);
   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 ExtraParams& extra,
-                                           int request_id) {
+bool ExtensionDownloader::AddExtensionData(
+    const std::string& id,
+    const base::Version& version,
+    Manifest::Type extension_type,
+    const GURL& extension_update_url,
+    const ExtraParams& extra,
+    int request_id,
+    ManifestFetchData::FetchPriority fetch_priority) {
   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 54 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, extra.update_url_data,
-                                     install_source)) {
+                                     install_source, fetch_priority)) {
       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));
+        CreateManifestFetchData(update_url, request_id, fetch_priority));
     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,
-                                    extra.update_url_data, install_source);
+                                    extra.update_url_data, install_source,
+                                    fetch_priority);
     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 42 matching lines @@
   } else {
     UMA_HISTOGRAM_COUNTS(
         "Extensions.UpdateCheckUrlLength",
         fetch_data->full_url().possibly_invalid_spec().length());
 
     manifests_queue_.ScheduleRequest(std::move(fetch_data));
   }
 }
 
 void ExtensionDownloader::CreateManifestFetcher() {
-  if (VLOG_IS_ON(2)) {
-    std::vector<std::string> id_vector(
-        manifests_queue_.active_request()->extension_ids().begin(),
-        manifests_queue_.active_request()->extension_ids().end());
-    std::string id_list = base::JoinString(id_vector, ",");
-    VLOG(2) << "Fetching " << manifests_queue_.active_request()->full_url()
-            << " for " << id_list;
-  }
+  const ManifestFetchData* active_request = manifests_queue_.active_request();
+  std::vector<base::StringPiece> id_vector(
+      active_request->extension_ids().begin(),
+      active_request->extension_ids().end());
+  std::string id_list = base::JoinString(id_vector, ",");
+  VLOG(2) << "Fetching " << active_request->full_url() << " for " << id_list;
+  VLOG(2) << "Update interactivity: "
+          << (active_request->foreground_check()
+                  ? kUpdateInteractivityForeground
+                  : kUpdateInteractivityBackground);
 
-  manifest_fetcher_ = net::URLFetcher::Create(
-      kManifestFetcherId, manifests_queue_.active_request()->full_url(),
-      net::URLFetcher::GET, this);
+  manifest_fetcher_ =
+      net::URLFetcher::Create(kManifestFetcherId, active_request->full_url(),
+                              net::URLFetcher::GET, this);
   manifest_fetcher_->SetRequestContext(request_context_.get());
   manifest_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                   net::LOAD_DO_NOT_SAVE_COOKIES |
                                   net::LOAD_DISABLE_CACHE);
+
+  // Send traffic-management headers.
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=647516
+  manifest_fetcher_->AddExtraRequestHeader(base::StringPrintf(
+      "%s: %s", kUpdateInteractivityHeader,
+      active_request->foreground_check() ? kUpdateInteractivityForeground
+                                         : kUpdateInteractivityBackground));
+  manifest_fetcher_->AddExtraRequestHeader(
+      base::StringPrintf("%s: %s", kUpdateAppIdHeader, id_list.c_str()));
+  manifest_fetcher_->AddExtraRequestHeader(base::StringPrintf(
+      "%s: %s-%s", kUpdateUpdaterHeader,
+      UpdateQueryParams::GetProdIdString(UpdateQueryParams::CRX),
+      UpdateQueryParams::GetProdVersion().c_str()));
+
   // Update checks can be interrupted if a network change is detected; this is
   // common for the retail mode AppPack on ChromeOS. Retrying once should be
   // enough to recover in those cases; let the fetcher retry up to 3 times
   // just in case. http://crosbug.com/130602
   manifest_fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
   manifest_fetcher_->Start();
 }
 
 void ExtensionDownloader::OnURLFetchComplete(const net::URLFetcher* source) {
   VLOG(2) << source->GetResponseCode() << " " << source->GetURL();
@@ skipping 464 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();
 }
 
 ManifestFetchData* ExtensionDownloader::CreateManifestFetchData(
     const GURL& update_url,
-    int request_id) {
+    int request_id,
+    ManifestFetchData::FetchPriority fetch_priority) {
   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);
+  return new ManifestFetchData(update_url, request_id, brand_code_,
+                               manifest_query_params_, ping_mode,
+                               fetch_priority);
 }
 
 }  // namespace extensions