1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/sync_file_system/drive_backend/fake_drive_uploader.h"
#include "base/check.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/notreached.h"
#include "base/run_loop.h"
#include "base/task/single_thread_task_runner.h"
#include "google_apis/drive/drive_api_parser.h"
#include "google_apis/drive/drive_common_callbacks.h"
#include "testing/gtest/include/gtest/gtest.h"
using drive::FakeDriveService;
using drive::UploadCompletionCallback;
using google_apis::ApiErrorCode;
using google_apis::CancelCallbackOnce;
using google_apis::FileResource;
using google_apis::FileResourceCallback;
using google_apis::ProgressCallback;
namespace sync_file_system {
namespace drive_backend {
namespace {
void DidAddFileOrDirectoryForMakingConflict(
ApiErrorCode error,
std::unique_ptr<FileResource> entry) {
ASSERT_EQ(google_apis::HTTP_CREATED, error);
ASSERT_TRUE(entry);
}
void DidAddFileForUploadNew(UploadCompletionCallback callback,
ApiErrorCode error,
std::unique_ptr<FileResource> entry) {
ASSERT_EQ(google_apis::HTTP_CREATED, error);
ASSERT_TRUE(entry);
base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), google_apis::HTTP_SUCCESS,
GURL(), std::move(entry)));
}
void DidGetFileResourceForUploadExisting(UploadCompletionCallback callback,
ApiErrorCode error,
std::unique_ptr<FileResource> entry) {
base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE,
base::BindOnce(std::move(callback), error, GURL(), std::move(entry)));
}
} // namespace
FakeDriveServiceWrapper::FakeDriveServiceWrapper()
: make_directory_conflict_(false) {}
FakeDriveServiceWrapper::~FakeDriveServiceWrapper() = default;
CancelCallbackOnce FakeDriveServiceWrapper::AddNewDirectory(
const std::string& parent_resource_id,
const std::string& directory_name,
const drive::AddNewDirectoryOptions& options,
FileResourceCallback callback) {
if (make_directory_conflict_) {
FakeDriveService::AddNewDirectory(
parent_resource_id, directory_name, options,
base::BindOnce(&DidAddFileOrDirectoryForMakingConflict));
}
return FakeDriveService::AddNewDirectory(parent_resource_id, directory_name,
options, std::move(callback));
}
FakeDriveUploader::FakeDriveUploader(
FakeDriveServiceWrapper* fake_drive_service)
: fake_drive_service_(fake_drive_service), make_file_conflict_(false) {}
FakeDriveUploader::~FakeDriveUploader() = default;
void FakeDriveUploader::StartBatchProcessing() {}
void FakeDriveUploader::StopBatchProcessing() {}
CancelCallbackOnce FakeDriveUploader::UploadNewFile(
const std::string& parent_resource_id,
const base::FilePath& local_file_path,
const std::string& title,
const std::string& content_type,
const drive::UploadNewFileOptions& options,
UploadCompletionCallback callback,
ProgressCallback progress_callback) {
DCHECK(!callback.is_null());
const std::string kFileContent = "test content";
if (make_file_conflict_) {
fake_drive_service_->AddNewFile(
content_type, kFileContent, parent_resource_id, title,
false, // shared_with_me
base::BindOnce(&DidAddFileOrDirectoryForMakingConflict));
}
fake_drive_service_->AddNewFile(
content_type, kFileContent, parent_resource_id, title,
false, // shared_with_me
base::BindOnce(&DidAddFileForUploadNew, std::move(callback)));
base::RunLoop().RunUntilIdle();
return CancelCallbackOnce();
}
CancelCallbackOnce FakeDriveUploader::UploadExistingFile(
const std::string& resource_id,
const base::FilePath& local_file_path,
const std::string& content_type,
const drive::UploadExistingFileOptions& options,
UploadCompletionCallback callback,
ProgressCallback progress_callback) {
DCHECK(!callback.is_null());
fake_drive_service_->GetFileResource(
resource_id, base::BindOnce(&DidGetFileResourceForUploadExisting,
std::move(callback)));
return CancelCallbackOnce();
}
CancelCallbackOnce FakeDriveUploader::ResumeUploadFile(
const GURL& upload_location,
const base::FilePath& local_file_path,
const std::string& content_type,
drive::UploadCompletionCallback callback,
ProgressCallback progress_callback) {
// At the moment, sync file system doesn't support resuming of the uploading.
// So this method shouldn't be reached.
NOTREACHED();
}
} // namespace drive_backend
} // namespace sync_file_system
|
