| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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/chromeos/drive/drive_url_request_job.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/bind.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "base/memory/ref_counted.h" | |
| 13 #include "chrome/browser/browser_process.h" | |
| 14 #include "chrome/browser/chromeos/drive/file_system_util.h" | |
| 15 #include "chrome/browser/extensions/api/file_handlers/mime_util.h" | |
| 16 #include "chrome/browser/profiles/profile_manager.h" | |
| 17 #include "chrome/common/url_constants.h" | |
| 18 #include "content/public/browser/browser_thread.h" | |
| 19 #include "content/public/browser/storage_partition.h" | |
| 20 #include "net/base/net_errors.h" | |
| 21 #include "net/http/http_byte_range.h" | |
| 22 #include "net/http/http_request_headers.h" | |
| 23 #include "net/http/http_response_info.h" | |
| 24 #include "net/http/http_util.h" | |
| 25 #include "net/url_request/url_request.h" | |
| 26 #include "net/url_request/url_request_status.h" | |
| 27 #include "storage/browser/fileapi/file_system_backend.h" | |
| 28 #include "storage/browser/fileapi/file_system_context.h" | |
| 29 #include "storage/browser/fileapi/file_system_operation_runner.h" | |
| 30 | |
| 31 using content::BrowserThread; | |
| 32 | |
| 33 namespace drive { | |
| 34 namespace { | |
| 35 | |
| 36 const char kMimeTypeForRFC822[] = "message/rfc822"; | |
| 37 const char kMimeTypeForMHTML[] = "multipart/related"; | |
| 38 | |
| 39 // Check if the |url| points a valid location or not. | |
| 40 bool IsValidURL(const storage::FileSystemURL& url) { | |
| 41 switch (url.type()) { | |
| 42 case storage::kFileSystemTypeDrive: { | |
| 43 const base::FilePath my_drive_path = util::GetDriveMyDriveRootPath(); | |
| 44 const base::FilePath drive_other_path = | |
| 45 util::GetDriveGrandRootPath().Append(util::kDriveOtherDirName); | |
| 46 const base::FilePath url_drive_path = | |
| 47 util::ExtractDrivePathFromFileSystemUrl(url); | |
| 48 return my_drive_path == url_drive_path || | |
| 49 my_drive_path.IsParent(url_drive_path) || | |
| 50 drive_other_path.IsParent(url_drive_path); | |
| 51 } | |
| 52 default: | |
| 53 return false; | |
| 54 } | |
| 55 } | |
| 56 | |
| 57 // Helper for obtaining FileSystemContext, FileSystemURL, and mime type on the | |
| 58 // UI thread. | |
| 59 class URLHelper { | |
| 60 public: | |
| 61 // The scoped pointer to control lifetime of the instance itself. The pointer | |
| 62 // is passed to callback functions and binds the lifetime of the instance to | |
| 63 // the callback's lifetime. | |
| 64 typedef scoped_ptr<URLHelper> Lifetime; | |
| 65 | |
| 66 URLHelper(void* profile_id, | |
| 67 const GURL& url, | |
| 68 const DriveURLRequestJob::HelperCallback& callback) | |
| 69 : profile_id_(profile_id), url_(url), callback_(callback) { | |
| 70 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
| 71 Lifetime lifetime(this); | |
| 72 BrowserThread::PostTask(BrowserThread::UI, | |
| 73 FROM_HERE, | |
| 74 base::Bind(&URLHelper::RunOnUIThread, | |
| 75 base::Unretained(this), | |
| 76 base::Passed(&lifetime))); | |
| 77 } | |
| 78 | |
| 79 private: | |
| 80 void RunOnUIThread(Lifetime lifetime) { | |
| 81 DCHECK_CURRENTLY_ON(BrowserThread::UI); | |
| 82 Profile* const profile = reinterpret_cast<Profile*>(profile_id_); | |
| 83 if (!g_browser_process->profile_manager()->IsValidProfile(profile)) { | |
| 84 ReplyResult(net::ERR_FAILED); | |
| 85 return; | |
| 86 } | |
| 87 content::StoragePartition* const storage = | |
| 88 content::BrowserContext::GetStoragePartitionForSite(profile, url_); | |
| 89 DCHECK(storage); | |
| 90 | |
| 91 scoped_refptr<storage::FileSystemContext> context = | |
| 92 storage->GetFileSystemContext(); | |
| 93 DCHECK(context.get()); | |
| 94 | |
| 95 // Obtain the absolute path in the file system. | |
| 96 base::FilePath path = drive::util::GetDriveMountPointPath(profile); | |
| 97 drive::util::GetDriveGrandRootPath().AppendRelativePath( | |
| 98 util::DriveURLToFilePath(url_), &path); | |
| 99 | |
| 100 storage::ExternalFileSystemBackend* const backend = | |
| 101 context->external_backend(); | |
| 102 DCHECK(backend); | |
| 103 | |
| 104 // Obtain the virtual path. | |
| 105 base::FilePath virtual_path; | |
| 106 if (!backend->GetVirtualPath(path, &virtual_path)) { | |
| 107 ReplyResult(net::ERR_FILE_NOT_FOUND); | |
| 108 return; | |
| 109 } | |
| 110 | |
| 111 // Obtain the file system URL. | |
| 112 // TODO(hirono): After removing MHTML support, stop to use the special | |
| 113 // drive: scheme and use filesystem: URL directly. crbug.com/415455 | |
| 114 file_system_url_ = context->CreateCrackedFileSystemURL( | |
| 115 GURL(std::string(chrome::kDriveScheme) + ":"), | |
| 116 storage::kFileSystemTypeExternal, | |
| 117 virtual_path); | |
| 118 if (!IsValidURL(file_system_url_)) { | |
| 119 ReplyResult(net::ERR_INVALID_URL); | |
| 120 return; | |
| 121 } | |
| 122 | |
| 123 file_system_context_ = context; | |
| 124 | |
| 125 extensions::app_file_handler_util::GetMimeTypeForLocalPath( | |
| 126 profile, | |
| 127 file_system_url_.path(), | |
| 128 base::Bind(&URLHelper::OnGotMimeTypeOnUIThread, | |
| 129 base::Unretained(this), | |
| 130 base::Passed(&lifetime))); | |
| 131 } | |
| 132 | |
| 133 void OnGotMimeTypeOnUIThread(Lifetime lifetime, | |
| 134 const std::string& mime_type) { | |
| 135 DCHECK_CURRENTLY_ON(BrowserThread::UI); | |
| 136 mime_type_ = mime_type; | |
| 137 | |
| 138 if (mime_type_ == kMimeTypeForRFC822) | |
| 139 mime_type_ = kMimeTypeForMHTML; | |
| 140 | |
| 141 ReplyResult(net::OK); | |
| 142 } | |
| 143 | |
| 144 void ReplyResult(net::Error error) { | |
| 145 DCHECK_CURRENTLY_ON(BrowserThread::UI); | |
| 146 | |
| 147 BrowserThread::PostTask(BrowserThread::IO, | |
| 148 FROM_HERE, | |
| 149 base::Bind(callback_, | |
| 150 error, | |
| 151 file_system_context_, | |
| 152 file_system_url_, | |
| 153 mime_type_)); | |
| 154 } | |
| 155 | |
| 156 void* const profile_id_; | |
| 157 const GURL url_; | |
| 158 const DriveURLRequestJob::HelperCallback callback_; | |
| 159 scoped_refptr<storage::FileSystemContext> file_system_context_; | |
| 160 storage::FileSystemURL file_system_url_; | |
| 161 std::string mime_type_; | |
| 162 | |
| 163 DISALLOW_COPY_AND_ASSIGN(URLHelper); | |
| 164 }; | |
| 165 | |
| 166 } // namespace | |
| 167 | |
| 168 DriveURLRequestJob::DriveURLRequestJob(void* profile_id, | |
| 169 net::URLRequest* request, | |
| 170 net::NetworkDelegate* network_delegate) | |
| 171 : net::URLRequestJob(request, network_delegate), | |
| 172 profile_id_(profile_id), | |
| 173 remaining_bytes_(0), | |
| 174 weak_ptr_factory_(this) { | |
| 175 } | |
| 176 | |
| 177 void DriveURLRequestJob::SetExtraRequestHeaders( | |
| 178 const net::HttpRequestHeaders& headers) { | |
| 179 std::string range_header; | |
| 180 if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) { | |
| 181 // Note: We only support single range requests. | |
| 182 std::vector<net::HttpByteRange> ranges; | |
| 183 if (net::HttpUtil::ParseRangeHeader(range_header, &ranges) && | |
| 184 ranges.size() == 1) { | |
| 185 byte_range_ = ranges[0]; | |
| 186 } else { | |
| 187 // Failed to parse Range: header, so notify the error. | |
| 188 NotifyDone( | |
| 189 net::URLRequestStatus(net::URLRequestStatus::FAILED, | |
| 190 net::ERR_REQUEST_RANGE_NOT_SATISFIABLE)); | |
| 191 } | |
| 192 } | |
| 193 } | |
| 194 | |
| 195 void DriveURLRequestJob::Start() { | |
| 196 DVLOG(1) << "Starting request"; | |
| 197 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
| 198 DCHECK(!stream_reader_); | |
| 199 | |
| 200 // We only support GET request. | |
| 201 if (request()->method() != "GET") { | |
| 202 LOG(WARNING) << "Failed to start request: " | |
| 203 << request()->method() << " method is not supported"; | |
| 204 NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED, | |
| 205 net::ERR_METHOD_NOT_SUPPORTED)); | |
| 206 return; | |
| 207 } | |
| 208 | |
| 209 // Check if the scheme is correct. | |
| 210 if (!request()->url().SchemeIs(chrome::kDriveScheme)) { | |
| 211 NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED, | |
| 212 net::ERR_INVALID_URL)); | |
| 213 return; | |
| 214 } | |
| 215 | |
| 216 // Owned by itself. | |
| 217 new URLHelper(profile_id_, | |
| 218 request()->url(), | |
| 219 base::Bind(&DriveURLRequestJob::OnHelperResultObtained, | |
| 220 weak_ptr_factory_.GetWeakPtr())); | |
| 221 } | |
| 222 | |
| 223 void DriveURLRequestJob::OnHelperResultObtained( | |
| 224 net::Error error, | |
| 225 const scoped_refptr<storage::FileSystemContext>& file_system_context, | |
| 226 const storage::FileSystemURL& file_system_url, | |
| 227 const std::string& mime_type) { | |
| 228 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
| 229 | |
| 230 if (error != net::OK) { | |
| 231 NotifyStartError( | |
| 232 net::URLRequestStatus(net::URLRequestStatus::FAILED, error)); | |
| 233 return; | |
| 234 } | |
| 235 | |
| 236 DCHECK(file_system_context.get()); | |
| 237 file_system_context_ = file_system_context; | |
| 238 file_system_url_ = file_system_url; | |
| 239 mime_type_ = mime_type; | |
| 240 | |
| 241 // Check if the entry has a redirect URL. | |
| 242 file_system_context_->external_backend()->GetRedirectURLForContents( | |
| 243 file_system_url_, | |
| 244 base::Bind(&DriveURLRequestJob::OnRedirectURLObtained, | |
| 245 weak_ptr_factory_.GetWeakPtr())); | |
| 246 } | |
| 247 | |
| 248 void DriveURLRequestJob::OnRedirectURLObtained(const GURL& redirect_url) { | |
| 249 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 250 redirect_url_ = redirect_url; | |
| 251 if (!redirect_url_.is_empty()) { | |
| 252 NotifyHeadersComplete(); | |
| 253 return; | |
| 254 } | |
| 255 | |
| 256 // Obtain file system context. | |
| 257 file_system_context_->operation_runner()->GetMetadata( | |
| 258 file_system_url_, | |
| 259 base::Bind(&DriveURLRequestJob::OnFileInfoObtained, | |
| 260 weak_ptr_factory_.GetWeakPtr())); | |
| 261 } | |
| 262 | |
| 263 void DriveURLRequestJob::OnFileInfoObtained(base::File::Error result, | |
| 264 const base::File::Info& file_info) { | |
| 265 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 266 | |
| 267 if (result == base::File::FILE_ERROR_NOT_FOUND) { | |
| 268 NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED, | |
| 269 net::ERR_FILE_NOT_FOUND)); | |
| 270 return; | |
| 271 } | |
| 272 | |
| 273 if (result != base::File::FILE_OK || file_info.is_directory || | |
| 274 file_info.size < 0) { | |
| 275 NotifyStartError( | |
| 276 net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED)); | |
| 277 return; | |
| 278 } | |
| 279 | |
| 280 // Compute content size. | |
| 281 if (!byte_range_.ComputeBounds(file_info.size)) { | |
| 282 NotifyStartError(net::URLRequestStatus( | |
| 283 net::URLRequestStatus::FAILED, net::ERR_REQUEST_RANGE_NOT_SATISFIABLE)); | |
| 284 return; | |
| 285 } | |
| 286 const int64 offset = byte_range_.first_byte_position(); | |
| 287 const int64 size = | |
| 288 byte_range_.last_byte_position() + 1 - byte_range_.first_byte_position(); | |
| 289 set_expected_content_size(size); | |
| 290 remaining_bytes_ = size; | |
| 291 | |
| 292 // Create file stream reader. | |
| 293 stream_reader_ = file_system_context_->CreateFileStreamReader( | |
| 294 file_system_url_, offset, size, base::Time()); | |
| 295 if (!stream_reader_) { | |
| 296 NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED, | |
| 297 net::ERR_FILE_NOT_FOUND)); | |
| 298 return; | |
| 299 } | |
| 300 | |
| 301 NotifyHeadersComplete(); | |
| 302 } | |
| 303 | |
| 304 void DriveURLRequestJob::Kill() { | |
| 305 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 306 | |
| 307 stream_reader_.reset(); | |
| 308 file_system_context_ = NULL; | |
| 309 net::URLRequestJob::Kill(); | |
| 310 weak_ptr_factory_.InvalidateWeakPtrs(); | |
| 311 } | |
| 312 | |
| 313 bool DriveURLRequestJob::GetMimeType(std::string* mime_type) const { | |
| 314 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 315 mime_type->assign(mime_type_); | |
| 316 return !mime_type->empty(); | |
| 317 } | |
| 318 | |
| 319 bool DriveURLRequestJob::IsRedirectResponse( | |
| 320 GURL* location, int* http_status_code) { | |
| 321 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 322 if (redirect_url_.is_empty()) | |
| 323 return false; | |
| 324 | |
| 325 // Redirect a hosted document. | |
| 326 *location = redirect_url_; | |
| 327 const int kHttpFound = 302; | |
| 328 *http_status_code = kHttpFound; | |
| 329 return true; | |
| 330 } | |
| 331 | |
| 332 bool DriveURLRequestJob::ReadRawData( | |
| 333 net::IOBuffer* buf, int buf_size, int* bytes_read) { | |
| 334 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 335 DCHECK(stream_reader_); | |
| 336 | |
| 337 if (remaining_bytes_ == 0) { | |
| 338 *bytes_read = 0; | |
| 339 return true; | |
| 340 } | |
| 341 | |
| 342 const int result = | |
| 343 stream_reader_->Read(buf, | |
| 344 std::min<int64>(buf_size, remaining_bytes_), | |
| 345 base::Bind(&DriveURLRequestJob::OnReadCompleted, | |
| 346 weak_ptr_factory_.GetWeakPtr())); | |
| 347 | |
| 348 if (result == net::ERR_IO_PENDING) { | |
| 349 // The data is not yet available. | |
| 350 SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0)); | |
| 351 return false; | |
| 352 } | |
| 353 if (result < 0) { | |
| 354 // An error occurs. | |
| 355 NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result)); | |
| 356 return false; | |
| 357 } | |
| 358 | |
| 359 // Reading has been finished immediately. | |
| 360 *bytes_read = result; | |
| 361 remaining_bytes_ -= result; | |
| 362 return true; | |
| 363 } | |
| 364 | |
| 365 DriveURLRequestJob::~DriveURLRequestJob() { | |
| 366 } | |
| 367 | |
| 368 void DriveURLRequestJob::OnReadCompleted(int read_result) { | |
| 369 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 370 | |
| 371 if (read_result < 0) { | |
| 372 DCHECK_NE(read_result, net::ERR_IO_PENDING); | |
| 373 NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, | |
| 374 read_result)); | |
| 375 } | |
| 376 | |
| 377 remaining_bytes_ -= read_result; | |
| 378 SetStatus(net::URLRequestStatus()); // Clear the IO_PENDING status. | |
| 379 NotifyReadComplete(read_result); | |
| 380 } | |
| 381 | |
| 382 } // namespace drive | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 580023003:
Rename the drive: scheme with the externalfile: scheme. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master