Split InitiateUpload method into two.

chrome/browser/google_apis/fake_drive_service.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/fake_drive_service.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 759 matching lines @@
       return;
     }
   }
 
   scoped_ptr<ResourceEntry> null;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
 }
 
-void FakeDriveService::InitiateUpload(
-    const InitiateUploadParams& params,
+void FakeDriveService::InitiateUploadNewFile(
+    const FilePath& drive_file_path,
+    const std::string& content_type,
+    int64 content_length,
+    const GURL& parent_upload_url,
+    const std::string& title,
     const InitiateUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return;
   }
 
-  DictionaryValue* entry = FindEntryByUploadUrl(params.upload_location);
+  DictionaryValue* entry = FindEntryByUploadUrl(parent_upload_url);
   if (!entry) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return;
   }
 
-  if (params.upload_mode == UPLOAD_EXISTING_FILE) {
-    std::string etag;
-    entry->GetString("gd$etag", &etag);
-    if (params.etag != etag) {
-      MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(callback, HTTP_PRECONDITION, GURL()));
-      return;
-    }
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, HTTP_SUCCESS, params.upload_location));
-    return;
-  }
-
   // If the title was set, the upload_location is the location of the parent
   // directory of the file that will be uploaded. The file does not yet exist
   // and it must be created. Its title will be the passed title param.
   std::string parent_resource_id;
   entry->GetString("gd$resourceId.$t", &parent_resource_id);
 
   std::string resource_id = GetNewResourceId();
   GURL upload_url = GURL("https://xxx/upload/" + resource_id);
 
   scoped_ptr<base::DictionaryValue> new_entry(new base::DictionaryValue);
   // Set the resource ID and the title
   new_entry->SetString("gd$resourceId.$t", resource_id);
-  new_entry->SetString("title.$t", params.title);
-  new_entry->SetString("docs$filename", params.title);
+  new_entry->SetString("title.$t", title);
+  new_entry->SetString("docs$filename", title);
   new_entry->SetString("docs$size", "0");
   new_entry->SetString("docs$md5Checksum.$t",
                        "3b4385ebefec6e743574c76bbd0575de");
 
   // Add "category" which sets the resource type to file.
   base::ListValue* categories = new base::ListValue;
   base::DictionaryValue* category = new base::DictionaryValue;
   category->SetString("label", "test/foo");
   category->SetString("scheme", "http://schemas.google.com/g/2005#kind");
   category->SetString("term", "http://schemas.google.com/docs/2007#file");
   categories->Append(category);
   new_entry->Set("category", categories);
 
   // Add "content" which sets the content URL.
   base::DictionaryValue* content = new base::DictionaryValue;
   content->SetString("src", "https://xxx/content/" + resource_id);
-  content->SetString("type", params.content_type);
+  content->SetString("type", content_type);
   new_entry->Set("content", content);
 
   // Add "link" which sets the parent URL, the edit URL and the upload URL.
   base::ListValue* links = new base::ListValue;
   if (parent_resource_id != GetRootResourceId()) {
     base::DictionaryValue* parent_link = new base::DictionaryValue;
     parent_link->SetString("href", GetFakeLinkUrl(parent_resource_id).spec());
     parent_link->SetString("rel",
                            "http://schemas.google.com/docs/2007#parent");
     links->Append(parent_link);
@@ skipping 26 matching lines @@
     resource_list_dict->Set("entry", new ListValue);
 
   if (resource_list_dict->GetList("entry", &entries))
     entries->Append(new_entry.release());
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, upload_url));
 }
 
+void FakeDriveService::InitiateUploadExistingFile(
+    const FilePath& drive_file_path,
+    const std::string& content_type,
+    int64 content_length,
+    const GURL& upload_url,
+    const std::string& etag,
+    const InitiateUploadCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
+  if (offline_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
+    return;
+  }
+
+  DictionaryValue* entry = FindEntryByUploadUrl(upload_url);
+  if (!entry) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, HTTP_NOT_FOUND, GURL()));
+    return;
+  }
+
+  std::string entry_etag;
+  entry->GetString("gd$etag", &entry_etag);
+  if (etag != entry_etag) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, HTTP_PRECONDITION, GURL()));
+    return;
+  }
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, HTTP_SUCCESS, upload_url));
+}
+
 void FakeDriveService::GetUploadStatus(
     UploadMode upload_mode,
     const base::FilePath& drive_file_path,
     const GURL& upload_url,
     int64 content_length,
     const UploadRangeCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 }
 
@@ skipping 152 matching lines @@
   return base::StringPrintf("resource_id_%d", resource_id_count_);
 }
 
 void FakeDriveService::AddNewChangestamp(base::DictionaryValue* entry) {
   ++largest_changestamp_;
   entry->SetString("docs$changestamp.value",
                    base::Int64ToString(largest_changestamp_));
 }
 
 }  // namespace google_apis