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