Give SxS distribution its own registration GUIDs.

win8/delegate_execute/chrome_util.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.
 
 #include "win8/delegate_execute/chrome_util.h"
 
 #include <windows.h>
 #include <atlbase.h>
 #include <shlobj.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/md5.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
+#include "chrome/installer/util/browser_distribution.h"
+#include "chrome/installer/util/install_util.h"
+#include "chrome/installer/util/util_constants.h"
 #include "google_update/google_update_idl.h"
 
 namespace {
 
 #if defined(GOOGLE_CHROME_BUILD)
-const wchar_t kAppUserModelId[] = L"Chrome";
-#else  // GOOGLE_CHROME_BUILD
-const wchar_t kAppUserModelId[] = L"Chromium";
-#endif  // GOOGLE_CHROME_BUILD
-
-#if defined(GOOGLE_CHROME_BUILD)
 
 // TODO(grt): These constants live in installer_util.  Consider moving them
 // into common_constants to allow for reuse.
 const base::FilePath::CharType kNewChromeExe[] =
     FILE_PATH_LITERAL("new_chrome.exe");
 const wchar_t kRenameCommandValue[] = L"cmd";
-const wchar_t kChromeAppGuid[] = L"{8A69D345-D564-463c-AFF1-A69D9E530F96}";
-const wchar_t kRegPathChromeClient[] =
-    L"Software\\Google\\Update\\Clients\\"
-    L"{8A69D345-D564-463c-AFF1-A69D9E530F96}";
-const int kExitCodeRenameSuccessful = 23;
+const wchar_t kRegPathChromeClientBase[] =
+    L"Software\\Google\\Update\\Clients\\";
 
 // Returns the name of the global event used to detect if |chrome_exe| is in
 // use by a browser process.
 // TODO(grt): Move this somewhere central so it can be used by both this
 // IsBrowserRunning (below) and IsBrowserAlreadyRunning (browser_util_win.cc).
 string16 GetEventName(const base::FilePath& chrome_exe) {
   static wchar_t const kEventPrefix[] = L"Global\\";
   const size_t prefix_len = arraysize(kEventPrefix) - 1;
   string16 name;
   name.reserve(prefix_len + chrome_exe.value().size());
@@ skipping 22 matching lines @@
 
 // Returns true if the file new_chrome.exe exists in the same directory as
 // |chrome_exe|.
 bool NewChromeExeExists(const base::FilePath& chrome_exe) {
   base::FilePath new_chrome_exe(chrome_exe.DirName().Append(kNewChromeExe));
   return base::PathExists(new_chrome_exe);
 }
 
 bool GetUpdateCommand(bool is_per_user, string16* update_command) {
   const HKEY root = is_per_user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
-  base::win::RegKey key(root, kRegPathChromeClient, KEY_QUERY_VALUE);
+  BrowserDistribution* dist = BrowserDistribution::GetDistribution();

[gab, 2013/09/10 19:08:57]

Did you make sure that GetDistribution() returns the proper distribution from
delegate_execute.exe (I'm guessing yes, but just making sure!)?

+  string16 reg_path_chrome_client = kRegPathChromeClientBase;
+  reg_path_chrome_client.append(dist->GetAppGuid());
+  base::win::RegKey key(root, reg_path_chrome_client.c_str(), KEY_QUERY_VALUE);
 
   return key.ReadValue(kRenameCommandValue, update_command) == ERROR_SUCCESS;
 }
 
 #endif  // GOOGLE_CHROME_BUILD
 
 // TODO(grt): This code also lives in installer_util.  Refactor for reuse.
 bool IsPerUserInstall(const base::FilePath& chrome_exe) {
   wchar_t program_files_path[MAX_PATH] = {0};
   if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PROGRAM_FILES, NULL,
                                 SHGFP_TYPE_CURRENT, program_files_path))) {
     return !StartsWith(chrome_exe.value().c_str(), program_files_path, false);
   } else {
     NOTREACHED();
   }
   return true;
 }
 
 // TODO(gab): This code also lives in shell_util. Refactor for reuse.
 string16 ByteArrayToBase32(const uint8* bytes, size_t size) {

[gab, 2013/09/10 19:08:57]

Can remove this method now.

   static const char kEncoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 
   // Eliminate special cases first.
   if (size == 0) {
     return string16();
   } else if (size == 1) {
     string16 ret;
     ret.push_back(kEncoding[(bytes[0] & 0xf8) >> 3]);
     ret.push_back(kEncoding[(bytes[0] & 0x07) << 2]);
     return ret;
@@ skipping 31 matching lines @@
   }
 
   if (ret.length() != encoded_length) {
     AtlTrace("%hs. Encoding doesn't match expected length.\n", __FUNCTION__);
     return string16();
   }
   return ret;
 }
 
 // TODO(gab): This code also lives in shell_util. Refactor for reuse.
 bool GetUserSpecificRegistrySuffix(string16* suffix) {

[gab, 2013/09/10 19:08:57]

Can remove this method now.

   string16 user_sid;
   if (!base::win::GetUserSidString(&user_sid)) {
     AtlTrace("%hs. GetUserSidString failed.\n", __FUNCTION__);
     return false;
   }
   COMPILE_ASSERT(sizeof(base::MD5Digest) == 16, size_of_MD5_not_as_expected_);
   base::MD5Digest md5_digest;
   std::string user_sid_ascii(UTF16ToASCII(user_sid));
   base::MD5Sum(user_sid_ascii.c_str(), user_sid_ascii.length(), &md5_digest);
   const string16 base32_md5(
@@ skipping 19 matching lines @@
 
 void UpdateChromeIfNeeded(const base::FilePath& chrome_exe) {
 #if defined(GOOGLE_CHROME_BUILD)
   // Nothing to do if a browser is already running or if there's no
   // new_chrome.exe.
   if (IsBrowserRunning(chrome_exe) || !NewChromeExeExists(chrome_exe))
     return;
 
   base::ProcessHandle process_handle = base::kNullProcessHandle;
 
   if (IsPerUserInstall(chrome_exe)) {

[gab, 2013/09/10 19:08:57]

This can now use InstallUtil::IsPerUserInstall().

And you can subsequently remove IsPerUserInstall() in this file.

     // Read the update command from the registry.
     string16 update_command;
     if (!GetUpdateCommand(true, &update_command)) {
       AtlTrace("%hs. Failed to read update command from registry.\n",
                __FUNCTION__);
     } else {
       // Run the update command.
       base::LaunchOptions launch_options;
       launch_options.start_hidden = true;
       if (!base::LaunchProcess(update_command, launch_options,
                                &process_handle)) {
         AtlTrace("%hs. Failed to launch command to finalize update; "
                  "error %u.\n", __FUNCTION__, ::GetLastError());
         process_handle = base::kNullProcessHandle;
       }
     }
   } else {
     // Run the update command via Google Update.
     HRESULT hr = S_OK;
     base::win::ScopedComPtr<IProcessLauncher> process_launcher;
     hr = process_launcher.CreateInstance(__uuidof(ProcessLauncherClass));
     if (FAILED(hr)) {
       AtlTrace("%hs. Failed to Create ProcessLauncher; hr=0x%X.\n",
                __FUNCTION__, hr);
     } else {
       ULONG_PTR handle = 0;
+      BrowserDistribution* dist = BrowserDistribution::GetDistribution();
       hr = process_launcher->LaunchCmdElevated(
-          kChromeAppGuid, kRenameCommandValue, GetCurrentProcessId(), &handle);
+          dist->GetAppGuid().c_str(), kRenameCommandValue,
+          GetCurrentProcessId(), &handle);
       if (FAILED(hr)) {
         AtlTrace("%hs. Failed to launch command to finalize update; "
                  "hr=0x%X.\n", __FUNCTION__, hr);
       } else {
         process_handle = reinterpret_cast<base::ProcessHandle>(handle);
       }
     }
   }
 
   // Wait for the update to complete and report the results.
   if (process_handle != base::kNullProcessHandle) {
     int exit_code = 0;
     // WaitForExitCode will close the handle in all cases.
     if (!base::WaitForExitCode(process_handle, &exit_code)) {
       AtlTrace("%hs. Failed to get result when finalizing update.\n",
                __FUNCTION__);
-    } else if (exit_code != kExitCodeRenameSuccessful) {
+    } else if (exit_code != installer::RENAME_SUCCESSFUL) {
       AtlTrace("%hs. Failed to finalize update with exit code %d.\n",
                __FUNCTION__, exit_code);
     } else {
       AtlTrace("%hs. Finalized pending update.\n", __FUNCTION__);
     }
   }
 #endif
 }
 
-// TODO(gab): This code also lives in shell_util. Refactor for reuse.
-string16 GetAppId(const base::FilePath& chrome_exe) {
-  string16 app_id(kAppUserModelId);
-  string16 suffix;
-  if (IsPerUserInstall(chrome_exe) &&
-      !GetUserSpecificRegistrySuffix(&suffix)) {
-    AtlTrace("%hs. GetUserSpecificRegistrySuffix failed.\n",
-              __FUNCTION__);
-  }
-  return app_id.append(suffix);
-}
-
 }  // delegate_execute