Send traffic-management headers from extension updater.

chrome/browser/extensions/updater/extension_updater.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_updater.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 79 matching lines @@
   if (last_active_ping_day.is_null())
     return extensions::ManifestFetchData::kNeverPinged;
   return SanitizeDays((Time::Now() - last_active_ping_day).InDays());
 }
 
 }  // namespace
 
 namespace extensions {
 
 ExtensionUpdater::CheckParams::CheckParams()
-    : install_immediately(false) {}
+    : install_immediately(false),
+      fetch_priority(ManifestFetchData::FetchPriority::BACKGROUND) {}
 
 ExtensionUpdater::CheckParams::~CheckParams() {}
 
 ExtensionUpdater::FetchedCRXFile::FetchedCRXFile(
     const CRXFileInfo& file,
     bool file_ownership_passed,
     const std::set<int>& request_ids,
     const InstallCallback& callback)
     : info(file),
       file_ownership_passed(file_ownership_passed),
@@ skipping 188 matching lines @@
 
 void ExtensionUpdater::DoCheckSoon() {
   DCHECK(will_check_soon_);
   CheckNow(CheckParams());
   will_check_soon_ = false;
 }
 
 void ExtensionUpdater::AddToDownloader(
     const ExtensionSet* extensions,
     const std::list<std::string>& pending_ids,
-    int request_id) {
+    int request_id,
+    ManifestFetchData::FetchPriority fetch_priority) {
   InProgressCheck& request = requests_in_progress_[request_id];
   for (ExtensionSet::const_iterator extension_iter = extensions->begin();
        extension_iter != extensions->end(); ++extension_iter) {
     const Extension& extension = **extension_iter;
     if (!Manifest::IsAutoUpdateableLocation(extension.location())) {
       VLOG(2) << "Extension " << extension.id() << " is not auto updateable";
       continue;
     }
     // An extension might be overwritten by policy, and have its update url
     // changed. Make sure existing extensions aren't fetched again, if a
     // pending fetch for an extension with the same id already exists.
     std::list<std::string>::const_iterator pending_id_iter = std::find(
         pending_ids.begin(), pending_ids.end(), extension.id());
     if (pending_id_iter == pending_ids.end()) {
-      if (downloader_->AddExtension(extension, request_id))
+      if (downloader_->AddExtension(extension, request_id, fetch_priority))
         request.in_progress_ids_.push_back(extension.id());
     }
   }
 }
 
 void ExtensionUpdater::CheckNow(const CheckParams& params) {
   int request_id = next_request_id_++;
 
   VLOG(2) << "Starting update check " << request_id;
   if (params.ids.empty())
@@ skipping 24 matching lines @@
       const PendingExtensionInfo* info = pending_extension_manager->GetById(
           *iter);
       if (!Manifest::IsAutoUpdateableLocation(info->install_source())) {
         VLOG(2) << "Extension " << *iter << " is not auto updateable";
         continue;
       }
       if (downloader_->AddPendingExtension(
               *iter, info->update_url(),
               pending_extension_manager->IsPolicyReinstallForCorruptionExpected(
                   *iter),
-              request_id))
+              request_id, params.fetch_priority))
         request.in_progress_ids_.push_back(*iter);
     }
 
     ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
-    AddToDownloader(&registry->enabled_extensions(), pending_ids, request_id);
-    AddToDownloader(&registry->disabled_extensions(), pending_ids, request_id);
+    AddToDownloader(&registry->enabled_extensions(), pending_ids, request_id,
+                    params.fetch_priority);
+    AddToDownloader(&registry->disabled_extensions(), pending_ids, request_id,
+                    params.fetch_priority);
   } else {
     for (std::list<std::string>::const_iterator it = params.ids.begin();
          it != params.ids.end(); ++it) {
       const Extension* extension = service_->GetExtensionById(*it, true);
-      if (extension && downloader_->AddExtension(*extension, request_id))
+      if (extension && downloader_->AddExtension(*extension, request_id,
+                                                 params.fetch_priority))
         request.in_progress_ids_.push_back(extension->id());
     }
   }
 
   // StartAllPending() might call OnExtensionDownloadFailed/Finished before
   // it returns, which would cause NotifyIfFinished to incorrectly try to
   // send out a notification. So check before we call StartAllPending if any
   // extensions are going to be updated, and use that to figure out if
   // NotifyIfFinished should be called.
   bool noChecks = request.in_progress_ids_.empty();
@@ skipping 211 matching lines @@
   const InProgressCheck& request = requests_in_progress_[request_id];
   if (request.in_progress_ids_.empty()) {
     VLOG(2) << "Finished update check " << request_id;
     if (!request.callback.is_null())
       request.callback.Run();
     requests_in_progress_.erase(request_id);
   }
 }
 
 }  // namespace extensions