Be explicit about target type in platform_util::OpenItem()

ui/base/win/shell.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.
 
 #include "ui/base/win/shell.h"
 
 #include <dwmapi.h>
 #include <shlobj.h>  // Must be before propkey.
 #include <propkey.h>
 #include <shellapi.h>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/native_library.h"
 #include "base/strings/string_util.h"
+#include "base/threading/thread_restrictions.h"
 #include "base/win/metro.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "ui/base/ui_base_switches.h"
 
 namespace ui {
 namespace win {
 
 namespace {
 
-// Show the Windows "Open With" dialog box to ask the user to pick an app to
-// open the file with.
-bool OpenItemWithExternalApp(const base::string16& full_path) {
-  SHELLEXECUTEINFO sei = { sizeof(sei) };
-  sei.fMask = SEE_MASK_FLAG_DDEWAIT;
+// Default ShellExecuteEx flags used with the "openas" verb.
+//
+// SEE_MASK_NOASYNC is specified so that ShellExecuteEx can be invoked from a
+// thread whose message loop may not wait around long enough for the
+// asynchronous tasks initiated by ShellExecuteEx to complete. Using this flag
+// causes ShellExecuteEx() to block until these tasks complete.
+const DWORD kDefaultOpenAsFlags = SEE_MASK_NOASYNC;
+
+// Default ShellExecuteEx flags used with the "explore", "open" or default verb.
+//
+// See kDefaultOpenFlags for description SEE_MASK_NOASYNC flag.
+// SEE_MASK_FLAG_NO_UI is used to suppress any error message boxes that might be
+// displayed if there is an error in opening the file. Failure in invoking the
+// "open" actions result in invocation of the "saveas" verb, making the error
+// dialog superfluous.
+const DWORD kDefaultOpenFlags = SEE_MASK_NOASYNC | SEE_MASK_FLAG_NO_UI;
+
+// Invokes ShellExecuteExW() with the given parameters.
+DWORD InvokeShellExecute(const base::string16 path,
+                         const base::string16 directory,
+                         const base::string16 args,
+                         const base::string16 verb,
+                         DWORD mask) {
+  base::ThreadRestrictions::AssertIOAllowed();
+  SHELLEXECUTEINFO sei = {sizeof(sei)};
+  sei.fMask = mask;
   sei.nShow = SW_SHOWNORMAL;
-  sei.lpVerb = L"openas";
-  sei.lpFile = full_path.c_str();
-  return (TRUE == ::ShellExecuteExW(&sei));
+  if (!verb.empty())
+    sei.lpVerb = verb.c_str();
+  sei.lpFile = path.c_str();
+  if (!directory.empty())
+    sei.lpDirectory = directory.c_str();
+  if (!args.empty())
+    sei.lpParameters = args.c_str();
+  return ::ShellExecuteExW(&sei) ? ERROR_SUCCESS : ::GetLastError();
 }
 
 }  // namespace
 
 bool OpenAnyViaShell(const base::string16& full_path,
                      const base::string16& directory,
                      const base::string16& args,
                      DWORD mask) {
-  SHELLEXECUTEINFO sei = { sizeof(sei) };
-  sei.fMask = mask;
-  sei.nShow = SW_SHOWNORMAL;
-  sei.lpFile = full_path.c_str();
-  sei.lpDirectory = directory.c_str();
-  if (!args.empty())
-    sei.lpParameters = args.c_str();
-
-  if (::ShellExecuteExW(&sei))
+  DWORD open_result =
+      InvokeShellExecute(full_path, directory, args, base::string16(), mask);
+  if (open_result == ERROR_SUCCESS)
     return true;
-  if (::GetLastError() == ERROR_NO_ASSOCIATION)
-    return OpenItemWithExternalApp(full_path);
+  // Show the Windows "Open With" dialog box to ask the user to pick an app to
+  // open the file with. Note that we are not forwarding |args| for the "openas"
+  // call since the target application is nolonger known at this point.
+  if (open_result == ERROR_NO_ASSOCIATION)
+    return InvokeShellExecute(full_path, directory, base::string16(), L"openas",
+                              kDefaultOpenAsFlags) == ERROR_SUCCESS;
   return false;
 }
 
-bool OpenItemViaShell(const base::FilePath& full_path) {
+bool OpenFileViaShell(const base::FilePath& full_path) {
   return OpenAnyViaShell(full_path.value(), full_path.DirName().value(),
-                         base::string16(), 0);
+                         base::string16(), kDefaultOpenFlags);
+}
+
+bool OpenFolderViaShell(const base::FilePath& full_path) {
+  // Only invoke the "explore" verb. This will fail if |full_path| is not a
+  // directory. The resulting error does not cause UI due to the
+  // SEE_MASK_FLAG_NO_UI flag in kDefaultOpenFlags.
+  return InvokeShellExecute(full_path.value(), full_path.value(),
+                            base::string16(), L"explore",
+                            kDefaultOpenFlags) == ERROR_SUCCESS;
 }
 
 bool PreventWindowFromPinning(HWND hwnd) {
   // This functionality is only available on Win7+. It also doesn't make sense
   // to do this for Chrome Metro.
   if (base::win::GetVersion() < base::win::VERSION_WIN7 ||
       base::win::IsMetroProcess())
     return false;
   base::win::ScopedComPtr<IPropertyStore> pps;
   HRESULT result = SHGetPropertyStoreForWindow(
@@ skipping 79 matching lines @@
   // at the same feature level. See bug 426573.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return false;
   // If composition is not enabled, we behave like on XP.
   BOOL enabled = FALSE;
   return SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled;
 }
 
 }  // namespace win
 }  // namespace ui