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