chromeos: Replace resource ID in drive URL with path

chrome/browser/chromeos/drive/drive_url_request_job.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/drive/drive_url_request_job.h"
 
 #include <algorithm>
 #include <cstring>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_interface.h"
+#include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/drive/drive_system_service.h"
 #include "chrome/browser/google_apis/base_operations.h"
 #include "chrome/browser/google_apis/task_util.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 #include "net/base/file_stream.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
@@ skipping 32 matching lines @@
 };
 
 std::string FixupMimeType(const std::string& type) {
   for (size_t i = 0; i < arraysize(kMimeTypeReplacements); i++) {
     if (type == kMimeTypeReplacements[i].original_type)
       return kMimeTypeReplacements[i].new_type;
   }
   return type;
 }
 
-// Helper function that extracts and unescapes resource_id from drive urls
-// (drive:<resource_id>).
-bool ParseDriveUrl(const std::string& path, std::string* resource_id) {
-  const std::string drive_schema(chrome::kDriveScheme + std::string(":"));
-  if (!StartsWithASCII(path, drive_schema, false) ||
-      path.size() <= drive_schema.size()) {
-    return false;
-  }
-
-  std::string id = path.substr(drive_schema.size());
-  *resource_id = net::UnescapeURLComponent(id, kUrlPathUnescapeMask);
-  return resource_id->size();
-}
-
 // Helper function to cancel Drive download operation on UI thread.
 void CancelDriveDownloadOnUIThread(
     const DriveURLRequestJob::DriveFileSystemGetter& file_system_getter,
     const base::FilePath& drive_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileSystemInterface* file_system = file_system_getter.Run();
   if (file_system) {
     file_system->CancelGetFile(drive_file_path);
   }
 }
 
 // Cancels the Drive download operation. The actually task is run on UI thread
 // asynchronously, but this method itself is designed to be run on IO thread.
 void CancelDriveDownload(
     const DriveURLRequestJob::DriveFileSystemGetter& file_system_getter,
     const base::FilePath& drive_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&CancelDriveDownloadOnUIThread,
                  file_system_getter, drive_file_path));
 }
 
-// Helper function to call DriveFileSystem::GetEntryInfoByResourceId.
-void GetEntryInfoByResourceIdOnUIThread(
+// Helper function to call DriveFileSystem::GetEntryInfoByPath.
+void GetEntryInfoByPathOnUIThread(
     const DriveURLRequestJob::DriveFileSystemGetter& file_system_getter,
-    const std::string& resource_id,
-    const drive::GetEntryInfoWithFilePathCallback& callback) {
+    const base::FilePath& path,
+    const drive::GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileSystemInterface* file_system = file_system_getter.Run();
   if (!file_system) {
-    callback.Run(DRIVE_FILE_ERROR_FAILED,
-                 base::FilePath(),
-                 scoped_ptr<DriveEntryProto>());
+    callback.Run(DRIVE_FILE_ERROR_FAILED, scoped_ptr<DriveEntryProto>());
     return;
   }
-  file_system->GetEntryInfoByResourceId(resource_id, callback);
+  file_system->GetEntryInfoByPath(path, callback);
 }
 
-// Returns the entry info for the |resource_id| on DriveFileSystem returned by
+// Returns the entry info for the |path| on DriveFileSystem returned by
 // |file_system_getter| via |callback|.
 // The main task will be done on UI thread, but this method itself is designed
 // to be run on IO thread. Also the |callback| will be run on IO thread, too.
-void GetEntryInfoByResourceId(
+void GetEntryInfoByPath(
     const DriveURLRequestJob::DriveFileSystemGetter& file_system_getter,
-    const std::string& resource_id,
-    const drive::GetEntryInfoWithFilePathCallback& callback) {
+    const base::FilePath& path,
+    const drive::GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&GetEntryInfoByResourceIdOnUIThread,
+      base::Bind(&GetEntryInfoByPathOnUIThread,
                  file_system_getter,
-                 resource_id,
+                 path,
                  google_apis::CreateRelayCallback(callback)));
 }
 
 // Helper function to call DriveFileSystem::GetFileByResourceId.
 void GetFileByResourceIdOnUIThread(
     const DriveURLRequestJob::DriveFileSystemGetter& file_system_getter,
     const std::string& resource_id,
     const drive::GetFileCallback& get_file_callback,
     const google_apis::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 100 matching lines @@
   // - gotten size of physical file if file exists in cache.
 
   // We only support GET request.
   if (request()->method() != "GET") {
     LOG(WARNING) << "Failed to start request: "
                  << request()->method() << " method is not supported";
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_METHOD_NOT_SUPPORTED));
     return;
   }
-
-  std::string resource_id;
-  if (!ParseDriveUrl(request_->url().spec(), &resource_id)) {
-    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                           net::ERR_INVALID_URL));
-    return;
-  }
-
-  GetEntryInfoByResourceId(
-      file_system_getter_,
-      resource_id,
-      base::Bind(&DriveURLRequestJob::OnGetEntryInfoByResourceId,
-                 weak_ptr_factory_.GetWeakPtr(), resource_id));
+  GetEntryInfoByPath(file_system_getter_,
+                     util::DriveURLToFilePath(request_->url()),
+                     base::Bind(&DriveURLRequestJob::OnGetEntryInfoByPath,
+                                weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DriveURLRequestJob::Kill() {
   DVLOG(1) << "Killing request";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   CloseFileStream();
 
   // If download operation for drive file (via
   // DriveFileSystem::GetFileByResourceId) is still in progress, cancel it by
@@ skipping 140 matching lines @@
 }
 
 //======================= DriveURLRequestJob protected methods ================
 
 DriveURLRequestJob::~DriveURLRequestJob() {
   CloseFileStream();
 }
 
 //======================= DriveURLRequestJob private methods ===================
 
-void DriveURLRequestJob::OnGetEntryInfoByResourceId(
-    const std::string& resource_id,
+void DriveURLRequestJob::OnGetEntryInfoByPath(
     DriveFileError error,
-    const base::FilePath& drive_file_path,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
     error = DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error == DRIVE_FILE_OK) {
-    DCHECK(entry_proto.get());
-    mime_type_ = entry_proto->file_specific_info().content_mime_type();
-    drive_file_path_ = drive_file_path;
-    initial_file_size_ = entry_proto->file_info().size();
-  } else {
+  if (error != DRIVE_FILE_OK) {
     mime_type_.clear();
     drive_file_path_.clear();
     initial_file_size_ = 0;
+    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                           net::ERR_FILE_NOT_FOUND));
+    return;
   }
+  DCHECK(entry_proto.get());
+  mime_type_ = entry_proto->file_specific_info().content_mime_type();
+  drive_file_path_ = util::DriveURLToFilePath(request_->url());
+  initial_file_size_ = entry_proto->file_info().size();
   remaining_bytes_ = initial_file_size_;
 
   DVLOG(1) << "Getting file for resource id";
   GetFileByResourceId(
       file_system_getter_,
-      resource_id,
+      entry_proto->resource_id(),
       base::Bind(&DriveURLRequestJob::OnGetFileByResourceId,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&DriveURLRequestJob::OnUrlFetchDownloadData,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DriveURLRequestJob::OnUrlFetchDownloadData(
     google_apis::GDataErrorCode error,
     scoped_ptr<std::string> download_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 331 matching lines @@
   response_info_.reset(new net::HttpResponseInfo());
   response_info_->headers = headers;
 
   set_expected_content_size(remaining_bytes_);
   headers_set_ = true;
 
   NotifyHeadersComplete();
 }
 
 }  // namespace drive