| // Copyright (c) 2012 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 "google_apis/drive/drive_api_requests.h" |
| |
| #include <stddef.h> |
| |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/callback.h" |
| #include "base/callback_helpers.h" |
| #include "base/json/json_writer.h" |
| #include "base/location.h" |
| #include "base/metrics/histogram_functions.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/string_piece.h" |
| #include "base/strings/string_split.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/task/sequenced_task_runner.h" |
| #include "base/task/task_runner_util.h" |
| #include "base/values.h" |
| #include "google_apis/common/request_sender.h" |
| #include "google_apis/common/time_util.h" |
| #include "google_apis/drive/request_util.h" |
| #include "net/base/url_util.h" |
| #include "net/http/http_response_headers.h" |
| #include "services/network/public/mojom/url_response_head.mojom.h" |
| |
| namespace google_apis { |
| namespace drive { |
| namespace { |
| |
| // Format of one request in batch uploading request. |
| const char kBatchUploadRequestFormat[] = |
| "%s %s HTTP/1.1\n" |
| "Host: %s\n" |
| "X-Goog-Upload-Protocol: multipart\n" |
| "Content-Type: %s\n" |
| "\n"; |
| |
| // Request header for specifying batch upload. |
| const char kBatchUploadHeader[] = "X-Goog-Upload-Protocol: batch"; |
| |
| // Content type of HTTP request. |
| const char kHttpContentType[] = "application/http"; |
| |
| // Break line in HTTP message. |
| const char kHttpBr[] = "\r\n"; |
| |
| // Mime type of multipart mixed. |
| const char kMultipartMixedMimeTypePrefix[] = "multipart/mixed; boundary="; |
| |
| // UMA names. |
| const char kUMADriveTotalFileCountInBatchUpload[] = |
| "Drive.TotalFileCountInBatchUpload"; |
| const char kUMADriveTotalFileSizeInBatchUpload[] = |
| "Drive.TotalFileSizeInBatchUpload"; |
| |
| // Parses the JSON value to FileResource instance and runs |callback| on the |
| // UI thread once parsing is done. |
| // This is customized version of ParseJsonAndRun defined above to adapt the |
| // remaining response type. |
| void ParseFileResourceWithUploadRangeAndRun( |
| UploadRangeCallback callback, |
| const UploadRangeResponse& response, |
| std::unique_ptr<base::Value> value) { |
| DCHECK(!callback.is_null()); |
| |
| std::unique_ptr<FileResource> file_resource; |
| if (value) { |
| file_resource = FileResource::CreateFrom(*value); |
| if (!file_resource) { |
| std::move(callback).Run( |
| UploadRangeResponse(PARSE_ERROR, response.start_position_received, |
| response.end_position_received), |
| std::unique_ptr<FileResource>()); |
| return; |
| } |
| } |
| |
| std::move(callback).Run(response, std::move(file_resource)); |
| } |
| |
| // Attaches |properties| to the |request_body| if |properties| is not empty. |
| // |request_body| must not be NULL. |
| void AttachProperties(const Properties& properties, |
| base::DictionaryValue* request_body) { |
| DCHECK(request_body); |
| if (properties.empty()) |
| return; |
| |
| base::Value::List properties_value; |
| for (const auto& property : properties) { |
| base::Value::Dict property_value; |
| std::string visibility_as_string; |
| switch (property.visibility()) { |
| case Property::VISIBILITY_PRIVATE: |
| visibility_as_string = "PRIVATE"; |
| break; |
| case Property::VISIBILITY_PUBLIC: |
| visibility_as_string = "PUBLIC"; |
| break; |
| } |
| property_value.Set("visibility", visibility_as_string); |
| property_value.Set("key", property.key()); |
| property_value.Set("value", property.value()); |
| properties_value.Append(std::move(property_value)); |
| } |
| request_body->SetKey("properties", base::Value(std::move(properties_value))); |
| } |
| |
| // Creates metadata JSON string for multipart uploading. |
| // All the values are optional. If the value is empty or null, the value does |
| // not appear in the metadata. |
| std::string CreateMultipartUploadMetadataJson( |
| const std::string& title, |
| const std::string& parent_resource_id, |
| const base::Time& modified_date, |
| const base::Time& last_viewed_by_me_date, |
| const Properties& properties) { |
| base::DictionaryValue root; |
| if (!title.empty()) |
| root.SetString("title", title); |
| |
| // Fill parent link. |
| if (!parent_resource_id.empty()) { |
| base::Value::List parents; |
| parents.Append(base::Value::FromUniquePtrValue( |
| google_apis::util::CreateParentValue(parent_resource_id))); |
| root.SetKey("parents", base::Value(std::move(parents))); |
| } |
| |
| if (!modified_date.is_null()) { |
| root.SetString("modifiedDate", |
| google_apis::util::FormatTimeAsString(modified_date)); |
| } |
| |
| if (!last_viewed_by_me_date.is_null()) { |
| root.SetString("lastViewedByMeDate", google_apis::util::FormatTimeAsString( |
| last_viewed_by_me_date)); |
| } |
| |
| AttachProperties(properties, &root); |
| std::string json_string; |
| base::JSONWriter::Write(root, &json_string); |
| return json_string; |
| } |
| |
| } // namespace |
| |
| MultipartHttpResponse::MultipartHttpResponse() = default; |
| |
| MultipartHttpResponse::~MultipartHttpResponse() = default; |
| |
| // The |response| must be multipart/mixed format that contains child HTTP |
| // response of drive batch request. |
| // https://www.ietf.org/rfc/rfc2046.txt |
| // |
| // It looks like: |
| // --Boundary |
| // Content-type: application/http |
| // |
| // HTTP/1.1 200 OK |
| // Header of child response |
| // |
| // Body of child response |
| // --Boundary |
| // Content-type: application/http |
| // |
| // HTTP/1.1 404 Not Found |
| // Header of child response |
| // |
| // Body of child response |
| // --Boundary-- |
| bool ParseMultipartResponse(const std::string& content_type, |
| const std::string& response, |
| std::vector<MultipartHttpResponse>* parts) { |
| if (response.empty()) |
| return false; |
| |
| base::StringPiece content_type_piece(content_type); |
| if (!base::StartsWith(content_type_piece, kMultipartMixedMimeTypePrefix)) { |
| return false; |
| } |
| content_type_piece.remove_prefix( |
| base::StringPiece(kMultipartMixedMimeTypePrefix).size()); |
| |
| if (content_type_piece.empty()) |
| return false; |
| if (content_type_piece[0] == '"') { |
| if (content_type_piece.size() <= 2 || content_type_piece.back() != '"') |
| return false; |
| |
| content_type_piece = |
| content_type_piece.substr(1, content_type_piece.size() - 2); |
| } |
| |
| std::string boundary(content_type_piece); |
| const std::string header = "--" + boundary; |
| const std::string terminator = "--" + boundary + "--"; |
| |
| std::vector<base::StringPiece> lines = base::SplitStringPieceUsingSubstr( |
| response, kHttpBr, base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL); |
| |
| enum { |
| STATE_START, |
| STATE_PART_HEADER, |
| STATE_PART_HTTP_STATUS_LINE, |
| STATE_PART_HTTP_HEADER, |
| STATE_PART_HTTP_BODY |
| } state = STATE_START; |
| |
| const std::string kHttpStatusPrefix = "HTTP/1.1 "; |
| std::vector<MultipartHttpResponse> responses; |
| ApiErrorCode code = PARSE_ERROR; |
| std::string body; |
| for (const auto& line : lines) { |
| if (state == STATE_PART_HEADER && line.empty()) { |
| state = STATE_PART_HTTP_STATUS_LINE; |
| continue; |
| } |
| |
| if (state == STATE_PART_HTTP_STATUS_LINE) { |
| if (base::StartsWith(line, kHttpStatusPrefix)) { |
| int int_code; |
| base::StringToInt( |
| line.substr(base::StringPiece(kHttpStatusPrefix).size()), |
| &int_code); |
| if (int_code > 0) |
| code = static_cast<ApiErrorCode>(int_code); |
| else |
| code = PARSE_ERROR; |
| } else { |
| code = PARSE_ERROR; |
| } |
| state = STATE_PART_HTTP_HEADER; |
| continue; |
| } |
| |
| if (state == STATE_PART_HTTP_HEADER && line.empty()) { |
| state = STATE_PART_HTTP_BODY; |
| body.clear(); |
| continue; |
| } |
| const base::StringPiece chopped_line = |
| base::TrimString(line, " \t", base::TRIM_TRAILING); |
| const bool is_new_part = chopped_line == header; |
| const bool was_last_part = chopped_line == terminator; |
| if (is_new_part || was_last_part) { |
| switch (state) { |
| case STATE_START: |
| break; |
| case STATE_PART_HEADER: |
| case STATE_PART_HTTP_STATUS_LINE: |
| responses.emplace_back(); |
| responses.back().code = PARSE_ERROR; |
| break; |
| case STATE_PART_HTTP_HEADER: |
| responses.emplace_back(); |
| responses.back().code = code; |
| break; |
| case STATE_PART_HTTP_BODY: |
| // Drop the last kHttpBr. |
| if (!body.empty()) |
| body.resize(body.size() - 2); |
| responses.emplace_back(); |
| responses.back().code = code; |
| responses.back().body.swap(body); |
| break; |
| } |
| if (is_new_part) |
| state = STATE_PART_HEADER; |
| if (was_last_part) |
| break; |
| } else if (state == STATE_PART_HTTP_BODY) { |
| base::StrAppend(&body, {line, kHttpBr}); |
| } |
| } |
| |
| parts->swap(responses); |
| return true; |
| } |
| |
| Property::Property() : visibility_(VISIBILITY_PRIVATE) {} |
| |
| Property::~Property() = default; |
| |
| //============================ DriveApiPartialFieldRequest ==================== |
| |
| DriveApiPartialFieldRequest::DriveApiPartialFieldRequest(RequestSender* sender) |
| : DriveUrlFetchRequestBase(sender, ProgressCallback(), ProgressCallback()) { |
| } |
| |
| DriveApiPartialFieldRequest::~DriveApiPartialFieldRequest() = default; |
| |
| GURL DriveApiPartialFieldRequest::GetURL() const { |
| GURL url = GetURLInternal(); |
| if (!fields_.empty()) |
| url = net::AppendOrReplaceQueryParameter(url, "fields", fields_); |
| return url; |
| } |
| |
| //=============================== FilesGetRequest ============================= |
| |
| FilesGetRequest::FilesGetRequest(RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| FileResourceCallback callback) |
| : DriveApiDataRequest<FileResource>(sender, std::move(callback)), |
| url_generator_(url_generator) {} |
| |
| FilesGetRequest::~FilesGetRequest() {} |
| |
| GURL FilesGetRequest::GetURLInternal() const { |
| return url_generator_.GetFilesGetUrl(file_id_, embed_origin_); |
| } |
| |
| //============================ FilesInsertRequest ============================ |
| |
| FilesInsertRequest::FilesInsertRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| FileResourceCallback callback) |
| : DriveApiDataRequest<FileResource>(sender, std::move(callback)), |
| url_generator_(url_generator), |
| visibility_(FILE_VISIBILITY_DEFAULT) {} |
| |
| FilesInsertRequest::~FilesInsertRequest() {} |
| |
| std::string FilesInsertRequest::GetRequestType() const { |
| return "POST"; |
| } |
| |
| bool FilesInsertRequest::GetContentData(std::string* upload_content_type, |
| std::string* upload_content) { |
| *upload_content_type = util::kContentTypeApplicationJson; |
| |
| base::DictionaryValue root; |
| |
| if (!last_viewed_by_me_date_.is_null()) { |
| root.SetString("lastViewedByMeDate", |
| util::FormatTimeAsString(last_viewed_by_me_date_)); |
| } |
| |
| if (!mime_type_.empty()) |
| root.SetString("mimeType", mime_type_); |
| |
| if (!modified_date_.is_null()) |
| root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_)); |
| |
| if (!parents_.empty()) { |
| base::Value::List parents_value; |
| for (size_t i = 0; i < parents_.size(); ++i) { |
| base::Value::Dict parent; |
| parent.Set("id", parents_[i]); |
| parents_value.Append(std::move(parent)); |
| } |
| root.SetKey("parents", base::Value(std::move(parents_value))); |
| } |
| |
| if (!title_.empty()) |
| root.SetString("title", title_); |
| |
| AttachProperties(properties_, &root); |
| base::JSONWriter::Write(root, upload_content); |
| |
| DVLOG(1) << "FilesInsert data: " << *upload_content_type << ", [" |
| << *upload_content << "]"; |
| return true; |
| } |
| |
| GURL FilesInsertRequest::GetURLInternal() const { |
| return url_generator_.GetFilesInsertUrl( |
| visibility_ == FILE_VISIBILITY_PRIVATE ? "PRIVATE" : ""); |
| } |
| |
| //============================== FilesPatchRequest ============================ |
| |
| FilesPatchRequest::FilesPatchRequest(RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| FileResourceCallback callback) |
| : DriveApiDataRequest<FileResource>(sender, std::move(callback)), |
| url_generator_(url_generator), |
| set_modified_date_(false), |
| update_viewed_date_(true) {} |
| |
| FilesPatchRequest::~FilesPatchRequest() {} |
| |
| std::string FilesPatchRequest::GetRequestType() const { |
| return "PATCH"; |
| } |
| |
| std::vector<std::string> FilesPatchRequest::GetExtraRequestHeaders() const { |
| std::vector<std::string> headers; |
| headers.push_back(util::kIfMatchAllHeader); |
| return headers; |
| } |
| |
| GURL FilesPatchRequest::GetURLInternal() const { |
| return url_generator_.GetFilesPatchUrl(file_id_, set_modified_date_, |
| update_viewed_date_); |
| } |
| |
| bool FilesPatchRequest::GetContentData(std::string* upload_content_type, |
| std::string* upload_content) { |
| if (title_.empty() && modified_date_.is_null() && |
| last_viewed_by_me_date_.is_null() && parents_.empty()) |
| return false; |
| |
| *upload_content_type = util::kContentTypeApplicationJson; |
| |
| base::DictionaryValue root; |
| if (!title_.empty()) |
| root.SetString("title", title_); |
| |
| if (!modified_date_.is_null()) |
| root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_)); |
| |
| if (!last_viewed_by_me_date_.is_null()) { |
| root.SetString("lastViewedByMeDate", |
| util::FormatTimeAsString(last_viewed_by_me_date_)); |
| } |
| |
| if (!parents_.empty()) { |
| base::Value::List parents_value; |
| for (size_t i = 0; i < parents_.size(); ++i) { |
| base::Value::Dict parent; |
| parent.Set("id", parents_[i]); |
| parents_value.Append(std::move(parent)); |
| } |
| root.SetKey("parents", base::Value(std::move(parents_value))); |
| } |
| |
| AttachProperties(properties_, &root); |
| base::JSONWriter::Write(root, upload_content); |
| |
| DVLOG(1) << "FilesPatch data: " << *upload_content_type << ", [" |
| << *upload_content << "]"; |
| return true; |
| } |
| |
| //============================= FilesCopyRequest ============================== |
| |
| FilesCopyRequest::FilesCopyRequest(RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| FileResourceCallback callback) |
| : DriveApiDataRequest<FileResource>(sender, std::move(callback)), |
| url_generator_(url_generator), |
| visibility_(FILE_VISIBILITY_DEFAULT) {} |
| |
| FilesCopyRequest::~FilesCopyRequest() = default; |
| |
| std::string FilesCopyRequest::GetRequestType() const { |
| return "POST"; |
| } |
| |
| GURL FilesCopyRequest::GetURLInternal() const { |
| return url_generator_.GetFilesCopyUrl( |
| file_id_, visibility_ == FILE_VISIBILITY_PRIVATE ? "PRIVATE" : ""); |
| } |
| |
| bool FilesCopyRequest::GetContentData(std::string* upload_content_type, |
| std::string* upload_content) { |
| if (parents_.empty() && title_.empty()) |
| return false; |
| |
| *upload_content_type = util::kContentTypeApplicationJson; |
| |
| base::DictionaryValue root; |
| |
| if (!modified_date_.is_null()) |
| root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_)); |
| |
| if (!parents_.empty()) { |
| base::Value::List parents_value; |
| for (size_t i = 0; i < parents_.size(); ++i) { |
| base::Value::Dict parent; |
| parent.Set("id", parents_[i]); |
| parents_value.Append(std::move(parent)); |
| } |
| root.SetKey("parents", base::Value(std::move(parents_value))); |
| } |
| |
| if (!title_.empty()) |
| root.SetString("title", title_); |
| |
| base::JSONWriter::Write(root, upload_content); |
| DVLOG(1) << "FilesCopy data: " << *upload_content_type << ", [" |
| << *upload_content << "]"; |
| return true; |
| } |
| |
| //========================= TeamDriveListRequest ============================= |
| |
| TeamDriveListRequest::TeamDriveListRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| TeamDriveListCallback callback) |
| : DriveApiDataRequest<TeamDriveList>(sender, std::move(callback)), |
| url_generator_(url_generator), |
| max_results_(30) {} |
| |
| TeamDriveListRequest::~TeamDriveListRequest() {} |
| |
| GURL TeamDriveListRequest::GetURLInternal() const { |
| return url_generator_.GetTeamDriveListUrl(max_results_, page_token_); |
| } |
| |
| //========================= StartPageTokenRequest ============================= |
| |
| StartPageTokenRequest::StartPageTokenRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| StartPageTokenCallback callback) |
| : DriveApiDataRequest<StartPageToken>(sender, std::move(callback)), |
| url_generator_(url_generator) {} |
| |
| StartPageTokenRequest::~StartPageTokenRequest() = default; |
| |
| GURL StartPageTokenRequest::GetURLInternal() const { |
| return url_generator_.GetStartPageTokenUrl(team_drive_id_); |
| } |
| |
| //============================= FilesListRequest ============================= |
| |
| FilesListRequest::FilesListRequest(RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| FileListCallback callback) |
| : DriveApiDataRequest<FileList>(sender, std::move(callback)), |
| url_generator_(url_generator), |
| max_results_(100), |
| corpora_(FilesListCorpora::DEFAULT) {} |
| |
| FilesListRequest::~FilesListRequest() {} |
| |
| GURL FilesListRequest::GetURLInternal() const { |
| return url_generator_.GetFilesListUrl(max_results_, page_token_, corpora_, |
| team_drive_id_, q_); |
| } |
| |
| //======================== FilesListNextPageRequest ========================= |
| |
| FilesListNextPageRequest::FilesListNextPageRequest(RequestSender* sender, |
| FileListCallback callback) |
| : DriveApiDataRequest<FileList>(sender, std::move(callback)) {} |
| |
| FilesListNextPageRequest::~FilesListNextPageRequest() = default; |
| |
| GURL FilesListNextPageRequest::GetURLInternal() const { |
| return next_link_; |
| } |
| |
| //============================ FilesDeleteRequest ============================= |
| |
| FilesDeleteRequest::FilesDeleteRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| EntryActionCallback callback) |
| : EntryActionRequest(sender, std::move(callback)), |
| url_generator_(url_generator) {} |
| |
| FilesDeleteRequest::~FilesDeleteRequest() {} |
| |
| std::string FilesDeleteRequest::GetRequestType() const { |
| return "DELETE"; |
| } |
| |
| GURL FilesDeleteRequest::GetURL() const { |
| return url_generator_.GetFilesDeleteUrl(file_id_); |
| } |
| |
| std::vector<std::string> FilesDeleteRequest::GetExtraRequestHeaders() const { |
| std::vector<std::string> headers( |
| EntryActionRequest::GetExtraRequestHeaders()); |
| headers.push_back(util::GenerateIfMatchHeader(etag_)); |
| return headers; |
| } |
| |
| //============================ FilesTrashRequest ============================= |
| |
| FilesTrashRequest::FilesTrashRequest(RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| FileResourceCallback callback) |
| : DriveApiDataRequest<FileResource>(sender, std::move(callback)), |
| url_generator_(url_generator) {} |
| |
| FilesTrashRequest::~FilesTrashRequest() {} |
| |
| std::string FilesTrashRequest::GetRequestType() const { |
| return "POST"; |
| } |
| |
| GURL FilesTrashRequest::GetURLInternal() const { |
| return url_generator_.GetFilesTrashUrl(file_id_); |
| } |
| |
| //============================== AboutGetRequest ============================= |
| |
| AboutGetRequest::AboutGetRequest(RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| AboutResourceCallback callback) |
| : DriveApiDataRequest<AboutResource>(sender, std::move(callback)), |
| url_generator_(url_generator) {} |
| |
| AboutGetRequest::~AboutGetRequest() {} |
| |
| GURL AboutGetRequest::GetURLInternal() const { |
| return url_generator_.GetAboutGetUrl(); |
| } |
| |
| //============================ ChangesListRequest =========================== |
| |
| ChangesListRequest::ChangesListRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| ChangeListCallback callback) |
| : DriveApiDataRequest<ChangeList>(sender, std::move(callback)), |
| url_generator_(url_generator), |
| include_deleted_(true), |
| max_results_(100), |
| start_change_id_(0) {} |
| |
| ChangesListRequest::~ChangesListRequest() {} |
| |
| GURL ChangesListRequest::GetURLInternal() const { |
| return url_generator_.GetChangesListUrl(include_deleted_, max_results_, |
| page_token_, start_change_id_, |
| team_drive_id_); |
| } |
| |
| //======================== ChangesListNextPageRequest ========================= |
| |
| ChangesListNextPageRequest::ChangesListNextPageRequest( |
| RequestSender* sender, |
| ChangeListCallback callback) |
| : DriveApiDataRequest<ChangeList>(sender, std::move(callback)) {} |
| |
| ChangesListNextPageRequest::~ChangesListNextPageRequest() = default; |
| |
| GURL ChangesListNextPageRequest::GetURLInternal() const { |
| return next_link_; |
| } |
| |
| //========================== ChildrenInsertRequest ============================ |
| |
| ChildrenInsertRequest::ChildrenInsertRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| EntryActionCallback callback) |
| : EntryActionRequest(sender, std::move(callback)), |
| url_generator_(url_generator) {} |
| |
| ChildrenInsertRequest::~ChildrenInsertRequest() {} |
| |
| std::string ChildrenInsertRequest::GetRequestType() const { |
| return "POST"; |
| } |
| |
| GURL ChildrenInsertRequest::GetURL() const { |
| return url_generator_.GetChildrenInsertUrl(folder_id_); |
| } |
| |
| bool ChildrenInsertRequest::GetContentData(std::string* upload_content_type, |
| std::string* upload_content) { |
| *upload_content_type = util::kContentTypeApplicationJson; |
| |
| base::DictionaryValue root; |
| root.SetString("id", id_); |
| |
| base::JSONWriter::Write(root, upload_content); |
| DVLOG(1) << "InsertResource data: " << *upload_content_type << ", [" |
| << *upload_content << "]"; |
| return true; |
| } |
| |
| //========================== ChildrenDeleteRequest ============================ |
| |
| ChildrenDeleteRequest::ChildrenDeleteRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| EntryActionCallback callback) |
| : EntryActionRequest(sender, std::move(callback)), |
| url_generator_(url_generator) {} |
| |
| ChildrenDeleteRequest::~ChildrenDeleteRequest() {} |
| |
| std::string ChildrenDeleteRequest::GetRequestType() const { |
| return "DELETE"; |
| } |
| |
| GURL ChildrenDeleteRequest::GetURL() const { |
| return url_generator_.GetChildrenDeleteUrl(child_id_, folder_id_); |
| } |
| |
| //======================= InitiateUploadNewFileRequest ======================= |
| |
| InitiateUploadNewFileRequest::InitiateUploadNewFileRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| const std::string& content_type, |
| int64_t content_length, |
| const std::string& parent_resource_id, |
| const std::string& title, |
| InitiateUploadCallback callback) |
| : InitiateUploadRequestBase(sender, |
| std::move(callback), |
| content_type, |
| content_length), |
| url_generator_(url_generator), |
| parent_resource_id_(parent_resource_id), |
| title_(title) {} |
| |
| InitiateUploadNewFileRequest::~InitiateUploadNewFileRequest() {} |
| |
| GURL InitiateUploadNewFileRequest::GetURL() const { |
| return url_generator_.GetInitiateUploadNewFileUrl(!modified_date_.is_null()); |
| } |
| |
| std::string InitiateUploadNewFileRequest::GetRequestType() const { |
| return "POST"; |
| } |
| |
| bool InitiateUploadNewFileRequest::GetContentData( |
| std::string* upload_content_type, |
| std::string* upload_content) { |
| *upload_content_type = util::kContentTypeApplicationJson; |
| |
| base::DictionaryValue root; |
| root.SetString("title", title_); |
| |
| // Fill parent link. |
| base::Value::List parents; |
| parents.Append(base::Value::FromUniquePtrValue( |
| util::CreateParentValue(parent_resource_id_))); |
| root.SetKey("parents", base::Value(std::move(parents))); |
| |
| if (!modified_date_.is_null()) |
| root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_)); |
| |
| if (!last_viewed_by_me_date_.is_null()) { |
| root.SetString("lastViewedByMeDate", |
| util::FormatTimeAsString(last_viewed_by_me_date_)); |
| } |
| |
| AttachProperties(properties_, &root); |
| base::JSONWriter::Write(root, upload_content); |
| |
| DVLOG(1) << "InitiateUploadNewFile data: " << *upload_content_type << ", [" |
| << *upload_content << "]"; |
| return true; |
| } |
| |
| //===================== InitiateUploadExistingFileRequest ==================== |
| |
| InitiateUploadExistingFileRequest::InitiateUploadExistingFileRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| const std::string& content_type, |
| int64_t content_length, |
| const std::string& resource_id, |
| const std::string& etag, |
| InitiateUploadCallback callback) |
| : InitiateUploadRequestBase(sender, |
| std::move(callback), |
| content_type, |
| content_length), |
| url_generator_(url_generator), |
| resource_id_(resource_id), |
| etag_(etag) {} |
| |
| InitiateUploadExistingFileRequest::~InitiateUploadExistingFileRequest() {} |
| |
| GURL InitiateUploadExistingFileRequest::GetURL() const { |
| return url_generator_.GetInitiateUploadExistingFileUrl( |
| resource_id_, !modified_date_.is_null()); |
| } |
| |
| std::string InitiateUploadExistingFileRequest::GetRequestType() const { |
| return "PUT"; |
| } |
| |
| std::vector<std::string> |
| InitiateUploadExistingFileRequest::GetExtraRequestHeaders() const { |
| std::vector<std::string> headers( |
| InitiateUploadRequestBase::GetExtraRequestHeaders()); |
| headers.push_back(util::GenerateIfMatchHeader(etag_)); |
| return headers; |
| } |
| |
| bool InitiateUploadExistingFileRequest::GetContentData( |
| std::string* upload_content_type, |
| std::string* upload_content) { |
| base::DictionaryValue root; |
| if (!parent_resource_id_.empty()) { |
| base::Value::List parents; |
| parents.Append(base::Value::FromUniquePtrValue( |
| util::CreateParentValue(parent_resource_id_))); |
| root.SetKey("parents", base::Value(std::move(parents))); |
| } |
| |
| if (!title_.empty()) |
| root.SetString("title", title_); |
| |
| if (!modified_date_.is_null()) |
| root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_)); |
| |
| if (!last_viewed_by_me_date_.is_null()) { |
| root.SetString("lastViewedByMeDate", |
| util::FormatTimeAsString(last_viewed_by_me_date_)); |
| } |
| |
| AttachProperties(properties_, &root); |
| if (root.DictEmpty()) |
| return false; |
| |
| *upload_content_type = util::kContentTypeApplicationJson; |
| base::JSONWriter::Write(root, upload_content); |
| DVLOG(1) << "InitiateUploadExistingFile data: " << *upload_content_type |
| << ", [" << *upload_content << "]"; |
| return true; |
| } |
| |
| //============================ ResumeUploadRequest =========================== |
| |
| ResumeUploadRequest::ResumeUploadRequest(RequestSender* sender, |
| const GURL& upload_location, |
| int64_t start_position, |
| int64_t end_position, |
| int64_t content_length, |
| const std::string& content_type, |
| const base::FilePath& local_file_path, |
| UploadRangeCallback callback, |
| ProgressCallback progress_callback) |
| : ResumeUploadRequestBase(sender, |
| upload_location, |
| start_position, |
| end_position, |
| content_length, |
| content_type, |
| local_file_path, |
| progress_callback), |
| callback_(std::move(callback)) { |
| DCHECK(!callback_.is_null()); |
| } |
| |
| ResumeUploadRequest::~ResumeUploadRequest() {} |
| |
| void ResumeUploadRequest::OnRangeRequestComplete( |
| const UploadRangeResponse& response, |
| std::unique_ptr<base::Value> value) { |
| DCHECK(CalledOnValidThread()); |
| ParseFileResourceWithUploadRangeAndRun(std::move(callback_), response, |
| std::move(value)); |
| } |
| |
| //========================== GetUploadStatusRequest ========================== |
| |
| GetUploadStatusRequest::GetUploadStatusRequest(RequestSender* sender, |
| const GURL& upload_url, |
| int64_t content_length, |
| UploadRangeCallback callback) |
| : GetUploadStatusRequestBase(sender, upload_url, content_length), |
| callback_(std::move(callback)) { |
| DCHECK(!callback_.is_null()); |
| } |
| |
| GetUploadStatusRequest::~GetUploadStatusRequest() {} |
| |
| void GetUploadStatusRequest::OnRangeRequestComplete( |
| const UploadRangeResponse& response, |
| std::unique_ptr<base::Value> value) { |
| DCHECK(CalledOnValidThread()); |
| ParseFileResourceWithUploadRangeAndRun(std::move(callback_), response, |
| std::move(value)); |
| } |
| |
| //======================= MultipartUploadNewFileDelegate ======================= |
| |
| MultipartUploadNewFileDelegate::MultipartUploadNewFileDelegate( |
| base::SequencedTaskRunner* task_runner, |
| const std::string& title, |
| const std::string& parent_resource_id, |
| const std::string& content_type, |
| int64_t content_length, |
| const base::Time& modified_date, |
| const base::Time& last_viewed_by_me_date, |
| const base::FilePath& local_file_path, |
| const Properties& properties, |
| const DriveApiUrlGenerator& url_generator, |
| FileResourceCallback callback, |
| ProgressCallback progress_callback) |
| : MultipartUploadRequestBase( |
| task_runner, |
| CreateMultipartUploadMetadataJson(title, |
| parent_resource_id, |
| modified_date, |
| last_viewed_by_me_date, |
| properties), |
| content_type, |
| content_length, |
| local_file_path, |
| std::move(callback), |
| progress_callback), |
| has_modified_date_(!modified_date.is_null()), |
| url_generator_(url_generator) {} |
| |
| MultipartUploadNewFileDelegate::~MultipartUploadNewFileDelegate() = default; |
| |
| GURL MultipartUploadNewFileDelegate::GetURL() const { |
| return url_generator_.GetMultipartUploadNewFileUrl(has_modified_date_); |
| } |
| |
| std::string MultipartUploadNewFileDelegate::GetRequestType() const { |
| return "POST"; |
| } |
| |
| //====================== MultipartUploadExistingFileDelegate =================== |
| |
| MultipartUploadExistingFileDelegate::MultipartUploadExistingFileDelegate( |
| base::SequencedTaskRunner* task_runner, |
| const std::string& title, |
| const std::string& resource_id, |
| const std::string& parent_resource_id, |
| const std::string& content_type, |
| int64_t content_length, |
| const base::Time& modified_date, |
| const base::Time& last_viewed_by_me_date, |
| const base::FilePath& local_file_path, |
| const std::string& etag, |
| const Properties& properties, |
| const DriveApiUrlGenerator& url_generator, |
| FileResourceCallback callback, |
| ProgressCallback progress_callback) |
| : MultipartUploadRequestBase( |
| task_runner, |
| CreateMultipartUploadMetadataJson(title, |
| parent_resource_id, |
| modified_date, |
| last_viewed_by_me_date, |
| properties), |
| content_type, |
| content_length, |
| local_file_path, |
| std::move(callback), |
| progress_callback), |
| resource_id_(resource_id), |
| etag_(etag), |
| has_modified_date_(!modified_date.is_null()), |
| url_generator_(url_generator) {} |
| |
| MultipartUploadExistingFileDelegate::~MultipartUploadExistingFileDelegate() = |
| default; |
| |
| std::vector<std::string> |
| MultipartUploadExistingFileDelegate::GetExtraRequestHeaders() const { |
| std::vector<std::string> headers( |
| MultipartUploadRequestBase::GetExtraRequestHeaders()); |
| headers.push_back(util::GenerateIfMatchHeader(etag_)); |
| return headers; |
| } |
| |
| GURL MultipartUploadExistingFileDelegate::GetURL() const { |
| return url_generator_.GetMultipartUploadExistingFileUrl(resource_id_, |
| has_modified_date_); |
| } |
| |
| std::string MultipartUploadExistingFileDelegate::GetRequestType() const { |
| return "PUT"; |
| } |
| |
| //========================== DownloadFileRequest ========================== |
| |
| DownloadFileRequest::DownloadFileRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| const std::string& resource_id, |
| const base::FilePath& output_file_path, |
| DownloadActionCallback download_action_callback, |
| const GetContentCallback& get_content_callback, |
| ProgressCallback progress_callback) |
| : DownloadFileRequestBase( |
| sender, |
| std::move(download_action_callback), |
| get_content_callback, |
| progress_callback, |
| url_generator.GenerateDownloadFileUrl(resource_id), |
| output_file_path) {} |
| |
| DownloadFileRequest::~DownloadFileRequest() = default; |
| |
| //========================== PermissionsInsertRequest ========================== |
| |
| PermissionsInsertRequest::PermissionsInsertRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator, |
| EntryActionCallback callback) |
| : EntryActionRequest(sender, std::move(callback)), |
| url_generator_(url_generator), |
| type_(PERMISSION_TYPE_USER), |
| role_(PERMISSION_ROLE_READER) {} |
| |
| PermissionsInsertRequest::~PermissionsInsertRequest() = default; |
| |
| GURL PermissionsInsertRequest::GetURL() const { |
| return url_generator_.GetPermissionsInsertUrl(id_); |
| } |
| |
| std::string PermissionsInsertRequest::GetRequestType() const { |
| return "POST"; |
| } |
| |
| bool PermissionsInsertRequest::GetContentData(std::string* upload_content_type, |
| std::string* upload_content) { |
| *upload_content_type = util::kContentTypeApplicationJson; |
| |
| base::DictionaryValue root; |
| switch (type_) { |
| case PERMISSION_TYPE_ANYONE: |
| root.SetStringKey("type", "anyone"); |
| break; |
| case PERMISSION_TYPE_DOMAIN: |
| root.SetStringKey("type", "domain"); |
| break; |
| case PERMISSION_TYPE_GROUP: |
| root.SetStringKey("type", "group"); |
| break; |
| case PERMISSION_TYPE_USER: |
| root.SetStringKey("type", "user"); |
| break; |
| } |
| switch (role_) { |
| case PERMISSION_ROLE_OWNER: |
| root.SetStringKey("role", "owner"); |
| break; |
| case PERMISSION_ROLE_READER: |
| root.SetStringKey("role", "reader"); |
| break; |
| case PERMISSION_ROLE_WRITER: |
| root.SetStringKey("role", "writer"); |
| break; |
| case PERMISSION_ROLE_COMMENTER: |
| root.SetStringKey("role", "reader"); |
| { |
| base::Value list(base::Value::Type::LIST); |
| list.Append("commenter"); |
| root.SetKey("additionalRoles", std::move(list)); |
| } |
| break; |
| } |
| root.SetStringKey("value", value_); |
| base::JSONWriter::Write(root, upload_content); |
| return true; |
| } |
| |
| //======================= SingleBatchableDelegateRequest ======================= |
| |
| SingleBatchableDelegateRequest::SingleBatchableDelegateRequest( |
| RequestSender* sender, |
| std::unique_ptr<BatchableDelegate> delegate) |
| : DriveUrlFetchRequestBase( |
| sender, |
| base::BindRepeating( |
| &SingleBatchableDelegateRequest::OnUploadProgress, |
| // Safe to not retain as the SimpleURLLoader is owned by our base |
| // class and cannot outlive this instance. |
| base::Unretained(this)), |
| ProgressCallback()), |
| delegate_(std::move(delegate)) {} |
| |
| SingleBatchableDelegateRequest::~SingleBatchableDelegateRequest() = default; |
| |
| GURL SingleBatchableDelegateRequest::GetURL() const { |
| return delegate_->GetURL(); |
| } |
| |
| std::string SingleBatchableDelegateRequest::GetRequestType() const { |
| return delegate_->GetRequestType(); |
| } |
| |
| std::vector<std::string> |
| SingleBatchableDelegateRequest::GetExtraRequestHeaders() const { |
| return delegate_->GetExtraRequestHeaders(); |
| } |
| |
| void SingleBatchableDelegateRequest::Prepare(PrepareCallback callback) { |
| delegate_->Prepare(std::move(callback)); |
| } |
| |
| bool SingleBatchableDelegateRequest::GetContentData( |
| std::string* upload_content_type, |
| std::string* upload_content) { |
| return delegate_->GetContentData(upload_content_type, upload_content); |
| } |
| |
| void SingleBatchableDelegateRequest::ProcessURLFetchResults( |
| const network::mojom::URLResponseHead* response_head, |
| base::FilePath response_file, |
| std::string response_body) { |
| delegate_->NotifyResult( |
| GetErrorCode(), response_body, |
| base::BindOnce( |
| &SingleBatchableDelegateRequest::OnProcessURLFetchResultsComplete, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void SingleBatchableDelegateRequest::RunCallbackOnPrematureFailure( |
| ApiErrorCode code) { |
| delegate_->NotifyError(code); |
| } |
| |
| void SingleBatchableDelegateRequest::OnUploadProgress(int64_t current, |
| int64_t total) { |
| delegate_->NotifyUploadProgress(current, total); |
| } |
| |
| //========================== BatchUploadRequest ========================== |
| |
| BatchUploadChildEntry::BatchUploadChildEntry(BatchableDelegate* request) |
| : request(request), prepared(false), data_offset(0), data_size(0) {} |
| |
| BatchUploadChildEntry::~BatchUploadChildEntry() = default; |
| |
| BatchUploadRequest::BatchUploadRequest( |
| RequestSender* sender, |
| const DriveApiUrlGenerator& url_generator) |
| : DriveUrlFetchRequestBase( |
| sender, |
| // Safe to not retain as the SimpleURLoader is owned by our base class |
| // and cannot outlive this instance. |
| base::BindRepeating(&BatchUploadRequest::OnUploadProgress, |
| base::Unretained(this)), |
| ProgressCallback()), |
| sender_(sender), |
| url_generator_(url_generator), |
| committed_(false), |
| last_progress_value_(0) {} |
| |
| BatchUploadRequest::~BatchUploadRequest() = default; |
| |
| void BatchUploadRequest::SetBoundaryForTesting(const std::string& boundary) { |
| boundary_ = boundary; |
| } |
| |
| void BatchUploadRequest::AddRequest(BatchableDelegate* request) { |
| DCHECK(CalledOnValidThread()); |
| DCHECK(request); |
| DCHECK(GetChildEntry(request) == child_requests_.end()); |
| DCHECK(!committed_); |
| child_requests_.push_back(std::make_unique<BatchUploadChildEntry>(request)); |
| request->Prepare(base::BindOnce(&BatchUploadRequest::OnChildRequestPrepared, |
| weak_ptr_factory_.GetWeakPtr(), request)); |
| } |
| |
| void BatchUploadRequest::OnChildRequestPrepared(RequestID request_id, |
| ApiErrorCode result) { |
| DCHECK(CalledOnValidThread()); |
| auto const child = GetChildEntry(request_id); |
| DCHECK(child != child_requests_.end()); |
| if (IsSuccessfulDriveApiErrorCode(result)) { |
| (*child)->prepared = true; |
| } else { |
| (*child)->request->NotifyError(result); |
| child_requests_.erase(child); |
| } |
| MayCompletePrepare(); |
| } |
| |
| void BatchUploadRequest::Commit() { |
| DCHECK(CalledOnValidThread()); |
| DCHECK(!committed_); |
| if (child_requests_.empty()) { |
| Cancel(); |
| } else { |
| committed_ = true; |
| MayCompletePrepare(); |
| } |
| } |
| |
| void BatchUploadRequest::Prepare(PrepareCallback callback) { |
| DCHECK(CalledOnValidThread()); |
| DCHECK(callback); |
| prepare_callback_ = std::move(callback); |
| MayCompletePrepare(); |
| } |
| |
| void BatchUploadRequest::Cancel() { |
| child_requests_.clear(); |
| UrlFetchRequestBase::Cancel(); |
| } |
| |
| // Obtains corresponding child entry of |request_id|. Returns NULL if the |
| // entry is not found. |
| std::vector<std::unique_ptr<BatchUploadChildEntry>>::iterator |
| BatchUploadRequest::GetChildEntry(RequestID request_id) { |
| for (auto it = child_requests_.begin(); it != child_requests_.end(); ++it) { |
| if ((*it)->request.get() == request_id) |
| return it; |
| } |
| return child_requests_.end(); |
| } |
| |
| void BatchUploadRequest::MayCompletePrepare() { |
| if (!committed_ || prepare_callback_.is_null()) |
| return; |
| for (const auto& child : child_requests_) { |
| if (!child->prepared) |
| return; |
| } |
| |
| // Build multipart body here. |
| int64_t total_size = 0; |
| std::vector<ContentTypeAndData> parts; |
| for (const auto& child : child_requests_) { |
| std::string type; |
| std::string data; |
| const bool result = child->request->GetContentData(&type, &data); |
| // Upload request must have content data. |
| DCHECK(result); |
| |
| const GURL url = child->request->GetURL(); |
| std::string method = child->request->GetRequestType(); |
| const std::string header = base::StringPrintf( |
| kBatchUploadRequestFormat, method.c_str(), url.path().c_str(), |
| url_generator_.GetBatchUploadUrl().host().c_str(), type.c_str()); |
| |
| child->data_offset = header.size(); |
| child->data_size = data.size(); |
| total_size += data.size(); |
| |
| parts.push_back(ContentTypeAndData({kHttpContentType, header + data})); |
| } |
| |
| UMA_HISTOGRAM_COUNTS_100(kUMADriveTotalFileCountInBatchUpload, parts.size()); |
| UMA_HISTOGRAM_MEMORY_KB(kUMADriveTotalFileSizeInBatchUpload, |
| total_size / 1024); |
| |
| std::vector<uint64_t> part_data_offset; |
| GenerateMultipartBody(MultipartType::kMixed, boundary_, parts, |
| &upload_content_, &part_data_offset); |
| DCHECK(part_data_offset.size() == child_requests_.size()); |
| for (size_t i = 0; i < child_requests_.size(); ++i) { |
| child_requests_[i]->data_offset += part_data_offset[i]; |
| } |
| std::move(prepare_callback_).Run(HTTP_SUCCESS); |
| } |
| |
| bool BatchUploadRequest::GetContentData(std::string* upload_content_type, |
| std::string* upload_content_data) { |
| upload_content_type->assign(upload_content_.type); |
| upload_content_data->assign(upload_content_.data); |
| return true; |
| } |
| |
| base::WeakPtr<BatchUploadRequest> |
| BatchUploadRequest::GetWeakPtrAsBatchUploadRequest() { |
| return weak_ptr_factory_.GetWeakPtr(); |
| } |
| |
| GURL BatchUploadRequest::GetURL() const { |
| return url_generator_.GetBatchUploadUrl(); |
| } |
| |
| std::string BatchUploadRequest::GetRequestType() const { |
| return "PUT"; |
| } |
| |
| std::vector<std::string> BatchUploadRequest::GetExtraRequestHeaders() const { |
| std::vector<std::string> headers; |
| headers.push_back(kBatchUploadHeader); |
| return headers; |
| } |
| |
| void BatchUploadRequest::ProcessURLFetchResults( |
| const network::mojom::URLResponseHead* response_head, |
| base::FilePath response_file, |
| std::string response_body) { |
| if (!IsSuccessfulDriveApiErrorCode(GetErrorCode())) { |
| RunCallbackOnPrematureFailure(GetErrorCode()); |
| sender_->RequestFinished(this); |
| return; |
| } |
| |
| std::string content_type; |
| if (response_head) { |
| response_head->headers->EnumerateHeader( |
| /* need only first header */ nullptr, "Content-Type", &content_type); |
| } |
| |
| std::vector<MultipartHttpResponse> parts; |
| if (!ParseMultipartResponse(content_type, response_body, &parts) || |
| child_requests_.size() != parts.size()) { |
| RunCallbackOnPrematureFailure(PARSE_ERROR); |
| sender_->RequestFinished(this); |
| return; |
| } |
| |
| for (size_t i = 0; i < parts.size(); ++i) { |
| BatchableDelegate* delegate = child_requests_[i]->request.get(); |
| // Pass ownership of |delegate| so that child_requests_.clear() won't |
| // kill the delegate. It has to be deleted after the notification. |
| delegate->NotifyResult( |
| parts[i].code, parts[i].body, |
| base::BindOnce(&base::DeletePointer<BatchableDelegate>, |
| child_requests_[i]->request.release())); |
| } |
| child_requests_.clear(); |
| |
| sender_->RequestFinished(this); |
| } |
| |
| void BatchUploadRequest::RunCallbackOnPrematureFailure(ApiErrorCode code) { |
| for (const auto& child : child_requests_) |
| child->request->NotifyError(code); |
| child_requests_.clear(); |
| } |
| |
| void BatchUploadRequest::OnUploadProgress(int64_t current, int64_t total) { |
| for (const auto& child : child_requests_) { |
| if (child->data_offset <= current && |
| current <= child->data_offset + child->data_size) { |
| child->request->NotifyUploadProgress(current - child->data_offset, |
| child->data_size); |
| } else if (last_progress_value_ < child->data_offset + child->data_size && |
| child->data_offset + child->data_size < current) { |
| child->request->NotifyUploadProgress(child->data_size, child->data_size); |
| } |
| } |
| last_progress_value_ = current; |
| } |
| } // namespace drive |
| } // namespace google_apis |