Fix bugs related to making Chrome default browser on Vista.

chrome/installer/util/shell_util.cc

 // Copyright (c) 2006-2008 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 defines functions that integrate Chrome in Windows shell. These
 // functions can be used by Chrome as well as Chrome installer. All of the
 // work is done by the local functions defined in anonymous namespace in
 // this class.
 
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include "chrome/installer/util/shell_util.h"
 
+#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/registry.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 186 matching lines @@
   for (std::list<RegistryEntry*>::iterator itr = entries.begin();
       itr != entries.end(); ++itr) {
     if (registered && !(*itr)->ExistsInHKLM())
       registered = false;
     delete (*itr);
   }
   LOG(INFO) << "Check for Chrome registeration returned " << registered;
   return registered;
 }
 
-bool CreateChromeRegKeysForXP(HKEY root_key, const std::wstring& chrome_exe) {
+bool BindChromeAssociations(HKEY root_key, const std::wstring& chrome_exe) {
   // Create a list of registry entries to create so that we can rollback
   // in case of problem.
   scoped_ptr<WorkItemList> items(WorkItem::CreateWorkItemList());
-  std::wstring classes_path(ShellUtil::kRegClasses);
-
-  std::wstring exe_name = file_util::GetFilenameFromPath(chrome_exe);
-  std::wstring chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
-  std::wstring chrome_icon(chrome_exe);
-  ShellUtil::GetChromeIcon(chrome_icon);
-
-  // Create Software\Classes\ChromeHTML
-  std::wstring html_prog_id = classes_path + L"\\" +
-                              ShellUtil::kChromeHTMLProgId;
-  items->AddCreateRegKeyWorkItem(root_key, html_prog_id);
-  items->AddSetRegValueWorkItem(root_key, html_prog_id,
-                                L"", ShellUtil::kChromeHTMLProgIdDesc, true);
-  items->AddSetRegValueWorkItem(root_key, html_prog_id,
-                                ShellUtil::kRegUrlProtocol, L"", true);
-  std::wstring default_icon = html_prog_id + ShellUtil::kRegDefaultIcon;
-  items->AddCreateRegKeyWorkItem(root_key, default_icon);
-  items->AddSetRegValueWorkItem(root_key, default_icon, L"",
-                                chrome_icon, true);
-  std::wstring open_cmd = html_prog_id + ShellUtil::kRegShellOpen;
-  items->AddCreateRegKeyWorkItem(root_key, open_cmd);
-  items->AddSetRegValueWorkItem(root_key, open_cmd, L"",
-                                chrome_open, true);
 
   // file extension associations
+  std::wstring classes_path(ShellUtil::kRegClasses);
   for (int i = 0; ShellUtil::kFileAssociations[i] != NULL; i++) {
     std::wstring key_path = classes_path + L"\\" +
                             ShellUtil::kFileAssociations[i];
     items->AddCreateRegKeyWorkItem(root_key, key_path);
     items->AddSetRegValueWorkItem(root_key, key_path, L"",
                                   ShellUtil::kChromeHTMLProgId, true);
   }
 
   // protocols associations
+  std::wstring chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
+  std::wstring chrome_icon(chrome_exe);
+  ShellUtil::GetChromeIcon(chrome_icon);
   for (int i = 0; ShellUtil::kProtocolAssociations[i] != NULL; i++) {
     std::wstring key_path = classes_path + L"\\" +
                             ShellUtil::kProtocolAssociations[i];
     // <root hkey>\Software\Classes\<protocol>\DefaultIcon
     std::wstring icon_path = key_path + ShellUtil::kRegDefaultIcon;
     items->AddCreateRegKeyWorkItem(root_key, icon_path);
     items->AddSetRegValueWorkItem(root_key, icon_path, L"",
                                   chrome_icon, true);
     // <root hkey>\Software\Classes\<protocol>\shell\open\command
     std::wstring shell_path = key_path + ShellUtil::kRegShellOpen;
     items->AddCreateRegKeyWorkItem(root_key, shell_path);
     items->AddSetRegValueWorkItem(root_key, shell_path, L"",
                                   chrome_open, true);
     // <root hkey>\Software\Classes\<protocol>\shell\open\ddeexec
     std::wstring dde_path = key_path + L"\\shell\\open\\ddeexec";
     items->AddCreateRegKeyWorkItem(root_key, dde_path);
     items->AddSetRegValueWorkItem(root_key, dde_path, L"", L"", true);
     // <root hkey>\Software\Classes\<protocol>\shell\@
     std::wstring protocol_shell_path = key_path + ShellUtil::kRegShellPath;
     items->AddSetRegValueWorkItem(root_key, protocol_shell_path, L"",
                                   L"open", true);
   }
 
   // start->Internet shortcut.
+  std::wstring exe_name = file_util::GetFilenameFromPath(chrome_exe);
   std::wstring start_internet(ShellUtil::kRegStartMenuInternet);
   items->AddCreateRegKeyWorkItem(root_key, start_internet);
   items->AddSetRegValueWorkItem(root_key, start_internet, L"",
                                 exe_name, true);
 
   // Apply all the registry changes and if there is a problem, rollback
   if (!items->Do()) {
     LOG(ERROR) << "Error while registering Chrome as default browser";
     items->Rollback();
     return false;
   }
   return true;
 }
 
+// Populate work_item_list with WorkItem entries that will add chrome.exe to
+// the set of App Paths registry keys so that ShellExecute can find it. Note
+// that this is done in HKLM, regardless of whether this is a single-user
+// install or not. For non-admin users, this will fail.
+// chrome_exe: full path to chrome.exe
+// work_item_list: pointer to the WorkItemList that will be populated
+void AddChromeAppPathWorkItems(const std::wstring& chrome_exe,
+                               WorkItemList* item_list) {
+  FilePath chrome_path(chrome_exe);
+  std::wstring app_path_key(ShellUtil::kAppPathsRegistryKey);
+  file_util::AppendToPath(&app_path_key, chrome_path.BaseName().value());
+  item_list->AddCreateRegKeyWorkItem(HKEY_LOCAL_MACHINE, app_path_key);
+  item_list->AddSetRegValueWorkItem(HKEY_LOCAL_MACHINE, app_path_key, L"",
+                                    chrome_exe, true);
+  item_list->AddSetRegValueWorkItem(HKEY_LOCAL_MACHINE, app_path_key,
+                                    ShellUtil::kAppPathsRegistryPathName,
+                                    chrome_path.DirName().value(), true);
+}
+
 // This method creates the registry entries required for Add/Remove Programs->
 // Set Program Access and Defaults, Start->Default Programs on Windows Vista
 // and Chrome ProgIds for file extension and protocol handler. root_key is
 // the root registry (HKLM or HKCU).
 bool SetAccessDefaultRegEntries(HKEY root_key,
                                 const std::wstring& chrome_exe) {
   LOG(INFO) << "Registering Chrome browser " << chrome_exe;
   // Create a list of registry entries work items so that we can rollback
   // in case of problem.
   scoped_ptr<WorkItemList> items(WorkItem::CreateWorkItemList());
 
   std::list<RegistryEntry*> entries = RegistryEntry::GetAllEntries(chrome_exe);
   for (std::list<RegistryEntry*>::iterator itr = entries.begin();
       itr != entries.end(); ++itr) {
     (*itr)->AddToWorkItemList(root_key, items.get());
     delete (*itr);
   }
 
   // Append the App Paths registry entries. Do this only if we are an admin,
   // since they are always written to HKLM.
   if (IsUserAnAdmin())
-    ShellUtil::AddChromeAppPathWorkItems(chrome_exe, items.get());
+    AddChromeAppPathWorkItems(chrome_exe, items.get());
 
   // Apply all the registry changes and if there is a problem, rollback.
   if (!items->Do()) {
     LOG(ERROR) << "Failed to add Chrome to Set Program Access and Defaults";
     items->Rollback();
     return false;
   }
 
   return true;
 }
@@ skipping 10 matching lines @@
       SetAccessDefaultRegEntries(HKEY_LOCAL_MACHINE, chrome_exe))
     return ShellUtil::SUCCESS;
 
   if (!skip_if_not_admin) {
     std::wstring exe_path(file_util::GetDirectoryFromPath(chrome_exe));
     file_util::AppendToPath(&exe_path, installer_util::kSetupExe);
     if (!file_util::PathExists(exe_path)) {
       BrowserDistribution* dist = BrowserDistribution::GetDistribution();
       RegKey key(HKEY_CURRENT_USER, dist->GetUninstallRegPath().c_str());
       key.ReadValue(installer_util::kUninstallStringField, &exe_path);
-      exe_path = exe_path.substr(0, exe_path.find_first_of(L" --"));
-      TrimString(exe_path, L" \"", &exe_path);
+      CommandLine command_line(L"");
+      command_line.ParseFromString(exe_path);
+      exe_path = command_line.program();
     }
     if (file_util::PathExists(exe_path)) {
       std::wstring params(L"--");
       params.append(installer_util::switches::kRegisterChromeBrowser);
       params.append(L"=\"" + chrome_exe + L"\"");
       DWORD ret_val = ShellUtil::SUCCESS;
       InstallUtil::ExecuteExeAsAdmin(exe_path, params, &ret_val);
       if (ret_val == ShellUtil::SUCCESS)
         return ShellUtil::SUCCESS;
     }
   }
   return ShellUtil::FAILURE;
 }
 
 }  // namespace
 
 
 const wchar_t* ShellUtil::kRegDefaultIcon = L"\\DefaultIcon";
 const wchar_t* ShellUtil::kRegShellPath = L"\\shell";
 const wchar_t* ShellUtil::kRegShellOpen = L"\\shell\\open\\command";
 const wchar_t* ShellUtil::kRegStartMenuInternet =
     L"Software\\Clients\\StartMenuInternet";
 const wchar_t* ShellUtil::kRegClasses = L"Software\\Classes";
 const wchar_t* ShellUtil::kRegRegisteredApplications =
     L"Software\\RegisteredApplications";
 const wchar_t* ShellUtil::kRegVistaUrlPrefs =
     L"Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice";
+const wchar_t* ShellUtil::kAppPathsRegistryKey =
+    L"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths";
+const wchar_t* ShellUtil::kAppPathsRegistryPathName = L"Path";
 
 const wchar_t* ShellUtil::kChromeHTMLProgId = L"ChromeHTML";
 const wchar_t* ShellUtil::kChromeHTMLProgIdDesc = L"Chrome HTML";
 const wchar_t* ShellUtil::kFileAssociations[] = {L".htm", L".html", L".shtml",
     L".xht", L".xhtml", NULL};
 const wchar_t* ShellUtil::kProtocolAssociations[] = {L"ftp", L"http", L"https",
     NULL};
 const wchar_t* ShellUtil::kRegUrlProtocol = L"URL Protocol";
 
 const wchar_t* ShellUtil::kChromeExtProgId = L"ChromeExt";
@@ skipping 75 matching lines @@
   } else {
     if (FAILED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL,
                                SHGFP_TYPE_CURRENT, qlaunch)))
       return false;
     *path = qlaunch;
   }
   file_util::AppendToPath(path, kQuickLaunchPath);
   return true;
 }
 
-void ShellUtil::AddChromeAppPathWorkItems(
-    const std::wstring& chrome_exe, WorkItemList* item_list) {
-  WorkItem* create_work_item = WorkItem::CreateCreateRegKeyWorkItem(
-      HKEY_LOCAL_MACHINE, installer_util::kAppPathsRegistryKey);
-
-  item_list->AddWorkItem(create_work_item);
-
-  WorkItem* set_default_value_work_item =
-      WorkItem::CreateSetRegValueWorkItem(HKEY_LOCAL_MACHINE,
-          installer_util::kAppPathsRegistryKey,
-          installer_util::kAppPathsRegistryDefaultName,
-          chrome_exe, true);
-  item_list->AddWorkItem(set_default_value_work_item);
-
-  FilePath chrome_path(chrome_exe);
-  WorkItem* set_path_value_work_item =
-      WorkItem::CreateSetRegValueWorkItem(HKEY_LOCAL_MACHINE,
-          installer_util::kAppPathsRegistryKey,
-          installer_util::kAppPathsRegistryPathName,
-          chrome_path.DirName().value(), true);
-  item_list->AddWorkItem(set_path_value_work_item);
-}
-
 bool ShellUtil::CreateChromeDesktopShortcut(const std::wstring& chrome_exe,
                                             int shell_change,
                                             bool create_new) {
   std::wstring shortcut_name;
   if (!ShellUtil::GetChromeShortcutName(&shortcut_name))
     return false;
 
   bool ret = true;
   if (shell_change & ShellUtil::CURRENT_USER) {
     std::wstring shortcut_path;
@@ skipping 52 matching lines @@
       ret = false;
     }
   }
 
   return ret;
 }
 
 bool ShellUtil::MakeChromeDefault(int shell_change,
                                   const std::wstring chrome_exe) {
   bool ret = true;
+  // First use the new "recommended" way on Vista to make Chrome default
+  // browser.
   if (win_util::GetWinVersion() == win_util::WINVERSION_VISTA) {
     LOG(INFO) << "Registering Chrome as default browser on Vista.";
     IApplicationAssociationRegistration* pAAR;
     HRESULT hr = CoCreateInstance(CLSID_ApplicationAssociationRegistration,
         NULL, CLSCTX_INPROC, __uuidof(IApplicationAssociationRegistration),
         (void**)&pAAR);
     if (SUCCEEDED(hr)) {
       BrowserDistribution* dist = BrowserDistribution::GetDistribution();
       hr = pAAR->SetAppAsDefaultAll(dist->GetApplicationName().c_str());
       pAAR->Release();
     }
     if (!SUCCEEDED(hr)) {
       ret = false;
       LOG(ERROR) << "Could not make Chrome default browser.";
     }
-  } else {
-    // Change the default browser for current user.
-    if ((shell_change & ShellUtil::CURRENT_USER) &&
-        !CreateChromeRegKeysForXP(HKEY_CURRENT_USER, chrome_exe))
-      ret = false;
+  }
 
-    // Chrome as default browser at system level.
-    if ((shell_change & ShellUtil::SYSTEM_LEVEL) &&
-        !CreateChromeRegKeysForXP(HKEY_LOCAL_MACHINE, chrome_exe))
-      ret = false;
-  }
+  // Now use the old way to associate Chrome with supported protocols and file
+  // associations. This should not be required on Vista but since some
+  // applications still read Software\Classes\http key directly, we have to do
+  // this on Vista also.
+  // Change the default browser for current user.
+  if ((shell_change & ShellUtil::CURRENT_USER) &&
+      !BindChromeAssociations(HKEY_CURRENT_USER, chrome_exe))
+    ret = false;
+
+  // Chrome as default browser at system level.
+  if ((shell_change & ShellUtil::SYSTEM_LEVEL) &&
+      !BindChromeAssociations(HKEY_LOCAL_MACHINE, chrome_exe))
+    ret = false;
 
   // Send Windows notification event so that it can update icons for
   // file associations.
   SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
   return ret;
 }
 
 bool ShellUtil::RemoveChromeDesktopShortcut(int shell_change) {
   std::wstring shortcut_name;
   if (!ShellUtil::GetChromeShortcutName(&shortcut_name))
@@ skipping 69 matching lines @@
     return file_util::UpdateShortcutLink(chrome_exe.c_str(),      // target
                                          shortcut.c_str(),        // shortcut
                                          chrome_path.c_str(),     // working dir
                                          NULL,                    // arguments
                                          NULL,                    // description
                                          chrome_exe.c_str(),      // icon file
                                          0);                      // icon index
   }
 }