Make delegate_execute GetLaunchMode() check for default browser.

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 <shlguid.h>
@@ skipping 98 matching lines @@
 
 // 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.
 //
-// The general flow when chrome is the default browser is as follows:
+// The general flow for activation is as follows:
 //
 // 1- User interacts with launch point (icon, tile, search, shellexec, etc)
 // 2- Windows finds the appid for launch item and resolves it to chrome
 // 3- Windows activates CommandExecuteImpl inside a surrogate process
 // 4- Windows calls the following sequence of entry points:
 //    CommandExecuteImpl::SetShowWindow
 //    CommandExecuteImpl::SetPosition
 //    CommandExecuteImpl::SetDirectory
 //    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
+//    a) if run in high-integrity return AHE_DESKTOP.
 //    b) 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) else return AHE_DESKTOP
+//       i) if chrome is not the default browser, return AHE_DESKTOP
+//       ii) if the command line --force-xxx is present return that
+//       iii) if the registry 'launch_mode' exists return that
+//       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 LaunchDesktopChrome() 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().
+//       back to launching chrome on the desktop via LaunchDestopChrome().  Note
+//       that this case can lead to strange behavior, because at this point we
+//       have pre-launched the browser with --silent-launch --viewer-connect.
+//       E_APPLICATION_NOT_REGISTERED is always returned if Chrome is not the
+//       default browser (this case will have already been checked for by
+//       GetLaunchMode() and AHE_DESKTOP returned), but we don't know if it can
+//       be returned for other reasons.
 //
 // 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.
 //
 CommandExecuteImpl::CommandExecuteImpl()
     : parameters_(CommandLine::NO_PROGRAM),
       launch_scheme_(INTERNET_SCHEME_DEFAULT),
       integrity_level_(base::INTEGRITY_UNKNOWN) {
   memset(&start_info_, 0, sizeof(start_info_));
@@ skipping 38 matching lines @@
 
 STDMETHODIMP CommandExecuteImpl::GetValue(enum AHE_TYPE* pahe) {
   if (!GetLaunchScheme(&display_name_, &launch_scheme_)) {
     AtlTrace("Failed to get scheme, E_FAIL\n");
     return E_FAIL;
   }
 
   EC_HOST_UI_MODE mode = GetLaunchMode();
   *pahe = (mode == ECHUIM_DESKTOP) ? AHE_DESKTOP : AHE_IMMERSIVE;
 
+  // If we're going to return AHE_IMMERSIVE, then both the browser process and
+  // the metro viewer need to launch and connect before the user can start
+  // browsing.  However we must not launch the metro viewer until we get a
+  // call to CommandExecuteImpl::Execute().  If we wait until then to launch
+  // the browser process as well, it will appear laggy while they connect to
+  // each other, so we pre-launch the browser process now.
   if (*pahe == AHE_IMMERSIVE && verb_ != win8::kMetroViewerConnectVerb)
     LaunchChromeBrowserProcess();
   return S_OK;
 }
 
 STDMETHODIMP CommandExecuteImpl::Execute() {
   AtlTrace("In %hs\n", __FUNCTION__);
 
   if (integrity_level_ == base::HIGH_INTEGRITY)
     return LaunchDesktopChrome();
@@ skipping 186 matching lines @@
   if (launch_mode_determined)
     return launch_mode;
 
   if (integrity_level_ == base::HIGH_INTEGRITY) {
     // Metro mode apps don't work in high integrity mode.
     AtlTrace("High integrity: launching in desktop mode\n");
     launch_mode = ECHUIM_DESKTOP;
     launch_mode_determined = true;
     return launch_mode;
   }
+
+  base::FilePath chrome_exe;
+  if (!FindChromeExe(&chrome_exe) ||
+      ShellUtil::GetChromeDefaultStateFromPath(chrome_exe) !=
+          ShellUtil::DefaultState::IS_DEFAULT) {
+    AtlTrace("Chrome is not default: launching in desktop mode\n");
+    launch_mode = ECHUIM_DESKTOP;
+    launch_mode_determined = true;
+    return launch_mode;
+  }
+
   if (GetAsyncKeyState(VK_SHIFT) && GetAsyncKeyState(VK_F11)) {
     AtlTrace("Hotkey: launching in immersive mode\n");
     launch_mode = ECHUIM_IMMERSIVE;
     launch_mode_determined = true;
     return launch_mode;
   }
 
   // From here on, if we can, we will write the outcome
   // of this function to the registry.
   if (parameters_.HasSwitch(switches::kForceImmersive)) {
@@ skipping 40 matching lines @@
     AtlTrace("Invalid registry launch mode value %u\n", reg_value);
     launch_mode = ECHUIM_DESKTOP;
   } else {
     launch_mode = static_cast<EC_HOST_UI_MODE>(reg_value);
     AtlTrace("Launch mode forced by registry to %s\n", modes[launch_mode]);
   }
 
   launch_mode_determined = true;
   return launch_mode;
 }