Add support for the quick-enable-cf command to the installer. This encompase...

chrome/installer/util/installation_state.cc

 // Copyright (c) 2010 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/installer/util/installation_state.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/install_util.h"
 
 namespace installer {
 
 ProductState::ProductState()
     : uninstall_command_(CommandLine::NO_PROGRAM),
       msi_(false),
       multi_install_(false) {
 }
 
 bool ProductState::Initialize(bool system_install,
                               BrowserDistribution::Type type) {
   return Initialize(system_install,
                     BrowserDistribution::GetSpecificDistribution(type));
 }
 
+// Initializes |commands| from the "Commands" subkey of |version_key|.
+// Returns false if there is no "Commands" subkey or on error.
+// static
+bool ProductState::InitializeCommands(const base::win::RegKey& version_key,
+                                      AppCommands* commands) {
+  static const DWORD kAccess = KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE;
+  base::win::RegKey commands_key;
+
+  if (commands_key.Open(version_key.Handle(), google_update::kRegCommandsKey,
+                        kAccess) == ERROR_SUCCESS)
+    return commands->Initialize(commands_key);
+  return false;
+}
+
 bool ProductState::Initialize(bool system_install,
                               BrowserDistribution* distribution) {
   const std::wstring version_key(distribution->GetVersionKey());
   const std::wstring state_key(distribution->GetStateKey());
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   base::win::RegKey key(root_key, version_key.c_str(), KEY_QUERY_VALUE);
   std::wstring version_str;
   if (key.ReadValue(google_update::kRegVersionField,
                     &version_str) == ERROR_SUCCESS) {
     version_.reset(Version::GetVersionFromString(WideToASCII(version_str)));
     if (version_.get() != NULL) {
       // The product is installed.
       if (key.ReadValue(google_update::kRegOldVersionField,
                         &version_str) == ERROR_SUCCESS) {
         old_version_.reset(
             Version::GetVersionFromString(WideToASCII(version_str)));
       } else {
         old_version_.reset();
       }
       if (key.ReadValue(google_update::kRegRenameCmdField,
                         &rename_cmd_) != ERROR_SUCCESS)
         rename_cmd_.clear();
+      if (!InitializeCommands(key, &commands_))
+        commands_.Clear();
       // Read from the ClientState key.
       channel_.set_value(std::wstring());
       uninstall_command_ = CommandLine(CommandLine::NO_PROGRAM);
       msi_ = false;
       multi_install_ = false;
       if (key.Open(root_key, state_key.c_str(),
                    KEY_QUERY_VALUE) == ERROR_SUCCESS) {
         std::wstring setup_path;
         std::wstring uninstall_arguments;
         // "ap" will be absent if not managed by Google Update.
@@ skipping 32 matching lines @@
   return *version_;
 }
 
 ProductState& ProductState::CopyFrom(const ProductState& other) {
   channel_.set_value(other.channel_.value());
   version_.reset(other.version_.get() == NULL ? NULL : other.version_->Clone());
   old_version_.reset(
       other.old_version_.get() == NULL ? NULL : other.old_version_->Clone());
   rename_cmd_ = other.rename_cmd_;
   uninstall_command_ = other.uninstall_command_;
+  commands_.CopyFrom(other.commands_);
   msi_ = other.msi_;
   multi_install_ = other.multi_install_;
 
   return *this;
 }
 
 InstallationState::InstallationState() {
 }
 
 // static
@@ skipping 31 matching lines @@
 
 const ProductState* InstallationState::GetProductState(
     bool system_install,
     BrowserDistribution::Type type) const {
   const ProductState& product_state = (system_install ? system_products_ :
       user_products_)[IndexFromDistType(type)];
   return product_state.version_.get() == NULL ? NULL : &product_state;
 }
 
 }  // namespace installer