Refactor how the updater state data is serialized in update checks.

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>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/update_client/configurator.h"
 #include "components/update_client/crx_update_item.h"
 #include "components/update_client/persisted_data.h"
 #include "components/update_client/request_sender.h"
 #include "components/update_client/update_client.h"
+#include "components/update_client/updater_state.h"
 #include "components/update_client/utils.h"
 #include "url/gurl.h"
 
 namespace update_client {
 
 namespace {
 
 // Returns a sanitized version of the brand or an empty string otherwise.
 std::string SanitizeBrand(const std::string& brand) {
   return IsValidBrand(brand) ? brand : std::string("");
@@ skipping 26 matching lines @@
 // the <request>.
 //
 // An app element looks like this:
 //    <app appid="hnimpnehoodheedghdeeijklkeaacbdc"
 //         version="0.1.2.3" installsource="ondemand">
 //      <updatecheck/>
 //      <packages>
 //        <package fp="abcd"/>
 //      </packages>
 //    </app>
-std::string BuildUpdateCheckRequest(const Configurator& config,
-                                    const IdToCrxUpdateItemMap& items,
-                                    PersistedData* metadata,
-                                    const std::string& additional_attributes,
-                                    bool enabled_component_updates) {
+std::string BuildUpdateCheckRequest(
+    const Configurator& config,
+    const IdToCrxUpdateItemMap& items,
+    PersistedData* metadata,
+    const std::string& additional_attributes,
+    bool enabled_component_updates,
+    const std::unique_ptr<UpdaterState::Attributes>& updater_state_attributes) {
   const std::string brand(SanitizeBrand(config.GetBrand()));
   std::string app_elements;
   for (const auto& item_pair : items) {
     const CrxUpdateItem* item = item_pair.second.get();
     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())
@@ skipping 30 matching lines @@
                           "<packages>"
                           "<package fp=\"%s\"/>"
                           "</packages>",
                           item->component.fingerprint.c_str());
     }
     base::StringAppendF(&app, "</app>");
     app_elements.append(app);
     VLOG(1) << "Appending to update request: " << app;
   }
 
+  // Include the updater state in the update check request.
   return BuildProtocolRequest(
       config.GetProdId(), config.GetBrowserVersion().GetString(),
       config.GetChannel(), config.GetLang(), config.GetOSLongName(),
-      config.GetDownloadPreference(), app_elements, additional_attributes);
+      config.GetDownloadPreference(), app_elements, additional_attributes,
+      updater_state_attributes);
 }
 
 class UpdateCheckerImpl : public UpdateChecker {
  public:
   UpdateCheckerImpl(const scoped_refptr<Configurator>& config,
                     PersistedData* metadata);
   ~UpdateCheckerImpl() override;
 
   // Overrides for UpdateChecker.
   bool CheckForUpdates(
       const IdToCrxUpdateItemMap& items_to_check,
       const std::string& additional_attributes,
       bool enabled_component_updates,
       const UpdateCheckCallback& update_check_callback) override;
 
  private:
+  void ReadUpdaterStateAttributes();
+  void CheckForUpdatesHelper(const IdToCrxUpdateItemMap& items_to_check,
+                             const std::string& additional_attributes,
+                             bool enabled_component_updates);
+
   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<UpdaterState::Attributes> updater_state_attributes_;
   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 IdToCrxUpdateItemMap& 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;
 
-  update_check_callback_ = update_check_callback;
+  return config_->GetSequencedTaskRunner()->PostTaskAndReply(
+      FROM_HERE, base::Bind(&UpdateCheckerImpl::ReadUpdaterStateAttributes,
+                            base::Unretained(this)),
+      base::Bind(&UpdateCheckerImpl::CheckForUpdatesHelper,
+                 base::Unretained(this), base::ConstRef(items_to_check),
+                 additional_attributes, enabled_component_updates));
+}
+
+// This function runs on the blocking pool task runner.
+void UpdateCheckerImpl::ReadUpdaterStateAttributes() {
+  const bool is_machine_install = !config_->IsPerUserInstall();
+  updater_state_attributes_ = UpdaterState::GetState(is_machine_install);
+}
+
+void UpdateCheckerImpl::CheckForUpdatesHelper(
+    const IdToCrxUpdateItemMap& items_to_check,
+    const std::string& additional_attributes,
+    bool enabled_component_updates) {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   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 (const auto& item : items_to_check)
     ids_checked->push_back(item.second->id);
   request_sender_.reset(new RequestSender(config_));
   request_sender_->Send(
       config_->EnabledCupSigning(),
       BuildUpdateCheckRequest(*config_, items_to_check, metadata_,
-                              additional_attributes, enabled_component_updates),
+                              additional_attributes, enabled_component_updates,
+                              updater_state_attributes_),
       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) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!error) {
@@ skipping 31 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