Add request header on gdata operation for testing ETag match.

chrome/browser/google_apis/gdata_operations.cc

 // 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 "chrome/browser/google_apis/gdata_operations.h"
 
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/gdata_util.h"
@@ skipping 160 matching lines @@
 
 ResumeUploadResponse::~ResumeUploadResponse() {
 }
 
 InitiateUploadParams::InitiateUploadParams(
     UploadMode upload_mode,
     const std::string& title,
     const std::string& content_type,
     int64 content_length,
     const GURL& upload_location,
-    const FilePath& virtual_path)
+    const FilePath& virtual_path,
+    const std::string& etag)
     : upload_mode(upload_mode),
       title(title),
       content_type(content_type),
       content_length(content_length),
       upload_location(upload_location),
-      virtual_path(virtual_path) {
+      virtual_path(virtual_path),
+      etag(etag) {
+  DCHECK(upload_mode == UPLOAD_NEW_FILE || upload_mode == UPLOAD_EXISTING_FILE);
+  DCHECK(upload_mode != UPLOAD_NEW_FILE || (!title.empty() && etag.empty()));
+  DCHECK(upload_mode != UPLOAD_EXISTING_FILE || title.empty());
 }
 
 InitiateUploadParams::~InitiateUploadParams() {
 }
 
 ResumeUploadParams::ResumeUploadParams(
     UploadMode upload_mode,
     int64 start_range,
     int64 end_range,
     int64 content_length,
     const std::string& content_type,
     scoped_refptr<net::IOBuffer> buf,
     const GURL& upload_location,
-    const FilePath& virtual_path) : upload_mode(upload_mode),
-                                    start_range(start_range),
-                                    end_range(end_range),
-                                    content_length(content_length),
-                                    content_type(content_type),
-                                    buf(buf),
-                                    upload_location(upload_location),
-                                    virtual_path(virtual_path) {
+    const FilePath& virtual_path,
+    const std::string& etag)
+    : upload_mode(upload_mode),
+      start_range(start_range),
+      end_range(end_range),
+      content_length(content_length),
+      content_type(content_type),
+      buf(buf),
+      upload_location(upload_location),
+      virtual_path(virtual_path),
+      etag(etag) {
 }
 
 ResumeUploadParams::~ResumeUploadParams() {
 }
 
 //============================ GetDocumentsOperation ===========================
 
 GetDocumentsOperation::GetDocumentsOperation(
     OperationRegistry* registry,
     const GURL& url,
@@ skipping 66 matching lines @@
 }
 
 //============================ DownloadFileOperation ===========================
 
 DownloadFileOperation::DownloadFileOperation(
     OperationRegistry* registry,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const GURL& document_url,
     const FilePath& virtual_path,
-    const FilePath& output_file_path)
+    const FilePath& output_file_path,
+    const std::string& etag)
     : UrlFetchOperationBase(registry,
                             OPERATION_DOWNLOAD,
                             virtual_path),
       download_action_callback_(download_action_callback),
       get_content_callback_(get_content_callback),
-      document_url_(document_url) {
+      document_url_(document_url),
+      etag_(etag) {
   // Make sure we download the content into a temp file.
   if (output_file_path.empty())
     save_temp_file_ = true;
   else
     output_file_path_ = output_file_path;
 }
 
 DownloadFileOperation::~DownloadFileOperation() {}
 
 // Overridden from UrlFetchOperationBase.
@@ skipping 32 matching lines @@
   if (!download_action_callback_.is_null())
     download_action_callback_.Run(code, document_url_, temp_file);
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void DownloadFileOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   if (!download_action_callback_.is_null())
     download_action_callback_.Run(code, document_url_, FilePath());
 }
 
+std::vector<std::string> DownloadFileOperation::GetExtraRequestHeaders() const {
+  std::vector<std::string> headers;
+  if (!etag_.empty())
+    headers.push_back(base::StringPrintf(kIfMatchHeaderFormat, etag_.c_str()));
+  return headers;
+}
+
 //=========================== DeleteDocumentOperation ==========================
 
 DeleteDocumentOperation::DeleteDocumentOperation(
     OperationRegistry* registry,
     const EntryActionCallback& callback,
-    const GURL& document_url)
-    : EntryActionOperation(registry, callback, document_url) {
+    const GURL& document_url,
+    const std::string& etag)
+    : EntryActionOperation(registry, callback, document_url),
+      etag_(etag) {
 }
 
 DeleteDocumentOperation::~DeleteDocumentOperation() {}
 
 GURL DeleteDocumentOperation::GetURL() const {
   return AddStandardUrlParams(document_url());
 }
 
 URLFetcher::RequestType DeleteDocumentOperation::GetRequestType() const {
   return URLFetcher::DELETE_REQUEST;
 }
 
 std::vector<std::string>
 DeleteDocumentOperation::GetExtraRequestHeaders() const {
   std::vector<std::string> headers;
-  headers.push_back(kIfMatchAllHeader);
+  if (etag_.empty())
+    headers.push_back(kIfMatchAllHeader);
+  else
+    headers.push_back(base::StringPrintf(kIfMatchHeaderFormat, etag_.c_str()));
   return headers;
 }
 
 //========================== CreateDirectoryOperation ==========================
 
 CreateDirectoryOperation::CreateDirectoryOperation(
     OperationRegistry* registry,
     const GetDataCallback& callback,
     const GURL& parent_content_url,
     const FilePath::StringType& directory_name)
@@ skipping 359 matching lines @@
 
 std::vector<std::string>
 InitiateUploadOperation::GetExtraRequestHeaders() const {
   std::vector<std::string> headers;
   if (!params_.content_type.empty())
     headers.push_back(kUploadContentType + params_.content_type);
 
   headers.push_back(
       kUploadContentLength + base::Int64ToString(params_.content_length));
 
-  if (params_.upload_mode == UPLOAD_EXISTING_FILE)
-    headers.push_back("If-Match: *");
+  if (params_.upload_mode == UPLOAD_EXISTING_FILE) {
+    if (params_.etag.empty()) {
+      headers.push_back(kIfMatchAllHeader);
+    } else {
+      headers.push_back(
+          base::StringPrintf(kIfMatchHeaderFormat, params_.etag.c_str()));
+    }
+  }
 
   return headers;
 }
 
 bool InitiateUploadOperation::GetContentData(std::string* upload_content_type,
                                              std::string* upload_content) {
   if (params_.upload_mode == UPLOAD_EXISTING_FILE) {
     // When uploading an existing file, the body is empty as we don't modify
     // the metadata.
     *upload_content = "";
@@ skipping 120 matching lines @@
   scoped_ptr<DocumentEntry> entry;
   if (!callback_.is_null())
     callback_.Run(ResumeUploadResponse(code, 0, 0), entry.Pass());
 }
 
 URLFetcher::RequestType ResumeUploadOperation::GetRequestType() const {
   return URLFetcher::PUT;
 }
 
 std::vector<std::string> ResumeUploadOperation::GetExtraRequestHeaders() const {
+  std::vector<std::string> headers;
+
+  if (params_.etag.empty()) {
+    headers.push_back(kIfMatchAllHeader);
+  } else {
+    headers.push_back(
+        base::StringPrintf(kIfMatchHeaderFormat, params_.etag.c_str()));
+  }
+
   if (params_.content_length == 0) {
     // For uploading an empty document, just PUT an empty content.
     DCHECK_EQ(params_.start_range, 0);
     DCHECK_EQ(params_.end_range, -1);
-    return std::vector<std::string>();
+    return headers;
   }
 
   // The header looks like
   // Content-Range: bytes <start_range>-<end_range>/<content_length>
   // for example:
   // Content-Range: bytes 7864320-8388607/13851821
   // Use * for unknown/streaming content length.
   DCHECK_GE(params_.start_range, 0);
   DCHECK_GE(params_.end_range, 0);
   DCHECK_GE(params_.content_length, -1);
 
-  std::vector<std::string> headers;
   headers.push_back(
       std::string(kUploadContentRange) +
       base::Int64ToString(params_.start_range) + "-" +
       base::Int64ToString(params_.end_range) + "/" +
       (params_.content_length == -1 ? "*" :
           base::Int64ToString(params_.content_length)));
   return headers;
 }
 
 bool ResumeUploadOperation::GetContentData(std::string* upload_content_type,
@@ skipping 83 matching lines @@
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void GetContactPhotoOperation::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   scoped_ptr<std::string> data(new std::string);
   callback_.Run(code, data.Pass());
 }
 
 }  // namespace gdata