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 13 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;
 }
 
+// If we are running on XP (no protected mode) or in a high-integrity process,
+// we can invoke the installer directly. If not, we will have to go via the
+// ProcessLauncher.
+bool CanLaunchDirectly() {
+  if (base::win::GetVersion() < base::win::VERSION_VISTA)
+    return true;
+
+  base::IntegrityLevel integrity_level = base::INTEGRITY_UNKNOWN;
+  if (!base::GetProcessIntegrityLevel(base::GetCurrentProcessHandle(),
+                                      &integrity_level)) {
+    DLOG(ERROR) << "Failed to determine process integrity level.";
+    return false;
+  }
+
+  return integrity_level == base::HIGH_INTEGRITY;
+}

[erikwright (departed), 2011/01/24 17:17:14]

By "Done", I meant, I added an implementation comment to the function definition
that hopefully makes it clear why this is HIGH_INTEGRITY.

+
 // 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))

[robertshield, 2011/01/24 15:08:42]

This appears to wait for 5 seconds whereas chrome_launcher.exe which is called
does an INFINITE wait on the elevated command. 
This means that when failing here, we don't know whether or not the elevated
command completed.

[erikwright (departed), 2011/01/24 17:17:14]

Yes. chrome_launcher will live as long as the elevated command. But here, we
only wait 5 seconds. The reason is that, essentially, we are blocking the UI.
The near term enhancement would be to make it asynchronous.

It is certainly possible that, after timing out, the installer will have
completed. In that case, the impact is that this browser's state will not
change, but future processes will reflect the change.

Again, this preserves the existing behaviour, which I think is acceptable for
now. This can probably be fixed in branch.

     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 95 matching lines @@
 
 void RegistryReadyModeState::PermanentlyDeclineChromeFrame() {
   if (LaunchAndCheckCommand(google_update::kRegCFOptOutCmdField))
     RefreshStateAndNotify();
 }
 
 void RegistryReadyModeState::AcceptChromeFrame() {
   if (LaunchAndCheckCommand(google_update::kRegCFOptInCmdField))
     NotifyObserver();
 }