chrome/browser/file_select_helper.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 "chrome/browser/file_select_helper.h"
   6
   7 #include <string>
   8 #include <utility>
   9
  10 #include "base/bind.h"
  11 #include "base/files/file_enumerator.h"
  12 #include "base/files/file_util.h"
  13 #include "base/strings/string_split.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "chrome/browser/browser_process.h"
  17 #include "chrome/browser/platform_util.h"
  18 #include "chrome/browser/profiles/profile.h"
  19 #include "chrome/browser/profiles/profile_manager.h"
  20 #include "chrome/browser/ui/browser.h"
  21 #include "chrome/browser/ui/browser_list.h"
  22 #include "chrome/browser/ui/chrome_select_file_policy.h"
  23 #include "chrome/grit/generated_resources.h"
  24 #include "content/public/browser/browser_thread.h"
  25 #include "content/public/browser/notification_details.h"
  26 #include "content/public/browser/notification_source.h"
  27 #include "content/public/browser/notification_types.h"
  28 #include "content/public/browser/render_view_host.h"
  29 #include "content/public/browser/render_widget_host_view.h"
  30 #include "content/public/browser/web_contents.h"
  31 #include "content/public/common/file_chooser_file_info.h"
  32 #include "content/public/common/file_chooser_params.h"
  33 #include "net/base/mime_util.h"
  34 #include "ui/base/l10n/l10n_util.h"
  35 #include "ui/shell_dialogs/selected_file_info.h"
  36
  37 #if defined(OS_CHROMEOS)
  38 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
  39 #include "content/public/browser/site_instance.h"
  40 #endif
  41
  42 using content::BrowserThread;
  43 using content::FileChooserParams;
  44 using content::RenderViewHost;
  45 using content::RenderWidgetHost;
  46 using content::WebContents;
  47
  48 namespace {
  49
  50 // There is only one file-selection happening at any given time,
  51 // so we allocate an enumeration ID for that purpose.  All IDs from
  52 // the renderer must start at 0 and increase.
  53 const int kFileSelectEnumerationId = -1;
  54
  55 // Converts a list of FilePaths to a list of ui::SelectedFileInfo.
  56 std::vector<ui::SelectedFileInfo> FilePathListToSelectedFileInfoList(
  57     const std::vector<base::FilePath>& paths) {
  58   std::vector<ui::SelectedFileInfo> selected_files;
  59   for (size_t i = 0; i < paths.size(); ++i) {
  60     selected_files.push_back(
  61         ui::SelectedFileInfo(paths[i], paths[i]));
  62   }
  63   return selected_files;
  64 }
  65
  66 void DeleteFiles(const std::vector<base::FilePath>& paths) {
  67   for (auto& file_path : paths)
  68     base::DeleteFile(file_path, false);
  69 }
  70
  71 bool IsValidProfile(Profile* profile) {
  72   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  73   return g_browser_process->profile_manager()->IsValidProfile(profile);
  74 }
  75
  76 }  // namespace
  77
  78 struct FileSelectHelper::ActiveDirectoryEnumeration {
  79   ActiveDirectoryEnumeration() : rvh_(NULL) {}
  80
  81   scoped_ptr<DirectoryListerDispatchDelegate> delegate_;
  82   scoped_ptr<net::DirectoryLister> lister_;
  83   RenderViewHost* rvh_;
  84   std::vector<base::FilePath> results_;
  85 };
  86
  87 FileSelectHelper::FileSelectHelper(Profile* profile)
  88     : profile_(profile),
  89       render_view_host_(NULL),
  90       web_contents_(NULL),
  91       select_file_dialog_(),
  92       select_file_types_(),
  93       dialog_type_(ui::SelectFileDialog::SELECT_OPEN_FILE),
  94       dialog_mode_(FileChooserParams::Open) {
  95 }
  96
  97 FileSelectHelper::~FileSelectHelper() {
  98   // There may be pending file dialogs, we need to tell them that we've gone
  99   // away so they don't try and call back to us.
 100   if (select_file_dialog_.get())
 101     select_file_dialog_->ListenerDestroyed();
 102
 103   // Stop any pending directory enumeration, prevent a callback, and free
 104   // allocated memory.
 105   std::map<int, ActiveDirectoryEnumeration*>::iterator iter;
 106   for (iter = directory_enumerations_.begin();
 107        iter != directory_enumerations_.end();
 108        ++iter) {
 109     iter->second->lister_.reset();
 110     delete iter->second;
 111   }
 112 }
 113
 114 void FileSelectHelper::DirectoryListerDispatchDelegate::OnListFile(
 115     const net::DirectoryLister::DirectoryListerData& data) {
 116   parent_->OnListFile(id_, data);
 117 }
 118
 119 void FileSelectHelper::DirectoryListerDispatchDelegate::OnListDone(int error) {
 120   parent_->OnListDone(id_, error);
 121 }
 122
 123 void FileSelectHelper::FileSelected(const base::FilePath& path,
 124                                     int index, void* params) {
 125   FileSelectedWithExtraInfo(ui::SelectedFileInfo(path, path), index, params);
 126 }
 127
 128 void FileSelectHelper::FileSelectedWithExtraInfo(
 129     const ui::SelectedFileInfo& file,
 130     int index,
 131     void* params) {
 132   if (IsValidProfile(profile_))
 133     profile_->set_last_selected_directory(file.file_path.DirName());
 134
 135   if (!render_view_host_) {
 136     RunFileChooserEnd();
 137     return;
 138   }
 139
 140   const base::FilePath& path = file.local_path;
 141   if (dialog_type_ == ui::SelectFileDialog::SELECT_UPLOAD_FOLDER) {
 142     StartNewEnumeration(path, kFileSelectEnumerationId, render_view_host_);
 143     return;
 144   }
 145
 146   std::vector<ui::SelectedFileInfo> files;
 147   files.push_back(file);
 148
 149 #if defined(OS_MACOSX) && !defined(OS_IOS)
 150   content::BrowserThread::PostTask(
 151       content::BrowserThread::FILE_USER_BLOCKING,
 152       FROM_HERE,
 153       base::Bind(&FileSelectHelper::ProcessSelectedFilesMac, this, files));
 154 #else
 155   NotifyRenderViewHostAndEnd(files);
 156 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 157 }
 158
 159 void FileSelectHelper::MultiFilesSelected(
 160     const std::vector<base::FilePath>& files,
 161     void* params) {
 162   std::vector<ui::SelectedFileInfo> selected_files =
 163       FilePathListToSelectedFileInfoList(files);
 164
 165   MultiFilesSelectedWithExtraInfo(selected_files, params);
 166 }
 167
 168 void FileSelectHelper::MultiFilesSelectedWithExtraInfo(
 169     const std::vector<ui::SelectedFileInfo>& files,
 170     void* params) {
 171   if (!files.empty() && IsValidProfile(profile_))
 172     profile_->set_last_selected_directory(files[0].file_path.DirName());
 173
 174 #if defined(OS_MACOSX) && !defined(OS_IOS)
 175   content::BrowserThread::PostTask(
 176       content::BrowserThread::FILE_USER_BLOCKING,
 177       FROM_HERE,
 178       base::Bind(&FileSelectHelper::ProcessSelectedFilesMac, this, files));
 179 #else
 180   NotifyRenderViewHostAndEnd(files);
 181 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 182 }
 183
 184 void FileSelectHelper::FileSelectionCanceled(void* params) {
 185   NotifyRenderViewHostAndEnd(std::vector<ui::SelectedFileInfo>());
 186 }
 187
 188 void FileSelectHelper::StartNewEnumeration(const base::FilePath& path,
 189                                            int request_id,
 190                                            RenderViewHost* render_view_host) {
 191   scoped_ptr<ActiveDirectoryEnumeration> entry(new ActiveDirectoryEnumeration);
 192   entry->rvh_ = render_view_host;
 193   entry->delegate_.reset(new DirectoryListerDispatchDelegate(this, request_id));
 194   entry->lister_.reset(new net::DirectoryLister(path,
 195                                                 true,
 196                                                 net::DirectoryLister::NO_SORT,
 197                                                 entry->delegate_.get()));
 198   if (!entry->lister_->Start()) {
 199     if (request_id == kFileSelectEnumerationId)
 200       FileSelectionCanceled(NULL);
 201     else
 202       render_view_host->DirectoryEnumerationFinished(request_id,
 203                                                      entry->results_);
 204   } else {
 205     directory_enumerations_[request_id] = entry.release();
 206   }
 207 }
 208
 209 void FileSelectHelper::OnListFile(
 210     int id,
 211     const net::DirectoryLister::DirectoryListerData& data) {
 212   ActiveDirectoryEnumeration* entry = directory_enumerations_[id];
 213
 214   // Directory upload only cares about files.
 215   if (data.info.IsDirectory())
 216     return;
 217
 218   entry->results_.push_back(data.path);
 219 }
 220
 221 void FileSelectHelper::OnListDone(int id, int error) {
 222   // This entry needs to be cleaned up when this function is done.
 223   scoped_ptr<ActiveDirectoryEnumeration> entry(directory_enumerations_[id]);
 224   directory_enumerations_.erase(id);
 225   if (!entry->rvh_)
 226     return;
 227   if (error) {
 228     FileSelectionCanceled(NULL);
 229     return;
 230   }
 231
 232   std::vector<ui::SelectedFileInfo> selected_files =
 233       FilePathListToSelectedFileInfoList(entry->results_);
 234
 235   if (id == kFileSelectEnumerationId) {
 236     NotifyRenderViewHostAndEnd(selected_files);
 237   } else {
 238     entry->rvh_->DirectoryEnumerationFinished(id, entry->results_);
 239     EnumerateDirectoryEnd();
 240   }
 241 }
 242
 243 void FileSelectHelper::NotifyRenderViewHostAndEnd(
 244     const std::vector<ui::SelectedFileInfo>& files) {
 245   if (!render_view_host_) {
 246     RunFileChooserEnd();
 247     return;
 248   }
 249
 250 #if defined(OS_CHROMEOS)
 251   if (!files.empty()) {
 252     if (!IsValidProfile(profile_)) {
 253       RunFileChooserEnd();
 254       return;
 255     }
 256     // Converts |files| into FileChooserFileInfo with handling of non-native
 257     // files.
 258     file_manager::util::ConvertSelectedFileInfoListToFileChooserFileInfoList(
 259         file_manager::util::GetFileSystemContextForRenderViewHost(
 260             profile_, render_view_host_),
 261         web_contents_->GetSiteInstance()->GetSiteURL(),
 262         files,
 263         base::Bind(
 264             &FileSelectHelper::NotifyRenderViewHostAndEndAfterConversion,
 265             this));
 266     return;
 267   }
 268 #endif  // defined(OS_CHROMEOS)
 269
 270   std::vector<content::FileChooserFileInfo> chooser_files;
 271   for (const auto& file : files) {
 272     content::FileChooserFileInfo chooser_file;
 273     chooser_file.file_path = file.local_path;
 274     chooser_file.display_name = file.display_name;
 275     chooser_files.push_back(chooser_file);
 276   }
 277
 278   NotifyRenderViewHostAndEndAfterConversion(chooser_files);
 279 }
 280
 281 void FileSelectHelper::NotifyRenderViewHostAndEndAfterConversion(
 282     const std::vector<content::FileChooserFileInfo>& list) {
 283   if (render_view_host_)
 284     render_view_host_->FilesSelectedInChooser(list, dialog_mode_);
 285
 286   // No members should be accessed from here on.
 287   RunFileChooserEnd();
 288 }
 289
 290 void FileSelectHelper::DeleteTemporaryFiles() {
 291   BrowserThread::PostTask(BrowserThread::FILE,
 292                           FROM_HERE,
 293                           base::Bind(&DeleteFiles, temporary_files_));
 294   temporary_files_.clear();
 295 }
 296
 297 scoped_ptr<ui::SelectFileDialog::FileTypeInfo>
 298 FileSelectHelper::GetFileTypesFromAcceptType(
 299     const std::vector<base::string16>& accept_types) {
 300   scoped_ptr<ui::SelectFileDialog::FileTypeInfo> base_file_type(
 301       new ui::SelectFileDialog::FileTypeInfo());
 302   if (accept_types.empty())
 303     return base_file_type.Pass();
 304
 305   // Create FileTypeInfo and pre-allocate for the first extension list.
 306   scoped_ptr<ui::SelectFileDialog::FileTypeInfo> file_type(
 307       new ui::SelectFileDialog::FileTypeInfo(*base_file_type));
 308   file_type->include_all_files = true;
 309   file_type->extensions.resize(1);
 310   std::vector<base::FilePath::StringType>* extensions =
 311       &file_type->extensions.back();
 312
 313   // Find the corresponding extensions.
 314   int valid_type_count = 0;
 315   int description_id = 0;
 316   for (size_t i = 0; i < accept_types.size(); ++i) {
 317     std::string ascii_type = base::UTF16ToASCII(accept_types[i]);
 318     if (!IsAcceptTypeValid(ascii_type))
 319       continue;
 320
 321     size_t old_extension_size = extensions->size();
 322     if (ascii_type[0] == '.') {
 323       // If the type starts with a period it is assumed to be a file extension
 324       // so we just have to add it to the list.
 325       base::FilePath::StringType ext(ascii_type.begin(), ascii_type.end());
 326       extensions->push_back(ext.substr(1));
 327     } else {
 328       if (ascii_type == "image/*")
 329         description_id = IDS_IMAGE_FILES;
 330       else if (ascii_type == "audio/*")
 331         description_id = IDS_AUDIO_FILES;
 332       else if (ascii_type == "video/*")
 333         description_id = IDS_VIDEO_FILES;
 334
 335       net::GetExtensionsForMimeType(ascii_type, extensions);
 336     }
 337
 338     if (extensions->size() > old_extension_size)
 339       valid_type_count++;
 340   }
 341
 342   // If no valid extension is added, bail out.
 343   if (valid_type_count == 0)
 344     return base_file_type.Pass();
 345
 346   // Use a generic description "Custom Files" if either of the following is
 347   // true:
 348   // 1) There're multiple types specified, like "audio/*,video/*"
 349   // 2) There're multiple extensions for a MIME type without parameter, like
 350   //    "ehtml,shtml,htm,html" for "text/html". On Windows, the select file
 351   //    dialog uses the first extension in the list to form the description,
 352   //    like "EHTML Files". This is not what we want.
 353   if (valid_type_count > 1 ||
 354       (valid_type_count == 1 && description_id == 0 && extensions->size() > 1))
 355     description_id = IDS_CUSTOM_FILES;
 356
 357   if (description_id) {
 358     file_type->extension_description_overrides.push_back(
 359         l10n_util::GetStringUTF16(description_id));
 360   }
 361
 362   return file_type.Pass();
 363 }
 364
 365 // static
 366 void FileSelectHelper::RunFileChooser(content::WebContents* tab,
 367                                       const FileChooserParams& params) {
 368   Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
 369   // FileSelectHelper will keep itself alive until it sends the result message.
 370   scoped_refptr<FileSelectHelper> file_select_helper(
 371       new FileSelectHelper(profile));
 372   file_select_helper->RunFileChooser(tab->GetRenderViewHost(), tab, params);
 373 }
 374
 375 // static
 376 void FileSelectHelper::EnumerateDirectory(content::WebContents* tab,
 377                                           int request_id,
 378                                           const base::FilePath& path) {
 379   Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
 380   // FileSelectHelper will keep itself alive until it sends the result message.
 381   scoped_refptr<FileSelectHelper> file_select_helper(
 382       new FileSelectHelper(profile));
 383   file_select_helper->EnumerateDirectory(
 384       request_id, tab->GetRenderViewHost(), path);
 385 }
 386
 387 void FileSelectHelper::RunFileChooser(RenderViewHost* render_view_host,
 388                                       content::WebContents* web_contents,
 389                                       const FileChooserParams& params) {
 390   DCHECK(!render_view_host_);
 391   DCHECK(!web_contents_);
 392   render_view_host_ = render_view_host;
 393   web_contents_ = web_contents;
 394   notification_registrar_.RemoveAll();
 395   notification_registrar_.Add(this,
 396                               content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
 397                               content::Source<WebContents>(web_contents_));
 398   notification_registrar_.Add(
 399       this,
 400       content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
 401       content::Source<RenderWidgetHost>(render_view_host_));
 402   notification_registrar_.Add(
 403       this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
 404       content::Source<WebContents>(web_contents_));
 405
 406   BrowserThread::PostTask(
 407       BrowserThread::FILE, FROM_HERE,
 408       base::Bind(&FileSelectHelper::RunFileChooserOnFileThread, this, params));
 409
 410   // Because this class returns notifications to the RenderViewHost, it is
 411   // difficult for callers to know how long to keep a reference to this
 412   // instance. We AddRef() here to keep the instance alive after we return
 413   // to the caller, until the last callback is received from the file dialog.
 414   // At that point, we must call RunFileChooserEnd().
 415   AddRef();
 416 }
 417
 418 void FileSelectHelper::RunFileChooserOnFileThread(
 419     const FileChooserParams& params) {
 420   select_file_types_ = GetFileTypesFromAcceptType(params.accept_types);
 421   select_file_types_->support_drive = !params.need_local_path;
 422
 423   BrowserThread::PostTask(
 424       BrowserThread::UI, FROM_HERE,
 425       base::Bind(&FileSelectHelper::RunFileChooserOnUIThread, this, params));
 426 }
 427
 428 void FileSelectHelper::RunFileChooserOnUIThread(
 429     const FileChooserParams& params) {
 430   if (!render_view_host_ || !web_contents_ || !IsValidProfile(profile_)) {
 431     // If the renderer was destroyed before we started, just cancel the
 432     // operation.
 433     RunFileChooserEnd();
 434     return;
 435   }
 436
 437   select_file_dialog_ = ui::SelectFileDialog::Create(
 438       this, new ChromeSelectFilePolicy(web_contents_));
 439   if (!select_file_dialog_.get())
 440     return;
 441
 442   dialog_mode_ = params.mode;
 443   switch (params.mode) {
 444     case FileChooserParams::Open:
 445       dialog_type_ = ui::SelectFileDialog::SELECT_OPEN_FILE;
 446       break;
 447     case FileChooserParams::OpenMultiple:
 448       dialog_type_ = ui::SelectFileDialog::SELECT_OPEN_MULTI_FILE;
 449       break;
 450     case FileChooserParams::UploadFolder:
 451       dialog_type_ = ui::SelectFileDialog::SELECT_UPLOAD_FOLDER;
 452       break;
 453     case FileChooserParams::Save:
 454       dialog_type_ = ui::SelectFileDialog::SELECT_SAVEAS_FILE;
 455       break;
 456     default:
 457       // Prevent warning.
 458       dialog_type_ = ui::SelectFileDialog::SELECT_OPEN_FILE;
 459       NOTREACHED();
 460   }
 461
 462   base::FilePath default_file_name = params.default_file_name.IsAbsolute() ?
 463       params.default_file_name :
 464       profile_->last_selected_directory().Append(params.default_file_name);
 465
 466   gfx::NativeWindow owning_window =
 467       platform_util::GetTopLevel(render_view_host_->GetView()->GetNativeView());
 468
 469 #if defined(OS_ANDROID)
 470   // Android needs the original MIME types and an additional capture value.
 471   std::pair<std::vector<base::string16>, bool> accept_types =
 472       std::make_pair(params.accept_types, params.capture);
 473 #endif
 474
 475   select_file_dialog_->SelectFile(
 476       dialog_type_,
 477       params.title,
 478       default_file_name,
 479       select_file_types_.get(),
 480       select_file_types_.get() && !select_file_types_->extensions.empty()
 481           ? 1
 482           : 0,  // 1-based index of default extension to show.
 483       base::FilePath::StringType(),
 484       owning_window,
 485 #if defined(OS_ANDROID)
 486       &accept_types);
 487 #else
 488       NULL);
 489 #endif
 490
 491   select_file_types_.reset();
 492 }
 493
 494 // This method is called when we receive the last callback from the file
 495 // chooser dialog. Perform any cleanup and release the reference we added
 496 // in RunFileChooser().
 497 void FileSelectHelper::RunFileChooserEnd() {
 498   // If there are temporary files, then this instance needs to stick around
 499   // until web_contents_ is destroyed, so that this instance can delete the
 500   // temporary files.
 501   if (!temporary_files_.empty())
 502     return;
 503
 504   render_view_host_ = NULL;
 505   web_contents_ = NULL;
 506   Release();
 507 }
 508
 509 void FileSelectHelper::EnumerateDirectory(int request_id,
 510                                           RenderViewHost* render_view_host,
 511                                           const base::FilePath& path) {
 512
 513   // Because this class returns notifications to the RenderViewHost, it is
 514   // difficult for callers to know how long to keep a reference to this
 515   // instance. We AddRef() here to keep the instance alive after we return
 516   // to the caller, until the last callback is received from the enumeration
 517   // code. At that point, we must call EnumerateDirectoryEnd().
 518   AddRef();
 519   StartNewEnumeration(path, request_id, render_view_host);
 520 }
 521
 522 // This method is called when we receive the last callback from the enumeration
 523 // code. Perform any cleanup and release the reference we added in
 524 // EnumerateDirectory().
 525 void FileSelectHelper::EnumerateDirectoryEnd() {
 526   Release();
 527 }
 528
 529 void FileSelectHelper::Observe(int type,
 530                                const content::NotificationSource& source,
 531                                const content::NotificationDetails& details) {
 532   switch (type) {
 533     case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
 534       DCHECK(content::Source<RenderWidgetHost>(source).ptr() ==
 535              render_view_host_);
 536       render_view_host_ = NULL;
 537       break;
 538     }
 539
 540     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
 541       DCHECK(content::Source<WebContents>(source).ptr() == web_contents_);
 542       web_contents_ = NULL;
 543     }
 544
 545     // Intentional fall through.
 546     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED:
 547       if (!temporary_files_.empty()) {
 548         DeleteTemporaryFiles();
 549
 550         // Now that the temporary files have been scheduled for deletion, there
 551         // is no longer any reason to keep this instance around.
 552         Release();
 553       }
 554
 555       break;
 556
 557     default:
 558       NOTREACHED();
 559   }
 560 }
 561
 562 // static
 563 bool FileSelectHelper::IsAcceptTypeValid(const std::string& accept_type) {
 564   // TODO(raymes): This only does some basic checks, extend to test more cases.
 565   // A 1 character accept type will always be invalid (either a "." in the case
 566   // of an extension or a "/" in the case of a MIME type).
 567   std::string unused;
 568   if (accept_type.length() <= 1 ||
 569       base::StringToLowerASCII(accept_type) != accept_type ||
 570       base::TrimWhitespaceASCII(accept_type, base::TRIM_ALL, &unused) !=
 571           base::TRIM_NONE) {
 572     return false;
 573   }
 574   return true;
 575 }