win8/metro_driver/file_picker.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 "stdafx.h"
   6 #include "win8/metro_driver/file_picker.h"
   7
   8 #include <windows.storage.pickers.h>
   9
  10 #include "base/bind.h"
  11 #include "base/files/file_path.h"
  12 #include "base/logging.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/synchronization/waitable_event.h"
  16 #include "base/win/metro.h"
  17 #include "base/win/scoped_comptr.h"
  18 #include "win8/metro_driver/chrome_app_view.h"
  19 #include "win8/metro_driver/winrt_utils.h"
  20
  21 namespace {
  22
  23 namespace winstorage = ABI::Windows::Storage;
  24 typedef winfoundtn::Collections::IVector<HSTRING> StringVectorItf;
  25
  26 // TODO(siggi): Complete this implementation and move it to a common place.
  27 class StringVectorImpl : public mswr::RuntimeClass<StringVectorItf> {
  28  public:
  29   ~StringVectorImpl() {
  30     std::for_each(strings_.begin(), strings_.end(), ::WindowsDeleteString);
  31   }
  32
  33   HRESULT RuntimeClassInitialize(const std::vector<base::string16>& list) {
  34     for (size_t i = 0; i < list.size(); ++i)
  35       strings_.push_back(MakeHString(list[i]));
  36
  37     return S_OK;
  38   }
  39
  40   // IVector<HSTRING> implementation.
  41   STDMETHOD(GetAt)(unsigned index, HSTRING* item) {
  42     if (index >= strings_.size())
  43       return E_INVALIDARG;
  44
  45     return ::WindowsDuplicateString(strings_[index], item);
  46   }
  47   STDMETHOD(get_Size)(unsigned *size) {
  48     if (strings_.size() > UINT_MAX)
  49       return E_UNEXPECTED;
  50     *size = static_cast<unsigned>(strings_.size());
  51     return S_OK;
  52   }
  53   STDMETHOD(GetView)(winfoundtn::Collections::IVectorView<HSTRING> **view) {
  54     return E_NOTIMPL;
  55   }
  56   STDMETHOD(IndexOf)(HSTRING value, unsigned *index, boolean *found) {
  57     return E_NOTIMPL;
  58   }
  59
  60   // write methods
  61   STDMETHOD(SetAt)(unsigned index, HSTRING item) {
  62     return E_NOTIMPL;
  63   }
  64   STDMETHOD(InsertAt)(unsigned index, HSTRING item) {
  65     return E_NOTIMPL;
  66   }
  67   STDMETHOD(RemoveAt)(unsigned index) {
  68     return E_NOTIMPL;
  69   }
  70   STDMETHOD(Append)(HSTRING item) {
  71     return E_NOTIMPL;
  72   }
  73   STDMETHOD(RemoveAtEnd)() {
  74     return E_NOTIMPL;
  75   }
  76   STDMETHOD(Clear)() {
  77     return E_NOTIMPL;
  78   }
  79
  80  private:
  81   std::vector<HSTRING> strings_;
  82 };
  83
  84 class FilePickerSessionBase {
  85  public:
  86   // Creates a file picker for open_file_name.
  87   explicit FilePickerSessionBase(OPENFILENAME* open_file_name);
  88
  89   // Runs the picker, returns true on success.
  90   bool Run();
  91
  92  protected:
  93   // Creates, configures and starts a file picker.
  94   // If the HRESULT returned is a failure code the file picker has not started,
  95   // so no callbacks should be expected.
  96   virtual HRESULT StartFilePicker() = 0;
  97
  98   // The parameters to our picker.
  99   OPENFILENAME* open_file_name_;
 100   // The event Run waits on.
 101   base::WaitableEvent event_;
 102   // True iff a file picker has successfully finished.
 103   bool success_;
 104
 105  private:
 106   // Initiate a file picker, must be called on the metro dispatcher's thread.
 107   void DoFilePicker();
 108
 109   DISALLOW_COPY_AND_ASSIGN(FilePickerSessionBase);
 110 };
 111
 112 class OpenFilePickerSession : public FilePickerSessionBase {
 113  public:
 114   explicit OpenFilePickerSession(OPENFILENAME* open_file_name);
 115
 116  private:
 117   HRESULT StartFilePicker() override;
 118
 119   typedef winfoundtn::IAsyncOperation<winstorage::StorageFile*>
 120       SingleFileAsyncOp;
 121   typedef winfoundtn::Collections::IVectorView<
 122       winstorage::StorageFile*> StorageFileVectorCollection;
 123   typedef winfoundtn::IAsyncOperation<StorageFileVectorCollection*>
 124       MultiFileAsyncOp;
 125
 126   // Called asynchronously when a single file picker is done.
 127   HRESULT SinglePickerDone(SingleFileAsyncOp* async, AsyncStatus status);
 128
 129   // Called asynchronously when a multi file picker is done.
 130   HRESULT MultiPickerDone(MultiFileAsyncOp* async, AsyncStatus status);
 131
 132   // Composes a multi-file result string suitable for returning to a
 133   // from a storage file collection.
 134   static HRESULT ComposeMultiFileResult(StorageFileVectorCollection* files,
 135                                         base::string16* result);
 136  private:
 137   DISALLOW_COPY_AND_ASSIGN(OpenFilePickerSession);
 138 };
 139
 140 class SaveFilePickerSession : public FilePickerSessionBase {
 141  public:
 142   explicit SaveFilePickerSession(OPENFILENAME* open_file_name);
 143
 144  private:
 145   HRESULT StartFilePicker() override;
 146
 147   typedef winfoundtn::IAsyncOperation<winstorage::StorageFile*>
 148       SaveFileAsyncOp;
 149
 150   // Called asynchronously when the save file picker is done.
 151   HRESULT FilePickerDone(SaveFileAsyncOp* async, AsyncStatus status);
 152 };
 153
 154 FilePickerSessionBase::FilePickerSessionBase(OPENFILENAME* open_file_name)
 155     : open_file_name_(open_file_name),
 156       event_(true, false),
 157       success_(false) {
 158 }
 159
 160 bool FilePickerSessionBase::Run() {
 161   DCHECK(globals.appview_msg_loop != NULL);
 162
 163   // Post the picker request over to the metro thread.
 164   bool posted = globals.appview_msg_loop->PostTask(FROM_HERE,
 165       base::Bind(&FilePickerSessionBase::DoFilePicker, base::Unretained(this)));
 166   if (!posted)
 167     return false;
 168
 169   // Wait for the file picker to complete.
 170   event_.Wait();
 171
 172   return success_;
 173 }
 174
 175 void FilePickerSessionBase::DoFilePicker() {
 176   // The file picker will fail if spawned from a snapped application,
 177   // so let's attempt to unsnap first if we're in that state.
 178   HRESULT hr = ChromeAppView::Unsnap();
 179   if (FAILED(hr)) {
 180     LOG(ERROR) << "Failed to unsnap for file picker, error 0x" << hr;
 181   }
 182
 183   if (SUCCEEDED(hr))
 184     hr = StartFilePicker();
 185
 186   if (FAILED(hr)) {
 187     LOG(ERROR) << "Failed to start file picker, error 0x"
 188                << std::hex << hr;
 189
 190     event_.Signal();
 191   }
 192 }
 193
 194 OpenFilePickerSession::OpenFilePickerSession(OPENFILENAME* open_file_name)
 195     : FilePickerSessionBase(open_file_name) {
 196 }
 197
 198 HRESULT OpenFilePickerSession::SinglePickerDone(SingleFileAsyncOp* async,
 199                                                 AsyncStatus status) {
 200   if (status == Completed) {
 201     mswr::ComPtr<winstorage::IStorageFile> file;
 202     HRESULT hr = async->GetResults(file.GetAddressOf());
 203
 204     if (file) {
 205       mswr::ComPtr<winstorage::IStorageItem> storage_item;
 206       if (SUCCEEDED(hr))
 207         hr = file.As(&storage_item);
 208
 209       mswrw::HString file_path;
 210       if (SUCCEEDED(hr))
 211         hr = storage_item->get_Path(file_path.GetAddressOf());
 212
 213       if (SUCCEEDED(hr)) {
 214         UINT32 path_len = 0;
 215         const wchar_t* path_str =
 216             ::WindowsGetStringRawBuffer(file_path.Get(), &path_len);
 217
 218         // If the selected file name is longer than the supplied buffer,
 219         // we return false as per GetOpenFileName documentation.
 220         if (path_len < open_file_name_->nMaxFile) {
 221           base::wcslcpy(open_file_name_->lpstrFile,
 222                         path_str,
 223                         open_file_name_->nMaxFile);
 224           success_ = true;
 225         }
 226       }
 227     } else {
 228       LOG(ERROR) << "NULL IStorageItem";
 229     }
 230   } else {
 231     LOG(ERROR) << "Unexpected async status " << static_cast<int>(status);
 232   }
 233
 234   event_.Signal();
 235
 236   return S_OK;
 237 }
 238
 239 HRESULT OpenFilePickerSession::MultiPickerDone(MultiFileAsyncOp* async,
 240                                                  AsyncStatus status) {
 241   if (status == Completed) {
 242     mswr::ComPtr<StorageFileVectorCollection> files;
 243     HRESULT hr = async->GetResults(files.GetAddressOf());
 244
 245     if (files) {
 246       base::string16 result;
 247       if (SUCCEEDED(hr))
 248         hr = ComposeMultiFileResult(files.Get(), &result);
 249
 250       if (SUCCEEDED(hr)) {
 251         if (result.size() + 1 < open_file_name_->nMaxFile) {
 252           // Because the result has embedded nulls, we must memcpy.
 253           memcpy(open_file_name_->lpstrFile,
 254                  result.c_str(),
 255                  (result.size() + 1) * sizeof(result[0]));
 256           success_ = true;
 257         }
 258       }
 259     } else {
 260       LOG(ERROR) << "NULL StorageFileVectorCollection";
 261     }
 262   } else {
 263     LOG(ERROR) << "Unexpected async status " << static_cast<int>(status);
 264   }
 265
 266   event_.Signal();
 267
 268   return S_OK;
 269 }
 270
 271 HRESULT OpenFilePickerSession::StartFilePicker() {
 272   DCHECK(globals.appview_msg_loop->BelongsToCurrentThread());
 273   DCHECK(open_file_name_ != NULL);
 274
 275   mswrw::HStringReference class_name(
 276       RuntimeClass_Windows_Storage_Pickers_FileOpenPicker);
 277
 278   // Create the file picker.
 279   mswr::ComPtr<winstorage::Pickers::IFileOpenPicker> picker;
 280   HRESULT hr = ::Windows::Foundation::ActivateInstance(
 281       class_name.Get(), picker.GetAddressOf());
 282   CheckHR(hr);
 283
 284   // Set the file type filter
 285   mswr::ComPtr<winfoundtn::Collections::IVector<HSTRING>> filter;
 286   hr = picker->get_FileTypeFilter(filter.GetAddressOf());
 287   if (FAILED(hr))
 288     return hr;
 289
 290   if (open_file_name_->lpstrFilter == NULL) {
 291     hr = filter->Append(mswrw::HStringReference(L"*").Get());
 292     if (FAILED(hr))
 293       return hr;
 294   } else {
 295     // The filter is a concatenation of zero terminated string pairs,
 296     // where each pair is {description, extension}. The concatenation ends
 297     // with a zero length string - e.g. a double zero terminator.
 298     const wchar_t* walk = open_file_name_->lpstrFilter;
 299     while (*walk != L'\0') {
 300       // Walk past the description.
 301       walk += wcslen(walk) + 1;
 302
 303       // We should have an extension, but bail on malformed filters.
 304       if (*walk == L'\0')
 305         break;
 306
 307       // There can be a single extension, or a list of semicolon-separated ones.
 308       std::vector<base::string16> extensions_win32_style;
 309       size_t extension_count = Tokenize(walk, L";", &extensions_win32_style);
 310       DCHECK_EQ(extension_count, extensions_win32_style.size());
 311
 312       // Metro wants suffixes only, not patterns.
 313       mswrw::HString extension;
 314       for (size_t i = 0; i < extensions_win32_style.size(); ++i) {
 315         if (extensions_win32_style[i] == L"*.*") {
 316           // The wildcard filter is "*" for Metro. The string "*.*" produces
 317           // an "invalid parameter" error.
 318           hr = extension.Set(L"*");
 319         } else {
 320           // Metro wants suffixes only, not patterns.
 321           base::string16 ext =
 322               base::FilePath(extensions_win32_style[i]).Extension();
 323           if ((ext.size() < 2) ||
 324               (ext.find_first_of(L"*?") != base::string16::npos)) {
 325             continue;
 326           }
 327           hr = extension.Set(ext.c_str());
 328         }
 329         if (SUCCEEDED(hr))
 330           hr = filter->Append(extension.Get());
 331         if (FAILED(hr))
 332           return hr;
 333       }
 334
 335       // Walk past the extension.
 336       walk += wcslen(walk) + 1;
 337     }
 338   }
 339
 340   // Spin up a single or multi picker as appropriate.
 341   if (open_file_name_->Flags & OFN_ALLOWMULTISELECT) {
 342     mswr::ComPtr<MultiFileAsyncOp> completion;
 343     hr = picker->PickMultipleFilesAsync(&completion);
 344     if (FAILED(hr))
 345       return hr;
 346
 347     // Create the callback method.
 348     typedef winfoundtn::IAsyncOperationCompletedHandler<
 349         StorageFileVectorCollection*> HandlerDoneType;
 350     mswr::ComPtr<HandlerDoneType> handler(mswr::Callback<HandlerDoneType>(
 351         this, &OpenFilePickerSession::MultiPickerDone));
 352     DCHECK(handler.Get() != NULL);
 353     hr = completion->put_Completed(handler.Get());
 354
 355     return hr;
 356   } else {
 357     mswr::ComPtr<SingleFileAsyncOp> completion;
 358     hr = picker->PickSingleFileAsync(&completion);
 359     if (FAILED(hr))
 360       return hr;
 361
 362     // Create the callback method.
 363     typedef winfoundtn::IAsyncOperationCompletedHandler<
 364         winstorage::StorageFile*> HandlerDoneType;
 365     mswr::ComPtr<HandlerDoneType> handler(mswr::Callback<HandlerDoneType>(
 366         this, &OpenFilePickerSession::SinglePickerDone));
 367     DCHECK(handler.Get() != NULL);
 368     hr = completion->put_Completed(handler.Get());
 369
 370     return hr;
 371   }
 372 }
 373
 374 HRESULT OpenFilePickerSession::ComposeMultiFileResult(
 375     StorageFileVectorCollection* files, base::string16* result) {
 376   DCHECK(files != NULL);
 377   DCHECK(result != NULL);
 378
 379   // Empty the output string.
 380   result->clear();
 381
 382   unsigned int num_files = 0;
 383   HRESULT hr = files->get_Size(&num_files);
 384   if (FAILED(hr))
 385     return hr;
 386
 387   // Make sure we return an error on an empty collection.
 388   if (num_files == 0) {
 389     DLOG(ERROR) << "Empty collection on input.";
 390     return E_UNEXPECTED;
 391   }
 392
 393   // This stores the base path that should be the parent of all the files.
 394   base::FilePath base_path;
 395
 396   // Iterate through the collection and append the file paths to the result.
 397   for (unsigned int i = 0; i < num_files; ++i) {
 398     mswr::ComPtr<winstorage::IStorageFile> file;
 399     hr = files->GetAt(i, file.GetAddressOf());
 400     if (FAILED(hr))
 401       return hr;
 402
 403     mswr::ComPtr<winstorage::IStorageItem> storage_item;
 404     hr = file.As(&storage_item);
 405     if (FAILED(hr))
 406       return hr;
 407
 408     mswrw::HString file_path_str;
 409     hr = storage_item->get_Path(file_path_str.GetAddressOf());
 410     if (FAILED(hr))
 411       return hr;
 412
 413     base::FilePath file_path(MakeStdWString(file_path_str.Get()));
 414     if (base_path.empty()) {
 415       DCHECK(result->empty());
 416       base_path = file_path.DirName();
 417
 418       // Append the path, including the terminating zero.
 419       // We do this only for the first file.
 420       result->append(base_path.value().c_str(), base_path.value().size() + 1);
 421     }
 422     DCHECK(!result->empty());
 423     DCHECK(!base_path.empty());
 424     DCHECK(base_path == file_path.DirName());
 425
 426     // Append the base name, including the terminating zero.
 427     base::FilePath base_name = file_path.BaseName();
 428     result->append(base_name.value().c_str(), base_name.value().size() + 1);
 429   }
 430
 431   DCHECK(!result->empty());
 432
 433   return S_OK;
 434 }
 435
 436 SaveFilePickerSession::SaveFilePickerSession(OPENFILENAME* open_file_name)
 437     : FilePickerSessionBase(open_file_name) {
 438 }
 439
 440 HRESULT SaveFilePickerSession::StartFilePicker() {
 441   DCHECK(globals.appview_msg_loop->BelongsToCurrentThread());
 442   DCHECK(open_file_name_ != NULL);
 443
 444   mswrw::HStringReference class_name(
 445       RuntimeClass_Windows_Storage_Pickers_FileSavePicker);
 446
 447   // Create the file picker.
 448   mswr::ComPtr<winstorage::Pickers::IFileSavePicker> picker;
 449   HRESULT hr = ::Windows::Foundation::ActivateInstance(
 450       class_name.Get(), picker.GetAddressOf());
 451   CheckHR(hr);
 452
 453   typedef winfoundtn::Collections::IMap<HSTRING, StringVectorItf*>
 454       StringVectorMap;
 455   mswr::ComPtr<StringVectorMap> choices;
 456   hr = picker->get_FileTypeChoices(choices.GetAddressOf());
 457   if (FAILED(hr))
 458     return hr;
 459
 460   if (open_file_name_->lpstrFilter) {
 461     // The filter is a concatenation of zero terminated string pairs,
 462     // where each pair is {description, extension list}. The concatenation ends
 463     // with a zero length string - e.g. a double zero terminator.
 464     const wchar_t* walk = open_file_name_->lpstrFilter;
 465     while (*walk != L'\0') {
 466       mswrw::HString description;
 467       hr = description.Set(walk);
 468       if (FAILED(hr))
 469         return hr;
 470
 471       // Walk past the description.
 472       walk += wcslen(walk) + 1;
 473
 474       // We should have an extension, but bail on malformed filters.
 475       if (*walk == L'\0')
 476         break;
 477
 478       // There can be a single extension, or a list of semicolon-separated ones.
 479       std::vector<base::string16> extensions_win32_style;
 480       size_t extension_count = Tokenize(walk, L";", &extensions_win32_style);
 481       DCHECK_EQ(extension_count, extensions_win32_style.size());
 482
 483       // Metro wants suffixes only, not patterns.  Also, metro does not support
 484       // the all files ("*") pattern in the save picker.
 485       std::vector<base::string16> extensions;
 486       for (size_t i = 0; i < extensions_win32_style.size(); ++i) {
 487         base::string16 ext =
 488             base::FilePath(extensions_win32_style[i]).Extension();
 489         if ((ext.size() < 2) ||
 490             (ext.find_first_of(L"*?") != base::string16::npos))
 491           continue;
 492         extensions.push_back(ext);
 493       }
 494
 495       if (!extensions.empty()) {
 496         // Convert to a Metro collection class.
 497         mswr::ComPtr<StringVectorItf> list;
 498         hr = mswr::MakeAndInitialize<StringVectorImpl>(
 499             list.GetAddressOf(), extensions);
 500         if (FAILED(hr))
 501           return hr;
 502
 503         // Finally set the filter.
 504         boolean replaced = FALSE;
 505         hr = choices->Insert(description.Get(), list.Get(), &replaced);
 506         if (FAILED(hr))
 507           return hr;
 508         DCHECK_EQ(FALSE, replaced);
 509       }
 510
 511       // Walk past the extension(s).
 512       walk += wcslen(walk) + 1;
 513     }
 514   }
 515
 516   // The save picker requires at least one choice.  Callers are strongly advised
 517   // to provide sensible choices.  If none were given, fallback to .dat.
 518   uint32 num_choices = 0;
 519   hr = choices->get_Size(&num_choices);
 520   if (FAILED(hr))
 521     return hr;
 522
 523   if (num_choices == 0) {
 524     mswrw::HString description;
 525     // TODO(grt): Get a properly translated string.  This can't be done from
 526     // within metro_driver.  Consider preprocessing the filter list in Chrome
 527     // land to ensure it has this entry if all others are patterns.  In that
 528     // case, this whole block of code can be removed.
 529     hr = description.Set(L"Data File");
 530     if (FAILED(hr))
 531       return hr;
 532
 533     mswr::ComPtr<StringVectorItf> list;
 534     hr = mswr::MakeAndInitialize<StringVectorImpl>(
 535         list.GetAddressOf(), std::vector<base::string16>(1, L".dat"));
 536     if (FAILED(hr))
 537       return hr;
 538
 539     boolean replaced = FALSE;
 540     hr = choices->Insert(description.Get(), list.Get(), &replaced);
 541     if (FAILED(hr))
 542       return hr;
 543     DCHECK_EQ(FALSE, replaced);
 544   }
 545
 546   if (open_file_name_->lpstrFile != NULL) {
 547     hr = picker->put_SuggestedFileName(
 548         mswrw::HStringReference(
 549             const_cast<const wchar_t*>(open_file_name_->lpstrFile)).Get());
 550     if (FAILED(hr))
 551       return hr;
 552   }
 553
 554   mswr::ComPtr<SaveFileAsyncOp> completion;
 555   hr = picker->PickSaveFileAsync(&completion);
 556   if (FAILED(hr))
 557     return hr;
 558
 559   // Create the callback method.
 560   typedef winfoundtn::IAsyncOperationCompletedHandler<
 561       winstorage::StorageFile*> HandlerDoneType;
 562   mswr::ComPtr<HandlerDoneType> handler(mswr::Callback<HandlerDoneType>(
 563       this, &SaveFilePickerSession::FilePickerDone));
 564   DCHECK(handler.Get() != NULL);
 565   hr = completion->put_Completed(handler.Get());
 566
 567   return hr;
 568 }
 569
 570 HRESULT SaveFilePickerSession::FilePickerDone(SaveFileAsyncOp* async,
 571                                               AsyncStatus status) {
 572   if (status == Completed) {
 573     mswr::ComPtr<winstorage::IStorageFile> file;
 574     HRESULT hr = async->GetResults(file.GetAddressOf());
 575
 576     if (file) {
 577       mswr::ComPtr<winstorage::IStorageItem> storage_item;
 578       if (SUCCEEDED(hr))
 579         hr = file.As(&storage_item);
 580
 581       mswrw::HString file_path;
 582       if (SUCCEEDED(hr))
 583         hr = storage_item->get_Path(file_path.GetAddressOf());
 584
 585       if (SUCCEEDED(hr)) {
 586         base::string16 path_str = MakeStdWString(file_path.Get());
 587
 588         // If the selected file name is longer than the supplied buffer,
 589         // we return false as per GetOpenFileName documentation.
 590         if (path_str.size() < open_file_name_->nMaxFile) {
 591           base::wcslcpy(open_file_name_->lpstrFile,
 592                         path_str.c_str(),
 593                         open_file_name_->nMaxFile);
 594           success_ = true;
 595         }
 596       }
 597     } else {
 598       LOG(ERROR) << "NULL IStorageItem";
 599     }
 600   } else {
 601     LOG(ERROR) << "Unexpected async status " << static_cast<int>(status);
 602   }
 603
 604   event_.Signal();
 605
 606   return S_OK;
 607 }
 608
 609 }  // namespace
 610
 611 BOOL MetroGetOpenFileName(OPENFILENAME* open_file_name) {
 612   OpenFilePickerSession session(open_file_name);
 613
 614   return session.Run();
 615 }
 616
 617 BOOL MetroGetSaveFileName(OPENFILENAME* open_file_name) {
 618   SaveFilePickerSession session(open_file_name);
 619
 620   return session.Run();
 621 }