When changing Ready Mode state from within an IE process, use chrome_launcher...

chrome_frame/ready_mode/internal/registry_ready_mode_state.cc

 // Copyright (c) 2011 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_frame/ready_mode/internal/registry_ready_mode_state.h"
 
 #include <windows.h>
 
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/task.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
+#include "base/win/windows_version.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/util_constants.h"
+#include "chrome_frame/chrome_launcher_utils.h"
 #include "chrome_frame/ready_mode/ready_mode.h"
-#include "google_update_idl.h"  // NOLINT
 
 namespace {
 
 // Looks up a command entry in the registry and attempts to execute it directly.
 // Returns the new process handle, which the caller is responsible for closing,
 // or NULL upon failure.
 HANDLE LaunchCommandDirectly(const std::wstring& command_field) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring version_key_name(dist->GetVersionKey());
 
@@ skipping 11 matching lines @@
       }
     }
   }
   return NULL;
 }
 
 // Attempts to launch a command using the ProcessLauncher. Returns a handle to
 // the launched process, which the caller is responsible for closing, or NULL
 // upon failure.
 HANDLE LaunchCommandViaProcessLauncher(const std::wstring& command_field) {
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
+  HANDLE launched_process = NULL;
 
-  base::win::ScopedComPtr<IProcessLauncher> ipl;
-  HRESULT hr = ipl.CreateInstance(__uuidof(ProcessLauncherClass));
+  scoped_ptr<CommandLine> command_line(
+      chrome_launcher::CreateUpdateCommandLine(command_field));
 
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to instantiate IProcessLauncher: "
-                << base::StringPrintf("0x%08x", hr);
-  } else {
-    ULONG_PTR phandle = NULL;
-    DWORD id = GetCurrentProcessId();
+  if (command_line != NULL)
+    base::LaunchApp(*command_line, false, true, &launched_process);
 
-    hr = ipl->LaunchCmdElevated(dist->GetAppGuid().c_str(),
-                                command_field.c_str(), id, &phandle);
-    if (SUCCEEDED(hr))
-      return reinterpret_cast<HANDLE>(phandle);
-
-    DLOG(ERROR) << "Failed to invoke IProcessLauncher::LaunchCmdElevated: "
-                << base::StringPrintf("0x%08x", hr);
-  }
-
-  return NULL;
+  return launched_process;
 }
 
 // Waits for the provided process to exit, and verifies that its exit code
 // corresponds to one of the known "success" codes for the installer. If the
 // exit code cannot be retrieved, or if it signals failure, returns false.
 bool CheckProcessExitCode(HANDLE handle) {
   // TODO(erikwright): Use RegisterWaitForSingleObject to wait
   // asynchronously.
   DWORD wait_result = WaitForSingleObject(handle, 5000);  // (ms)
 
@@ skipping 19 matching lines @@
 
   if (wait_result == WAIT_ABANDONED)
     DLOG(ERROR) << "Unexpeced WAIT_ABANDONED while waiting on child process.";
 
   if (wait_result == WAIT_TIMEOUT)
     DLOG(ERROR) << "Timeout while waiting on child process.";
 
   return false;
 }
 
+bool CanLaunchDirectly() {
+  if (base::win::GetVersion() < base::win::VERSION_VISTA)
+    return true;
+
+  base::IntegrityLevel integrity_level;

[amit, 2011/01/24 05:54:50]

= 0 or some invalid value?

[erikwright (departed), 2011/01/24 06:21:00]

Done.

+  if (!base::GetProcessIntegrityLevel(base::GetCurrentProcessHandle(),
+                                      &integrity_level)) {
+    DLOG(ERROR) << "Failed to determine process integrity level.";
+    return false;
+  }
+
+  return integrity_level == base::HIGH_INTEGRITY;

[amit, 2011/01/24 05:54:50]

Shouldn't this check be for MEDIUM_INTEGRITY (in order for launching from low to
medium integrity)?

[erikwright (departed), 2011/01/24 06:21:00]

Done.

+}
+
 // Attempts to launch the specified command either directly or via the
 // ProcessLauncher. Returns true if the command is launched and returns a
 // success code.
 bool LaunchAndCheckCommand(const std::wstring& command_field) {
   base::win::ScopedHandle handle;
 
-  handle.Set(LaunchCommandDirectly(command_field));
+  if (CanLaunchDirectly())
+    handle.Set(LaunchCommandDirectly(command_field));
+  else
+    handle.Set(LaunchCommandViaProcessLauncher(command_field));
+
   if (handle.IsValid() && CheckProcessExitCode(handle))
     return true;
 
-  handle.Set(LaunchCommandViaProcessLauncher(command_field));
-  if (handle.IsValid() && CheckProcessExitCode(handle))
-    return true;
-
   DLOG(ERROR) << "Command " << command_field << " could not be launched.";
   return false;
 }
 
 }  // namespace
 
 RegistryReadyModeState::RegistryReadyModeState(
     const std::wstring& key_name, base::TimeDelta temporary_decline_duration,
     Observer* observer)
     : key_name_(key_name),
@@ skipping 105 matching lines @@
 
 void RegistryReadyModeState::PermanentlyDeclineChromeFrame() {
   if (LaunchAndCheckCommand(google_update::kRegCFOptOutCmdField))
     RefreshStateAndNotify();
 }
 
 void RegistryReadyModeState::AcceptChromeFrame() {
   if (LaunchAndCheckCommand(google_update::kRegCFOptInCmdField))
     NotifyObserver();
 }