src/chrome/browser/sync_file_system/drive_backend/fake_drive_uploader.cc

   1 // Copyright 2014 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/sync_file_system/drive_backend/fake_drive_uploader.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/thread_task_runner_handle.h"
  12 #include "google_apis/drive/drive_api_parser.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using drive::FakeDriveService;
  16 using drive::UploadCompletionCallback;
  17 using google_apis::CancelCallback;
  18 using google_apis::FileResource;
  19 using google_apis::FileResourceCallback;
  20 using google_apis::GDataErrorCode;
  21 using google_apis::ProgressCallback;
  22
  23 namespace sync_file_system {
  24 namespace drive_backend {
  25
  26 namespace {
  27
  28 void DidAddFileOrDirectoryForMakingConflict(GDataErrorCode error,
  29                                             scoped_ptr<FileResource> entry) {
  30   ASSERT_EQ(google_apis::HTTP_CREATED, error);
  31   ASSERT_TRUE(entry);
  32 }
  33
  34 void DidAddFileForUploadNew(
  35     const UploadCompletionCallback& callback,
  36     GDataErrorCode error,
  37     scoped_ptr<FileResource> entry) {
  38   ASSERT_EQ(google_apis::HTTP_CREATED, error);
  39   ASSERT_TRUE(entry);
  40   base::ThreadTaskRunnerHandle::Get()->PostTask(
  41       FROM_HERE,
  42       base::Bind(callback,
  43                  google_apis::HTTP_SUCCESS,
  44                  GURL(),
  45                  base::Passed(&entry)));
  46 }
  47
  48 void DidGetFileResourceForUploadExisting(
  49     const UploadCompletionCallback& callback,
  50     GDataErrorCode error,
  51     scoped_ptr<FileResource> entry) {
  52   base::ThreadTaskRunnerHandle::Get()->PostTask(
  53       FROM_HERE,
  54       base::Bind(callback,
  55                  error,
  56                  GURL(),
  57                  base::Passed(&entry)));
  58 }
  59
  60 }  // namespace
  61
  62 FakeDriveServiceWrapper::FakeDriveServiceWrapper()
  63   : make_directory_conflict_(false) {}
  64
  65 FakeDriveServiceWrapper::~FakeDriveServiceWrapper() {}
  66
  67 CancelCallback FakeDriveServiceWrapper::AddNewDirectory(
  68     const std::string& parent_resource_id,
  69     const std::string& directory_name,
  70     const AddNewDirectoryOptions& options,
  71     const FileResourceCallback& callback) {
  72   if (make_directory_conflict_) {
  73     FakeDriveService::AddNewDirectory(
  74         parent_resource_id,
  75         directory_name,
  76         options,
  77         base::Bind(&DidAddFileOrDirectoryForMakingConflict));
  78   }
  79   return FakeDriveService::AddNewDirectory(
  80       parent_resource_id, directory_name, options, callback);
  81 }
  82
  83 FakeDriveUploader::FakeDriveUploader(
  84     FakeDriveServiceWrapper* fake_drive_service)
  85     : fake_drive_service_(fake_drive_service),
  86       make_file_conflict_(false) {}
  87
  88 FakeDriveUploader::~FakeDriveUploader() {}
  89
  90 CancelCallback FakeDriveUploader::UploadNewFile(
  91     const std::string& parent_resource_id,
  92     const base::FilePath& local_file_path,
  93     const std::string& title,
  94     const std::string& content_type,
  95     const UploadNewFileOptions& options,
  96     const UploadCompletionCallback& callback,
  97     const ProgressCallback& progress_callback) {
  98   DCHECK(!callback.is_null());
  99   const std::string kFileContent = "test content";
 100
 101   if (make_file_conflict_) {
 102     fake_drive_service_->AddNewFile(
 103         content_type,
 104         kFileContent,
 105         parent_resource_id,
 106         title,
 107         false,  // shared_with_me
 108         base::Bind(&DidAddFileOrDirectoryForMakingConflict));
 109   }
 110
 111   fake_drive_service_->AddNewFile(
 112       content_type,
 113       kFileContent,
 114       parent_resource_id,
 115       title,
 116       false,  // shared_with_me
 117       base::Bind(&DidAddFileForUploadNew, callback));
 118   base::MessageLoop::current()->RunUntilIdle();
 119
 120   return CancelCallback();
 121 }
 122
 123 CancelCallback FakeDriveUploader::UploadExistingFile(
 124     const std::string& resource_id,
 125     const base::FilePath& local_file_path,
 126     const std::string& content_type,
 127     const UploadExistingFileOptions& options,
 128     const UploadCompletionCallback& callback,
 129     const ProgressCallback& progress_callback) {
 130   DCHECK(!callback.is_null());
 131   return fake_drive_service_->GetFileResource(
 132       resource_id,
 133       base::Bind(&DidGetFileResourceForUploadExisting, callback));
 134 }
 135
 136 CancelCallback FakeDriveUploader::ResumeUploadFile(
 137     const GURL& upload_location,
 138     const base::FilePath& local_file_path,
 139     const std::string& content_type,
 140     const UploadCompletionCallback& callback,
 141     const ProgressCallback& progress_callback) {
 142   // At the moment, sync file system doesn't support resuming of the uploading.
 143   // So this method shouldn't be reached.
 144   NOTREACHED();
 145   return CancelCallback();
 146 }
 147
 148 }  // namespace drive_backend
 149 }  // namespace sync_file_system