Register Chrome in Active Setup to be called by Windows at user login.

chrome/installer/setup/install_worker.cc

 // Copyright (c) 2012 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.
 //
 // This file contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <oaidl.h>
 #include <shlobj.h>
 #include <time.h>
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
+#include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/setup_constants.h"
+#include "chrome/installer/setup/setup_util.h"
+#include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/conditional_work_item_list.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
+#include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
-#include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 #include "chrome_frame/chrome_tab.h"
 
 using base::win::RegKey;
 
@@ skipping 804 matching lines @@
     const Product* product = products[i];
 
     AddUninstallShortcutWorkItems(installer_state, setup_path, new_version,
                                   install_list, *product);
 
     AddVersionKeyWorkItems(root, product->distribution(), new_version,
                            add_language_identifier, install_list);
 
     AddDelegateExecuteWorkItems(installer_state, src_path, new_version,
                                 *product, install_list);
+
+    AddActiveSetupWorkItems(installer_state, new_version, *product,
+                            install_list);
   }
 
   if (installer_state.is_multi_install()) {
     AddMultiUninstallWorkItems(installer_state, setup_path, new_version,
                                install_list);
 
     AddVersionKeyWorkItems(root,
         installer_state.multi_package_binaries_distribution(), new_version,
         add_language_identifier, install_list);
   }
@@ skipping 308 matching lines @@
 
   } else {
     VLOG(1) << "Adding unregistration items for DelegateExecute verb handler.";
 
     list->AddDeleteRegKeyWorkItem(root, delegate_execute_path);
     list->AddDeleteRegKeyWorkItem(root, typelib_path);
     list->AddDeleteRegKeyWorkItem(root, interface_path);
   }
 }
 
+void AddActiveSetupWorkItems(const InstallerState& installer_state,
+                             const Version& new_version,
+                             const Product& product,
+                             WorkItemList* list) {
+  DCHECK(installer_state.operation() != InstallerState::UNINSTALL);
+  BrowserDistribution* distribution = product.distribution();
+
+  if (!product.is_chrome() || !installer_state.system_install()) {
+    const char* install_level =
+        installer_state.system_install() ? "system" : "user";
+    VLOG(1) << "No Active Setup processing to do for " << install_level
+            << "-level " << distribution->GetAppShortCutName();
+    return;
+  }
+
+  const HKEY root = HKEY_LOCAL_MACHINE;
+  const string16 active_setup_path(GetActiveSetupPath(distribution));
+
+  VLOG(1) << "Adding registration items for Active Setup.";
+  list->AddCreateRegKeyWorkItem(root, active_setup_path);
+  list->AddSetRegValueWorkItem(root, active_setup_path, L"",
+                               distribution->GetAppShortCutName(), true);
+
+  CommandLine cmd(installer_state.GetInstallerDirectory(new_version).
+      Append(installer::kSetupExe));
+  cmd.AppendSwitch(installer::switches::kConfigureUserSettings);
+  cmd.AppendSwitch(installer::switches::kVerboseLogging);
+  list->AddSetRegValueWorkItem(root, active_setup_path, L"StubPath",
+                               cmd.GetCommandLineString(), true);
+
+  // TODO(grt): http://crbug.com/75152 Write a reference to a localized
+  // resource.
+  list->AddSetRegValueWorkItem(root, active_setup_path, L"Localized Name",
+                               distribution->GetAppShortCutName(), true);
+
+  list->AddSetRegValueWorkItem(root, active_setup_path, L"IsInstalled",
+                               DWORD(1U), true);

[tommi (sloooow) - chröme, 2012/07/20 09:59:25]

static_cast<DWORD>(1U).  Is the cast actually necessary?

[gab, 2012/07/20 14:45:47]

Done.

Yes the cast is necessary otherwise I get:

1>installer\setup\install_worker.cc(1230): error C2668:
'WorkItemList::AddSetRegValueWorkItem' : ambiguous call to overloaded function
1>          G:\src\component\src\chrome/installer/util/work_item_list.h(110):
could be 'WorkItem *WorkItemList::AddSetRegValueWorkItem(HKEY,const std::wstring
&,const std::wstring &,int64,bool)'
1>          G:\src\component\src\chrome/installer/util/work_item_list.h(102): or
      'WorkItem *WorkItemList::AddSetRegValueWorkItem(HKEY,const std::wstring
&,const std::wstring &,DWORD,bool)'
1>          while trying to match the argument list '(const HKEY, const
string16, const wchar_t [12], unsigned int, bool)'

+
+  string16 comma_separated_version(ASCIIToUTF16(new_version.GetString()));
+  ReplaceChars(comma_separated_version, L".", L",", &comma_separated_version);
+  list->AddSetRegValueWorkItem(root, active_setup_path, L"Version",
+                               comma_separated_version, true);
+}
+
 namespace {
 
 enum ElevationPolicyId {
   CURRENT_ELEVATION_POLICY,
   OLD_ELEVATION_POLICY,
 };
 
 // Although the UUID of the ChromeFrame class is used for the "current" value,
 // this is done only as a convenience; there is no need for the GUID of the Low
 // Rights policies to match the ChromeFrame class's GUID.  Hence, it is safe to
@@ skipping 227 matching lines @@
     } else {
       DCHECK(operation == REMOVE_COMMAND);
       work_item_list->AddDeleteRegKeyWorkItem(installer_state.root_key(),
                                               cmd_key)->set_log_message(
           "removing quick-enable-cf command");
     }
   }
 }
 
 }  // namespace installer