Use consistent values for enabled_component_updates throughout an update.

components/update_client/update_checker.cc

 // Copyright 2014 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 "components/update_client/update_checker.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 54 matching lines @@
 //    <app appid="hnimpnehoodheedghdeeijklkeaacbdc"
 //         version="0.1.2.3" installsource="ondemand">
 //      <updatecheck />
 //      <packages>
 //        <package fp="abcd" />
 //      </packages>
 //    </app>
 std::string BuildUpdateCheckRequest(const Configurator& config,
                                     const std::vector<CrxUpdateItem*>& items,
                                     PersistedData* metadata,
-                                    const std::string& additional_attributes) {
+                                    const std::string& additional_attributes,
+                                    bool enabled_component_updates) {
   const std::string brand(SanitizeBrand(config.GetBrand()));
   std::string app_elements;
   for (size_t i = 0; i != items.size(); ++i) {
     const CrxUpdateItem* item = items[i];
     const update_client::InstallerAttributes installer_attributes(
         SanitizeInstallerAttributes(item->component.installer_attributes));
     std::string app("<app ");
     base::StringAppendF(&app, "appid=\"%s\" version=\"%s\"", item->id.c_str(),
                         item->component.version.GetString().c_str());
     if (!brand.empty())
       base::StringAppendF(&app, " brand=\"%s\"", brand.c_str());
     if (item->on_demand)
       base::StringAppendF(&app, " installsource=\"ondemand\"");
     for (const auto& attr : installer_attributes) {
       base::StringAppendF(&app, " %s=\"%s\"", attr.first.c_str(),
                           attr.second.c_str());
     }
     base::StringAppendF(&app, ">");
 
     base::StringAppendF(&app, "<updatecheck");
     if (item->component.supports_group_policy_enable_component_updates &&
-        !config.EnabledComponentUpdates()) {
+        !enabled_component_updates) {
       base::StringAppendF(&app, " updatedisabled=\"true\"");
     }
     base::StringAppendF(&app, "/>");
 
     base::StringAppendF(&app, "<ping rd=\"%d\" ping_freshness=\"%s\" />",
                         metadata->GetDateLastRollCall(item->id),
                         metadata->GetPingFreshness(item->id).c_str());
     if (!item->component.fingerprint.empty()) {
       base::StringAppendF(&app,
                           "<packages>"
@@ skipping 15 matching lines @@
 class UpdateCheckerImpl : public UpdateChecker {
  public:
   UpdateCheckerImpl(const scoped_refptr<Configurator>& config,
                     PersistedData* metadata);
   ~UpdateCheckerImpl() override;
 
   // Overrides for UpdateChecker.
   bool CheckForUpdates(
       const std::vector<CrxUpdateItem*>& items_to_check,
       const std::string& additional_attributes,
+      bool enabled_component_updates,
       const UpdateCheckCallback& update_check_callback) override;
 
  private:
   void OnRequestSenderComplete(
       std::unique_ptr<std::vector<std::string>> ids_checked,
       int error,
       const std::string& response,
       int retry_after_sec);
   base::ThreadChecker thread_checker_;
 
   const scoped_refptr<Configurator> config_;
   PersistedData* metadata_;
   UpdateCheckCallback update_check_callback_;
   std::unique_ptr<RequestSender> request_sender_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckerImpl);
 };
 
 UpdateCheckerImpl::UpdateCheckerImpl(const scoped_refptr<Configurator>& config,
                                      PersistedData* metadata)
     : config_(config), metadata_(metadata) {}
 
 UpdateCheckerImpl::~UpdateCheckerImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool UpdateCheckerImpl::CheckForUpdates(
     const std::vector<CrxUpdateItem*>& items_to_check,
     const std::string& additional_attributes,
+    bool enabled_component_updates,
     const UpdateCheckCallback& update_check_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (request_sender_.get()) {
     NOTREACHED();
     return false;  // Another update check is in progress.
   }
 
   update_check_callback_ = update_check_callback;
 
   auto urls(config_->UpdateUrl());
   if (IsEncryptionRequired(items_to_check))
     RemoveUnsecureUrls(&urls);
 
   std::unique_ptr<std::vector<std::string>> ids_checked(
       new std::vector<std::string>());
   for (auto* crx : items_to_check)
     ids_checked->push_back(crx->id);
   request_sender_.reset(new RequestSender(config_));
   request_sender_->Send(
       config_->EnabledCupSigning(),
       BuildUpdateCheckRequest(*config_, items_to_check, metadata_,
-                              additional_attributes),
+                              additional_attributes, enabled_component_updates),
       urls, base::Bind(&UpdateCheckerImpl::OnRequestSenderComplete,
                        base::Unretained(this), base::Passed(&ids_checked)));
   return true;
 }
 
 void UpdateCheckerImpl::OnRequestSenderComplete(
     std::unique_ptr<std::vector<std::string>> ids_checked,
     int error,
     const std::string& response,
     int retry_after_sec) {
@@ skipping 23 matching lines @@
 }  // namespace
 
 std::unique_ptr<UpdateChecker> UpdateChecker::Create(
     const scoped_refptr<Configurator>& config,
     PersistedData* persistent) {
   return std::unique_ptr<UpdateChecker>(
       new UpdateCheckerImpl(config, persistent));
 }
 
 }  // namespace update_client