Implement the persistent metro mode setting (win8)

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/win_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "win8/delegate_execute/chrome_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
@@ skipping 13 matching lines @@
 //    CommandExecuteImpl::SetParameter
 //    CommandExecuteImpl::SetNoShowUI
 //    CommandExecuteImpl::SetSelection
 //    CommandExecuteImpl::Initialize
 //    Up to this point the code basically just gathers values passed in, like
 //    the launch scheme (or url) and the activation verb.
 // 5- Windows calls CommandExecuteImpl::Getvalue()
 //    Here we need to return AHE_IMMERSIVE or AHE_DESKTOP. That depends on:
 //    a) if run in high-integrity return AHE_DESKTOP
 //    b) if chrome is running return the AHE_ mode of chrome
-//    c) if the current process is inmmersive return AHE_IMMERSIVE
-//    d) if the protocol is file and IExecuteCommandHost::GetUIMode() is not
-//       ECHUIM_DESKTOP then return AHE_IMMERSIVE
-//    e) if none of the above return AHE_DESKTOP
-// 6- If we returned AHE_DESKTOP in step 5 then CommandExecuteImpl::Execute()
-//    is called, here we call GetLaunchMode() which:
-//    a) if chrome is running return the mode of chrome or
-//    b) return IExecuteCommandHost::GetUIMode()
-// 7- If GetLaunchMode() returns
-//    a) ECHUIM_DESKTOP we call LaunchDestopChrome() that calls ::CreateProcess
+//    c) else we return what GetLaunchMode() tells us, which is:
+//       i) if the command line --force-xxx is present return that
+//       ii) if the registry 'launch_mode' exists return that
+//       iii) if IsMachineATablet() is true return AHE_IMMERSIVE
+//       iv) else return AHE_DESKTOP
+// 6- If we returned AHE_IMMERSIVE in step 5 windows might not call us back
+//    and simply activate chrome in metro by itself, however in some cases
+//    it might proceed at step 7.
+//    As far as we know if we return AHE_DESKTOP then step 7 always happens.
+// 7- Windows calls CommandExecuteImpl::Execute()
+//    Here we call GetLaunchMode() which returns the cached answer
+//    computed at step 5c. which can be:
+//    a) ECHUIM_DESKTOP then we call LaunchDestopChrome() that calls
+//       ::CreateProcess and we exit at this point even on failure.
 //    b) else we call one of the IApplicationActivationManager activation
 //       functions depending on the parameters passed in step 4.
+//    c) If the activation returns E_APPLICATION_NOT_REGISTERED, then we fall
+//       back to launching chrome on the desktop via LaunchDestopChrome().
 //
-//  Some examples will help clarify the common cases.
+// 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.
 //
-//  I - No chrome running, taskbar icon launch:
-//      a) Scheme is 'file', Verb is 'open'
-//      b) GetValue() returns at e) step : AHE_DESKTOP
-//      c) Execute() calls LaunchDestopChrome()
-//      --> desktop chrome runs
-//  II- No chrome running, tile activation launch:
-//      a) Scheme is 'file', Verb is 'open'
-//      b) GetValue() returns at d) step : AHE_IMMERSIVE
-//      c) Windows does not call us back and just activates chrome
-//      --> metro chrome runs
-//  III- No chrome running, url link click on metro app:
-//      a) Scheme is 'http', Verb is 'open'
-//      b) Getvalue() returns at e) step : AHE_DESKTOP
-//      c) Execute() calls IApplicationActivationManager::ActivateForProtocol
-//      --> metro chrome runs
+// 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),
       launch_scheme_(INTERNET_SCHEME_DEFAULT),
       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();
@@ skipping 82 matching lines @@
       chrome_mode_ = ECHUIM_IMMERSIVE;
       *pahe = AHE_IMMERSIVE;
     } else {
       AtlTrace("Chrome [%d] is Desktop, AHE_DESKTOP\n");
       chrome_mode_ = ECHUIM_DESKTOP;
       *pahe = AHE_DESKTOP;
     }
     return S_OK;
   }
 
-  if (IsImmersiveProcess(GetCurrentProcess())) {
-    AtlTrace("Current process is inmmersive, AHE_IMMERSIVE\n");
-    *pahe = AHE_IMMERSIVE;
-    return S_OK;
-  }
-
-  if ((launch_scheme_ == INTERNET_SCHEME_FILE) &&
-      (GetLaunchMode() != ECHUIM_DESKTOP)) {
-    AtlTrace("INTERNET_SCHEME_FILE, mode != ECHUIM_DESKTOP, AHE_IMMERSIVE\n");
-    *pahe = AHE_IMMERSIVE;
-    return S_OK;
-  }
-
-  AtlTrace("Fallback is AHE_DESKTOP\n");
-  *pahe = AHE_DESKTOP;
+  EC_HOST_UI_MODE mode = GetLaunchMode();
+  *pahe = (mode == ECHUIM_DESKTOP) ? AHE_DESKTOP : AHE_IMMERSIVE;
   return S_OK;
 }
 
 STDMETHODIMP CommandExecuteImpl::Execute() {
   AtlTrace("In %hs\n", __FUNCTION__);
 
   if (integrity_level_ == base::HIGH_INTEGRITY)
     return LaunchDesktopChrome();
 
   EC_HOST_UI_MODE mode = GetLaunchMode();
@@ skipping 187 matching lines @@
     CloseHandle(proc_info.hProcess);
     CloseHandle(proc_info.hThread);
   } else {
     AtlTrace("Process launch failed, error %d\n", ::GetLastError());
   }
 
   return S_OK;
 }
 
 EC_HOST_UI_MODE CommandExecuteImpl::GetLaunchMode() {
-  // We are to return chrome's mode if chrome exists else we query our embedder
-  // IServiceProvider and learn the mode from them.
+  // 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", "Inmmersive", "SysLauncher", "??" };
+  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)) {
     launch_mode = ECHUIM_IMMERSIVE;
     launch_mode_determined = true;
+    parameters_.clear();
   } else if (parameters_ == ASCIIToWide(switches::kForceDesktop)) {
     launch_mode = ECHUIM_DESKTOP;
     launch_mode_determined = true;
+    parameters_.clear();
+  }
+
+  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",

[grt (UTC plus 2), 2012/09/14 01:13:42]

in this case, key_result is a last-error code.  i think they're base-10 in their
natural habitat (winerror.h), so i'd go with %u.

+             chrome::kMetroRegistryPath,
+             key_result);

[grt (UTC plus 2), 2012/09/14 01:13:42]

nit: move up to previous line

+    if (!launch_mode_determined) {
+      launch_mode = ECHUIM_DESKTOP;
+      launch_mode_determined = true;
+    }
+    return launch_mode;
   }
 
   if (launch_mode_determined) {
-    parameters_.clear();
-    AtlTrace("Launch mode forced to %s\n", modes[launch_mode]);
+    AtlTrace("Launch mode forced by cmdline to %s\n", modes[launch_mode]);
+    reg_key.WriteValue(chrome::kLaunchModeValue,
+                       static_cast<DWORD>(launch_mode));
     return launch_mode;
   }
 
-  CComPtr<IExecuteCommandHost> host;
-  CComQIPtr<IServiceProvider> service_provider = m_spUnkSite;
-  if (service_provider) {
-    service_provider->QueryService(IID_IExecuteCommandHost, &host);
-    if (host) {
-      host->GetUIMode(&launch_mode);
-    } else {
-      AtlTrace("Failed to get IID_IExecuteCommandHost. Assuming desktop\n");
-    }
+  DWORD reg_value;
+  if (reg_key.ReadValueDW(chrome::kLaunchModeValue,
+                          &reg_value) != ERROR_SUCCESS) {
+    launch_mode = base::win::IsMachineATablet() ?
+                      ECHUIM_IMMERSIVE : ECHUIM_DESKTOP;
+    AtlTrace("Launch mode forced by heuristics to %s\n", modes[launch_mode]);
+  } else if (reg_value >= ECHUIM_SYSTEM_LAUNCHER) {
+    AtlTrace("Invalid registry launch mode value %u\n", reg_value);
+    launch_mode = ECHUIM_DESKTOP;
   } else {
-      AtlTrace("Failed to get IServiceProvider. Assuming desktop mode\n");
+    AtlTrace("Launch mode forced by registry to %s\n", modes[launch_mode]);
+    launch_mode = static_cast<EC_HOST_UI_MODE>(reg_value);
   }
-  AtlTrace("Launch mode is %s\n", modes[launch_mode]);
+
   launch_mode_determined = true;
   return launch_mode;
 }