base/win/shortcut.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/win/shortcut.h"
   6
   7 #include <shellapi.h>
   8 #include <shlobj.h>
   9 #include <propkey.h>
  10
  11 #include "base/file_util.h"
  12 #include "base/threading/thread_restrictions.h"
  13 #include "base/win/scoped_comptr.h"
  14 #include "base/win/scoped_propvariant.h"
  15 #include "base/win/win_util.h"
  16 #include "base/win/windows_version.h"
  17
  18 namespace base {
  19 namespace win {
  20
  21 namespace {
  22
  23 // Initializes |i_shell_link| and |i_persist_file| (releasing them first if they
  24 // are already initialized).
  25 // If |shortcut| is not NULL, loads |shortcut| into |i_persist_file|.
  26 // If any of the above steps fail, both |i_shell_link| and |i_persist_file| will
  27 // be released.
  28 void InitializeShortcutInterfaces(
  29     const wchar_t* shortcut,
  30     ScopedComPtr<IShellLink>* i_shell_link,
  31     ScopedComPtr<IPersistFile>* i_persist_file) {
  32   i_shell_link->Release();
  33   i_persist_file->Release();
  34   if (FAILED(i_shell_link->CreateInstance(CLSID_ShellLink, NULL,
  35                                           CLSCTX_INPROC_SERVER)) ||
  36       FAILED(i_persist_file->QueryFrom(*i_shell_link)) ||
  37       (shortcut && FAILED((*i_persist_file)->Load(shortcut, STGM_READWRITE)))) {
  38     i_shell_link->Release();
  39     i_persist_file->Release();
  40   }
  41 }
  42
  43 }  // namespace
  44
  45 bool CreateOrUpdateShortcutLink(const FilePath& shortcut_path,
  46                                 const ShortcutProperties& properties,
  47                                 ShortcutOperation operation) {
  48   base::ThreadRestrictions::AssertIOAllowed();
  49
  50   // A target is required unless |operation| is SHORTCUT_UPDATE_EXISTING.
  51   if (operation != SHORTCUT_UPDATE_EXISTING &&
  52       !(properties.options & ShortcutProperties::PROPERTIES_TARGET)) {
  53     NOTREACHED();
  54     return false;
  55   }
  56
  57   bool shortcut_existed = PathExists(shortcut_path);
  58
  59   // Interfaces to the old shortcut when replacing an existing shortcut.
  60   ScopedComPtr<IShellLink> old_i_shell_link;
  61   ScopedComPtr<IPersistFile> old_i_persist_file;
  62
  63   // Interfaces to the shortcut being created/updated.
  64   ScopedComPtr<IShellLink> i_shell_link;
  65   ScopedComPtr<IPersistFile> i_persist_file;
  66   switch (operation) {
  67     case SHORTCUT_CREATE_ALWAYS:
  68       InitializeShortcutInterfaces(NULL, &i_shell_link, &i_persist_file);
  69       break;
  70     case SHORTCUT_UPDATE_EXISTING:
  71       InitializeShortcutInterfaces(shortcut_path.value().c_str(), &i_shell_link,
  72                                    &i_persist_file);
  73       break;
  74     case SHORTCUT_REPLACE_EXISTING:
  75       InitializeShortcutInterfaces(shortcut_path.value().c_str(),
  76                                    &old_i_shell_link, &old_i_persist_file);
  77       // Confirm |shortcut_path| exists and is a shortcut by verifying
  78       // |old_i_persist_file| was successfully initialized in the call above. If
  79       // so, initialize the interfaces to begin writing a new shortcut (to
  80       // overwrite the current one if successful).
  81       if (old_i_persist_file.get())
  82         InitializeShortcutInterfaces(NULL, &i_shell_link, &i_persist_file);
  83       break;
  84     default:
  85       NOTREACHED();
  86   }
  87
  88   // Return false immediately upon failure to initialize shortcut interfaces.
  89   if (!i_persist_file.get())
  90     return false;
  91
  92   if ((properties.options & ShortcutProperties::PROPERTIES_TARGET) &&
  93       FAILED(i_shell_link->SetPath(properties.target.value().c_str()))) {
  94     return false;
  95   }
  96
  97   if ((properties.options & ShortcutProperties::PROPERTIES_WORKING_DIR) &&
  98       FAILED(i_shell_link->SetWorkingDirectory(
  99           properties.working_dir.value().c_str()))) {
 100     return false;
 101   }
 102
 103   if (properties.options & ShortcutProperties::PROPERTIES_ARGUMENTS) {
 104     if (FAILED(i_shell_link->SetArguments(properties.arguments.c_str())))
 105       return false;
 106   } else if (old_i_persist_file.get()) {
 107     wchar_t current_arguments[MAX_PATH] = {0};
 108     if (SUCCEEDED(old_i_shell_link->GetArguments(current_arguments,
 109                                                  MAX_PATH))) {
 110       i_shell_link->SetArguments(current_arguments);
 111     }
 112   }
 113
 114   if ((properties.options & ShortcutProperties::PROPERTIES_DESCRIPTION) &&
 115       FAILED(i_shell_link->SetDescription(properties.description.c_str()))) {
 116     return false;
 117   }
 118
 119   if ((properties.options & ShortcutProperties::PROPERTIES_ICON) &&
 120       FAILED(i_shell_link->SetIconLocation(properties.icon.value().c_str(),
 121                                            properties.icon_index))) {
 122     return false;
 123   }
 124
 125   bool has_app_id =
 126       (properties.options & ShortcutProperties::PROPERTIES_APP_ID) != 0;
 127   bool has_dual_mode =
 128       (properties.options & ShortcutProperties::PROPERTIES_DUAL_MODE) != 0;
 129   if ((has_app_id || has_dual_mode) &&
 130       GetVersion() >= VERSION_WIN7) {
 131     ScopedComPtr<IPropertyStore> property_store;
 132     if (FAILED(property_store.QueryFrom(i_shell_link)) || !property_store.get())
 133       return false;
 134
 135     if (has_app_id &&
 136         !SetAppIdForPropertyStore(property_store, properties.app_id.c_str())) {
 137       return false;
 138     }
 139     if (has_dual_mode &&
 140         !SetBooleanValueForPropertyStore(property_store,
 141                                          PKEY_AppUserModel_IsDualMode,
 142                                          properties.dual_mode)) {
 143       return false;
 144     }
 145   }
 146
 147   // Release the interfaces to the old shortcut to make sure it doesn't prevent
 148   // overwriting it if needed.
 149   old_i_persist_file.Release();
 150   old_i_shell_link.Release();
 151
 152   HRESULT result = i_persist_file->Save(shortcut_path.value().c_str(), TRUE);
 153
 154   // Release the interfaces in case the SHChangeNotify call below depends on
 155   // the operations above being fully completed.
 156   i_persist_file.Release();
 157   i_shell_link.Release();
 158
 159   // If we successfully created/updated the icon, notify the shell that we have
 160   // done so.
 161   const bool succeeded = SUCCEEDED(result);
 162   if (succeeded) {
 163     if (shortcut_existed) {
 164       // TODO(gab): SHCNE_UPDATEITEM might be sufficient here; further testing
 165       // required.
 166       SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
 167     } else {
 168       SHChangeNotify(SHCNE_CREATE, SHCNF_PATH, shortcut_path.value().c_str(),
 169                      NULL);
 170     }
 171   }
 172
 173   return succeeded;
 174 }
 175
 176 bool ResolveShortcutProperties(const FilePath& shortcut_path,
 177                                uint32 options,
 178                                ShortcutProperties* properties) {
 179   DCHECK(options && properties);
 180   base::ThreadRestrictions::AssertIOAllowed();
 181
 182   if (options & ~ShortcutProperties::PROPERTIES_ALL)
 183     NOTREACHED() << "Unhandled property is used.";
 184
 185   ScopedComPtr<IShellLink> i_shell_link;
 186
 187   // Get pointer to the IShellLink interface.
 188   if (FAILED(i_shell_link.CreateInstance(CLSID_ShellLink, NULL,
 189                                          CLSCTX_INPROC_SERVER))) {
 190     return false;
 191   }
 192
 193   ScopedComPtr<IPersistFile> persist;
 194   // Query IShellLink for the IPersistFile interface.
 195   if (FAILED(persist.QueryFrom(i_shell_link)))
 196     return false;
 197
 198   // Load the shell link.
 199   if (FAILED(persist->Load(shortcut_path.value().c_str(), STGM_READ)))
 200     return false;
 201
 202   // Reset |properties|.
 203   properties->options = 0;
 204
 205   wchar_t temp[MAX_PATH];
 206   if (options & ShortcutProperties::PROPERTIES_TARGET) {
 207     // Try to find the target of a shortcut.
 208     if (FAILED(i_shell_link->Resolve(0, SLR_NO_UI | SLR_NOSEARCH)))
 209       return false;
 210     if (FAILED(i_shell_link->GetPath(temp, MAX_PATH, NULL, SLGP_UNCPRIORITY)))
 211       return false;
 212     properties->set_target(FilePath(temp));
 213   }
 214
 215   if (options & ShortcutProperties::PROPERTIES_WORKING_DIR) {
 216     if (FAILED(i_shell_link->GetWorkingDirectory(temp, MAX_PATH)))
 217       return false;
 218     properties->set_working_dir(FilePath(temp));
 219   }
 220
 221   if (options & ShortcutProperties::PROPERTIES_ARGUMENTS) {
 222     if (FAILED(i_shell_link->GetArguments(temp, MAX_PATH)))
 223       return false;
 224     properties->set_arguments(temp);
 225   }
 226
 227   if (options & ShortcutProperties::PROPERTIES_DESCRIPTION) {
 228     // Note: description length constrained by MAX_PATH.
 229     if (FAILED(i_shell_link->GetDescription(temp, MAX_PATH)))
 230       return false;
 231     properties->set_description(temp);
 232   }
 233
 234   if (options & ShortcutProperties::PROPERTIES_ICON) {
 235     int temp_index;
 236     if (FAILED(i_shell_link->GetIconLocation(temp, MAX_PATH, &temp_index)))
 237       return false;
 238     properties->set_icon(FilePath(temp), temp_index);
 239   }
 240
 241   // Windows 7+ options, avoiding unnecessary work.
 242   if ((options & ShortcutProperties::PROPERTIES_WIN7) &&
 243       GetVersion() >= VERSION_WIN7) {
 244     ScopedComPtr<IPropertyStore> property_store;
 245     if (FAILED(property_store.QueryFrom(i_shell_link)))
 246       return false;
 247
 248     if (options & ShortcutProperties::PROPERTIES_APP_ID) {
 249       ScopedPropVariant pv_app_id;
 250       if (property_store->GetValue(PKEY_AppUserModel_ID,
 251                                    pv_app_id.Receive()) != S_OK) {
 252         return false;
 253       }
 254       switch (pv_app_id.get().vt) {
 255         case VT_EMPTY:
 256           properties->set_app_id(L"");
 257           break;
 258         case VT_LPWSTR:
 259           properties->set_app_id(pv_app_id.get().pwszVal);
 260           break;
 261         default:
 262           NOTREACHED() << "Unexpected variant type: " << pv_app_id.get().vt;
 263           return false;
 264       }
 265     }
 266
 267     if (options & ShortcutProperties::PROPERTIES_DUAL_MODE) {
 268       ScopedPropVariant pv_dual_mode;
 269       if (property_store->GetValue(PKEY_AppUserModel_IsDualMode,
 270                                    pv_dual_mode.Receive()) != S_OK) {
 271         return false;
 272       }
 273       switch (pv_dual_mode.get().vt) {
 274         case VT_EMPTY:
 275           properties->set_dual_mode(false);
 276           break;
 277         case VT_BOOL:
 278           properties->set_dual_mode(pv_dual_mode.get().boolVal == VARIANT_TRUE);
 279           break;
 280         default:
 281           NOTREACHED() << "Unexpected variant type: " << pv_dual_mode.get().vt;
 282           return false;
 283       }
 284     }
 285   }
 286
 287   return true;
 288 }
 289
 290 bool ResolveShortcut(const FilePath& shortcut_path,
 291                      FilePath* target_path,
 292                      string16* args) {
 293   uint32 options = 0;
 294   if (target_path)
 295     options |= ShortcutProperties::PROPERTIES_TARGET;
 296   if (args)
 297     options |= ShortcutProperties::PROPERTIES_ARGUMENTS;
 298   DCHECK(options);
 299
 300   ShortcutProperties properties;
 301   if (!ResolveShortcutProperties(shortcut_path, options, &properties))
 302     return false;
 303
 304   if (target_path)
 305     *target_path = properties.target;
 306   if (args)
 307     *args = properties.arguments;
 308   return true;
 309 }
 310
 311 bool TaskbarPinShortcutLink(const wchar_t* shortcut) {
 312   base::ThreadRestrictions::AssertIOAllowed();
 313
 314   // "Pin to taskbar" is only supported after Win7.
 315   if (GetVersion() < VERSION_WIN7)
 316     return false;
 317
 318   int result = reinterpret_cast<int>(ShellExecute(NULL, L"taskbarpin", shortcut,
 319       NULL, NULL, 0));
 320   return result > 32;
 321 }
 322
 323 bool TaskbarUnpinShortcutLink(const wchar_t* shortcut) {
 324   base::ThreadRestrictions::AssertIOAllowed();
 325
 326   // "Unpin from taskbar" is only supported after Win7.
 327   if (GetVersion() < VERSION_WIN7)
 328     return false;
 329
 330   int result = reinterpret_cast<int>(ShellExecute(NULL, L"taskbarunpin",
 331       shortcut, NULL, NULL, 0));
 332   return result > 32;
 333 }
 334
 335 }  // namespace win
 336 }  // namespace base