Prefix Chrome switches with the switch prefix.

win8/delegate_execute/command_execute_impl.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.
 // Implementation of the CommandExecuteImpl class which implements the
 // IExecuteCommand and related interfaces for handling ShellExecute based
 // launches of the Chrome browser.
 
 #include "win8/delegate_execute/command_execute_impl.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_handle.h"
+#include "base/win/scoped_process_information.h"
 #include "base/win/win_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/util_constants.h"
 #include "win8/delegate_execute/chrome_util.h"
+#include "win8/delegate_execute/delegate_execute_util.h"
 
 // CommandExecuteImpl is resposible for activating chrome in Windows 8. The
 // flow is complicated and this tries to highlight the important events.
 // The current approach is to have a single instance of chrome either
 // running in desktop or metro mode. If there is no current instance then
 // the desktop shortcut launches desktop chrome and the metro tile or search
 // charm launches metro chrome.
 // If chrome is running then focus/activation is given to the existing one
 // regarless of what launch point the user used.
 //
@@ skipping 37 matching lines @@
 //
 // Note that if a command line --force-xxx is present we write that launch mode
 // in the registry so next time the logic reaches 5c-ii it will use the same
 // mode again.
 //
 // Also note that if we are not the default browser and IsMachineATablet()
 // returns true, launching chrome can go all the way to 7c, which might be
 // a slow way to start chrome.
 //
 CommandExecuteImpl::CommandExecuteImpl()
-    : integrity_level_(base::INTEGRITY_UNKNOWN),
+    : parameters_(CommandLine::NO_PROGRAM),
       launch_scheme_(INTERNET_SCHEME_DEFAULT),
+      integrity_level_(base::INTEGRITY_UNKNOWN),
       chrome_mode_(ECHUIM_SYSTEM_LAUNCHER) {
   memset(&start_info_, 0, sizeof(start_info_));
   start_info_.cb = sizeof(start_info_);
   // We need to query the user data dir of chrome so we need chrome's
   // path provider.
   chrome::RegisterPathProvider();
 }
 
 // CommandExecuteImpl
 STDMETHODIMP CommandExecuteImpl::SetKeyState(DWORD key_state) {
   AtlTrace("In %hs\n", __FUNCTION__);
   return S_OK;
 }
 
 STDMETHODIMP CommandExecuteImpl::SetParameters(LPCWSTR params) {
   AtlTrace("In %hs [%S]\n", __FUNCTION__, params);
-  if (params) {
-    parameters_ = params;
-  }
+  parameters_ = delegate_execute::CommandLineFromParameters(params);
   return S_OK;
 }
 
 STDMETHODIMP CommandExecuteImpl::SetPosition(POINT pt) {
   AtlTrace("In %hs\n", __FUNCTION__);
   return S_OK;
 }
 
 STDMETHODIMP CommandExecuteImpl::SetShowWindow(int show) {
   AtlTrace("In %hs  show=%d\n", __FUNCTION__, show);
@@ skipping 235 matching lines @@
       // chrome is the default we should treat it as a parameter to be passed
       // to chrome.
       if (display_name.find(installer::kChromeExe) != string16::npos)
         display_name.clear();
       break;
 
     default:
       break;
   }
 
-  string16 command_line = L"\"";
-  command_line += chrome_exe_.value();
-  command_line += L"\"";
-
-  if (!parameters_.empty()) {
-    AtlTrace("Adding parameters %ls to command line\n", parameters_.c_str());
-    command_line += L" ";
-    command_line += parameters_.c_str();
-  }
-
-  if (!display_name.empty()) {
-    command_line += L" -- ";
-    command_line += display_name;
-  }
+  CommandLine chrome(
+      delegate_execute::MakeChromeCommandLine(chrome_exe_, parameters_,
+                                              display_name));
+  string16 command_line(chrome.GetCommandLineString());
 
   AtlTrace("Formatted command line is %ls\n", command_line.c_str());
 
-  PROCESS_INFORMATION proc_info = {0};
-  BOOL ret = CreateProcess(NULL, const_cast<LPWSTR>(command_line.c_str()),
+  base::win::ScopedProcessInformation proc_info;
+  BOOL ret = CreateProcess(chrome_exe_.value().c_str(),
+                           const_cast<LPWSTR>(command_line.c_str()),
                            NULL, NULL, FALSE, 0, NULL, NULL, &start_info_,
-                           &proc_info);
+                           proc_info.Receive());
   if (ret) {
-    AtlTrace("Process id is %d\n", proc_info.dwProcessId);
-    AllowSetForegroundWindow(proc_info.dwProcessId);
-    CloseHandle(proc_info.hProcess);
-    CloseHandle(proc_info.hThread);
+    AtlTrace("Process id is %d\n", proc_info.process_id());
+    AllowSetForegroundWindow(proc_info.process_id());
   } else {
     AtlTrace("Process launch failed, error %d\n", ::GetLastError());
   }
 
   return S_OK;
 }
 
 EC_HOST_UI_MODE CommandExecuteImpl::GetLaunchMode() {
   // See the header file for an explanation of the mode selection logic.
   static bool launch_mode_determined = false;
   static EC_HOST_UI_MODE launch_mode = ECHUIM_DESKTOP;
 
   const char* modes[] = { "Desktop", "Immersive", "SysLauncher", "??" };
 
   if (launch_mode_determined)
     return launch_mode;
 
   if (chrome_mode_ != ECHUIM_SYSTEM_LAUNCHER) {
     launch_mode = chrome_mode_;
     AtlTrace("Launch mode is that of chrome, %s\n", modes[launch_mode]);
     launch_mode_determined = true;
     return launch_mode;
   }
 
-  if (parameters_ == ASCIIToWide(switches::kForceImmersive)) {
+  if (parameters_.HasSwitch(switches::kForceImmersive)) {
     launch_mode = ECHUIM_IMMERSIVE;
     launch_mode_determined = true;
-    parameters_.clear();
-  } else if (parameters_ == ASCIIToWide(switches::kForceDesktop)) {
+    parameters_ = CommandLine(CommandLine::NO_PROGRAM);
+  } else if (parameters_.HasSwitch(switches::kForceDesktop)) {
     launch_mode = ECHUIM_DESKTOP;
     launch_mode_determined = true;
-    parameters_.clear();
+    parameters_ = CommandLine(CommandLine::NO_PROGRAM);
   }
 
   base::win::RegKey reg_key;
   LONG key_result = reg_key.Create(HKEY_CURRENT_USER,
                                    chrome::kMetroRegistryPath,
                                    KEY_ALL_ACCESS);
   if (key_result != ERROR_SUCCESS) {
     AtlTrace("Failed to open HKCU %ls key, error 0x%x\n",
              chrome::kMetroRegistryPath,
              key_result);
@@ skipping 21 matching lines @@
     AtlTrace("Invalid registry launch mode value %u\n", reg_value);
     launch_mode = ECHUIM_DESKTOP;
   } else {
     AtlTrace("Launch mode forced by registry to %s\n", modes[launch_mode]);
     launch_mode = static_cast<EC_HOST_UI_MODE>(reg_value);
   }
 
   launch_mode_determined = true;
   return launch_mode;
 }