Serialize Google Update state as part of the recovery component 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/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)
     : id(id), name(name) {}
 ComponentInfo::~ComponentInfo() {}
 
 CrxUpdateService::CrxUpdateService(
     const scoped_refptr<Configurator>& config,
@@ skipping 286 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 auto* registered_component(GetComponent(id));
+    const update_client::CrxComponent* registered_component(GetComponent(id));
     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(CompletionCallback callback,
                                         const base::TimeTicks& start_time,
                                         int error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Update completed with error " << error;
 
@@ 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::WrapUnique(
       new CrxUpdateService(config, std::move(update_client)));
 }
 
 }  // namespace component_updater