Implement fake drive service upload methods.

Implement fake drive service upload methods.

this will be needed to add DriveFileSystemExtensionApi tests for file
copy/move/create operations.

BUG=172424
TEST=none


Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=181412

[satorux1, 2013-02-06 07:47:55]

Thank you for adding the missing features.

Could you add tests in fake_drive_service_unittest.cc?

https://codereview.chromium.org/12210031/diff/2001/chrome/browser/google_apis...
File chrome/browser/google_apis/fake_drive_service.cc (right):

https://codereview.chromium.org/12210031/diff/2001/chrome/browser/google_apis...
chrome/browser/google_apis/fake_drive_service.cc:893: return_code =
GDATA_NO_CONNECTION;
I'd suggest to return here

if (offline_) {
  MessageLoop::current()->PostTask(
        FROM_HERE,
        base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
  return;
}

This would increase the number of lines, but be easier to read.

https://codereview.chromium.org/12210031/diff/2001/chrome/browser/google_apis...
chrome/browser/google_apis/fake_drive_service.cc:899: return_code =
HTTP_NOT_FOUND;
like wise. I'd suggest to return when failed.

[satorux1, 2013-02-07 05:44:26]

add peria@ and hidehiko@ in case they do the same thing.

[tonibarzic, 2013-02-07 08:31:36]

+ added tests

https://codereview.chromium.org/12210031/diff/2001/chrome/browser/google_apis...
File chrome/browser/google_apis/fake_drive_service.cc (right):

https://codereview.chromium.org/12210031/diff/2001/chrome/browser/google_apis...
chrome/browser/google_apis/fake_drive_service.cc:893: return_code =
GDATA_NO_CONNECTION;
On 2013/02/06 07:47:55, satorux1 wrote:
> I'd suggest to return here
> 
> if (offline_) {
>   MessageLoop::current()->PostTask(
>         FROM_HERE,
>         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
>   return;
> }
> 
> This would increase the number of lines, but be easier to read.

Done.

https://codereview.chromium.org/12210031/diff/2001/chrome/browser/google_apis...
chrome/browser/google_apis/fake_drive_service.cc:899: return_code =
HTTP_NOT_FOUND;
On 2013/02/06 07:47:55, satorux1 wrote:
> like wise. I'd suggest to return when failed.

Done.

[satorux1, 2013-02-07 08:38:38]

LGTM. Thank you for adding lots of tests!

[hidehiko, 2013-02-07 11:44:34]

On 2013/02/07 08:38:38, satorux1 wrote:
> LGTM. Thank you for adding lots of tests!

Just FYI: I'm not sure how these methods will be used, as I couldn't find
DriveFileSystemExtensionApi and I'm not sure about its background well. But
probably, it'd be great to add FakeDriveService::GetUploadStatus implementation,
which is tightly connected to InitiateUpload and ResumeUpload. Not sure it
should be done in this CL or another one, though.

[tbarzic, 2013-02-07 15:04:12]

On 2013/02/07 11:44:34, hidehiko wrote:
> On 2013/02/07 08:38:38, satorux1 wrote:
> > LGTM. Thank you for adding lots of tests!
> 
> Just FYI: I'm not sure how these methods will be used, as I couldn't find
> DriveFileSystemExtensionApi and I'm not sure about its background well. But
> probably, it'd be great to add FakeDriveService::GetUploadStatus
implementation,
> which is tightly connected to InitiateUpload and ResumeUpload. Not sure it
> should be done in this CL or another one, though.

the test will look something like RemoteFileSystemExtensionApipTest, but test
extension (like o in
chrome/test/data/extensions/api_test/filebrowser_component/remote.js) will also
do file  operations that create new files.. I think I'll implement
GetUploadStatus later, after I land the test changes..

[commit-bot: I haz the power, 2013-02-07 15:04:39]

CQ is trying da patch. Follow status at
https://chromium-status.appspot.com/cq/tbarzic@chromium.org/12210031/8001

[commit-bot: I haz the power, 2013-02-07 15:04:42]

Failed to apply patch for chrome/browser/google_apis/fake_drive_service.cc:
While running patch -p1 --forward --force --no-backup-if-mismatch;
  patching file chrome/browser/google_apis/fake_drive_service.cc
  Hunk #1 succeeded at 25 (offset 2 lines).
  Hunk #2 FAILED at 779.
  Hunk #3 succeeded at 853 (offset 13 lines).
  1 out of 3 hunks FAILED -- saving rejects to file
chrome/browser/google_apis/fake_drive_service.cc.rej

Patch:       chrome/browser/google_apis/fake_drive_service.cc
Index: chrome/browser/google_apis/fake_drive_service.cc
diff --git a/chrome/browser/google_apis/fake_drive_service.cc
b/chrome/browser/google_apis/fake_drive_service.cc
index
4be7bfd2935d316c427fa373c5ba3e98c5ee5d11..d7c173bb9bf68e8668f87d49922f1277b642cc35
100644
--- a/chrome/browser/google_apis/fake_drive_service.cc
+++ b/chrome/browser/google_apis/fake_drive_service.cc
@@ -23,6 +23,11 @@ using content::BrowserThread;
 
 namespace google_apis {
 namespace {
+
+// Rel property of upload link in the entries dictionary value.
+const char kUploadUrlRel[] =
+    "http://schemas.google.com/g/2005#resumable-create-media";
+
 // Returns true if a resource entry matches with the search query.
 // Supports queries consist of following format.
 // - Phrases quoted by double/single quotes
@@ -774,12 +779,171 @@ void FakeDriveService::InitiateUpload(
     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);
+  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("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);
+  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);
+  }
+
+  base::DictionaryValue* edit_link = new base::DictionaryValue;
+  edit_link->SetString("href", "https://xxx/edit/" + resource_id);
+  edit_link->SetString("rel", "edit");
+  links->Append(edit_link);
+
+  base::DictionaryValue* upload_link = new base::DictionaryValue;
+  upload_link->SetString("href", upload_url.spec());
+  upload_link->SetString("rel", kUploadUrlRel);
+  links->Append(upload_link);
+  new_entry->Set("link", links);
+
+  AddNewChangestamp(new_entry.get());
+
+  base::DictionaryValue* resource_list_dict = NULL;
+  base::ListValue* entries = NULL;
+  if (!resource_list_value_->GetAsDictionary(&resource_list_dict)) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, HTTP_NOT_FOUND, GURL()));
+    return;
+  }
+
+  // If there are no entries, prepare an empty entry to add.
+  if (!resource_list_dict->HasKey("entry"))
+    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::ResumeUpload(const ResumeUploadParams& params,
                                     const ResumeUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
+
+  scoped_ptr<ResourceEntry> result_entry;
+
+  if (offline_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   ResumeUploadResponse(GDATA_NO_CONNECTION,
+                                        params.start_position,
+                                        params.end_position),
+                   base::Passed(&result_entry)));
+    return;
+  }
+
+  DictionaryValue* entry = NULL;
+  entry = FindEntryByUploadUrl(params.upload_location);
+  if (!entry) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   ResumeUploadResponse(HTTP_NOT_FOUND,
+                                        params.start_position,
+                                        params.end_position),
+                   base::Passed(&result_entry)));
+    return;
+  }
+
+  entry->SetString("docs$size.$t", base::Int64ToString(params.end_position));
+
+  if (params.content_length != params.end_position) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   ResumeUploadResponse(HTTP_RESUME_INCOMPLETE,
+                                        params.start_position,
+                                        params.end_position),
+                    base::Passed(&result_entry)));
+    return;
+  }
+
+  result_entry = ResourceEntry::CreateFrom(*entry).Pass();
+
+  GDataErrorCode return_code = HTTP_SUCCESS;
+  if (params.upload_mode == UPLOAD_NEW_FILE)
+    return_code = HTTP_CREATED;
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback,
+                 ResumeUploadResponse(return_code,
+                                      params.start_position,
+                                      params.end_position),
+                 base::Passed(&result_entry)));
 }
 
 void FakeDriveService::AuthorizeApp(const GURL& edit_url,
@@ -835,6 +999,42 @@ base::DictionaryValue*
FakeDriveService::FindEntryByContentUrl(
   return NULL;
 }
 
+base::DictionaryValue* FakeDriveService::FindEntryByUploadUrl(
+    const GURL& upload_url) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  base::DictionaryValue* resource_list_dict = NULL;
+  base::ListValue* entries = NULL;
+  // Go through entries and return the one that matches |upload_url|.
+  if (resource_list_value_->GetAsDictionary(&resource_list_dict) &&
+      resource_list_dict->GetList("entry", &entries)) {
+    for (size_t i = 0; i < entries->GetSize(); ++i) {
+      base::DictionaryValue* entry = NULL;
+      base::ListValue* links = NULL;
+      if (entries->GetDictionary(i, &entry) &&
+          entry->GetList("link", &links) &&
+          links) {
+        for (size_t link_index = 0;
+            link_index < links->GetSize();
+            ++link_index) {
+          base::DictionaryValue* link = NULL;
+          std::string rel;
+          std::string found_upload_url;
+          if (links->GetDictionary(link_index, &link) &&
+              link && link->GetString("rel", &rel) &&
+              rel == kUploadUrlRel &&
+              link->GetString("href", &found_upload_url) &&
+              GURL(found_upload_url) == upload_url) {
+            return entry;
+          }
+        }
+      }
+    }
+  }
+
+  return NULL;
+}
+
 std::string FakeDriveService::GetNewResourceId() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

[commit-bot: I haz the power, 2013-02-07 22:57:06]

CQ is trying da patch. Follow status at
https://chromium-status.appspot.com/cq/tbarzic@chromium.org/12210031/6004

[commit-bot: I haz the power, 2013-02-07 23:51:39]

CQ is trying da patch. Follow status at
https://chromium-status.appspot.com/cq/tbarzic@chromium.org/12210031/8005

[commit-bot: I haz the power, 2013-02-08 02:28:32]

Change committed as 181412