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

components/component_updater/component_updater_service.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/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 11 matching lines @@
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/component_updater/component_updater_service_internal.h"
 #include "components/component_updater/timer.h"
-#if defined(OS_WIN)
-#include "components/component_updater/updater_state_win.h"
-#endif
 #include "components/update_client/configurator.h"
 #include "components/update_client/crx_update_item.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/update_client_errors.h"
 #include "components/update_client/utils.h"
 #include "url/gurl.h"
 
 using CrxInstaller = update_client::CrxInstaller;
 using UpdateClient = update_client::UpdateClient;
 
 namespace {
 
 enum UpdateType {
   UPDATE_TYPE_MANUAL = 0,
   UPDATE_TYPE_AUTOMATIC,
   UPDATE_TYPE_COUNT,
 };
 
-const char kRecoveryComponentId[] = "npdjjkjlcidkjlamlmmdelcjbcpdjocm";
-
 }  // namespace
 
 namespace component_updater {
 
 ComponentInfo::ComponentInfo(const std::string& id, const base::string16& name,
                              const base::Version& version)
     : id(id), name(name), version(version) {}
 ComponentInfo::~ComponentInfo() {}
 
 CrxUpdateService::CrxUpdateService(
@@ skipping 289 matching lines @@
   return false;
 }
 
 void CrxUpdateService::OnUpdate(const std::vector<std::string>& ids,
                                 std::vector<CrxComponent>* components) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(components->empty());
 
   for (const auto& id : ids) {
     const update_client::CrxComponent* registered_component(GetComponent(id));
-    if (registered_component) {
+    if (registered_component)
       components->push_back(*registered_component);
-      if (id == kRecoveryComponentId) {
-        // Override the installer attributes for the recovery component in the
-        // components which will be checked for updates.
-        update_client::CrxComponent& recovery_component(components->back());
-        recovery_component.installer_attributes =
-            GetInstallerAttributesForRecoveryComponentInstaller(
-                recovery_component);
-      }
-    }
   }
 }
 
 void CrxUpdateService::OnUpdateComplete(Callback callback,
                                         const base::TimeTicks& start_time,
                                         update_client::Error error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Update completed with error " << static_cast<int>(error);
 
   UMA_HISTOGRAM_BOOLEAN("ComponentUpdater.UpdateCompleteResult",
@@ skipping 40 matching lines @@
   // Update the component registration with the new version.
   if (event == Observer::Events::COMPONENT_UPDATED) {
     auto* component(const_cast<CrxComponent*>(GetComponent(id)));
     if (component) {
       component->version = update_item.next_version;
       component->fingerprint = update_item.next_fp;
     }
   }
 }
 
-update_client::InstallerAttributes
-CrxUpdateService::GetInstallerAttributesForRecoveryComponentInstaller(
-    const CrxComponent& crx_component) const {
-  update_client::InstallerAttributes installer_attributes;
-#if defined(OS_WIN)
-  DCHECK_EQ("recovery", crx_component.name);
-
-  const bool is_machine =
-      crx_component.installer_attributes.count("ismachine") &&
-      crx_component.installer_attributes.at("ismachine") == "1";
-
-  auto updater_state(UpdaterState::Create(is_machine));
-  if (updater_state) {
-    installer_attributes = updater_state->MakeInstallerAttributes();
-  }
-#endif
-  return installer_attributes;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 // TODO(sorin): consider making this a singleton.
 std::unique_ptr<ComponentUpdateService> ComponentUpdateServiceFactory(
     const scoped_refptr<Configurator>& config) {
   DCHECK(config);
   auto update_client = update_client::UpdateClientFactory(config);
   return base::MakeUnique<CrxUpdateService>(config, std::move(update_client));
 }
 
 }  // namespace component_updater