Support contents upload on FakeDriveService

chrome/browser/drive/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/drive/fake_drive_service.h"
 
 #include <string>
 
+#include "base/file_util.h"
 #include "base/logging.h"
+#include "base/md5.h"
 #include "base/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/google_apis/test_util.h"
@@ skipping 69 matching lines @@
     // TODO(peria): Deal with other attributes than title.
     if (!key.empty() && key != "title")
       return false;
     // Search query in the title.
     if (entry.title().find(value) == std::string::npos)
       return false;
   }
   return true;
 }
 
-// Gets the upload URL from the given entry. Returns an empty URL if not
-// found.
-GURL GetUploadUrl(const base::DictionaryValue& entry) {
-  std::string upload_url;
-  const base::ListValue* links = NULL;
-  if (entry.GetList("link", &links) && links) {
-    for (size_t link_index = 0;
-         link_index < links->GetSize();
-         ++link_index) {
-      const base::DictionaryValue* link = NULL;
-      std::string rel;
-      if (links->GetDictionary(link_index, &link) &&
-          link && link->GetString("rel", &rel) &&
-          rel == kUploadUrlRel &&
-          link->GetString("href", &upload_url)) {
-        break;
-      }
-    }
-  }
-  return GURL(upload_url);
-}
-
 // Returns |url| without query parameter.
 GURL RemoveQueryParameter(const GURL& url) {
   GURL::Replacements replacements;
   replacements.ClearQuery();
   return url.ReplaceComponents(replacements);
 }
 
 }  // namespace
 
+struct FakeDriveService::UploadSession {
+  std::string content_type;
+  int64 content_length;
+  std::string parent_resource_id;
+  std::string resource_id;
+  std::string etag;
+  std::string title;
+
+  int64 uploaded_size;
+
+  UploadSession()
+      : content_length(0),
+        uploaded_size(0) {}
+
+  UploadSession(
+      std::string content_type,
+      int64 content_length,
+      std::string parent_resource_id,
+      std::string resource_id,
+      std::string etag,
+      std::string title)
+    : content_type(content_type),
+      content_length(content_length),
+      parent_resource_id(parent_resource_id),
+      resource_id(resource_id),
+      etag(etag),
+      title(title),
+      uploaded_size(0) {
+  }
+};
+
 FakeDriveService::FakeDriveService()
     : largest_changestamp_(0),
       published_date_seq_(0),
+      next_upload_sequence_number_(0),
       default_max_results_(0),
       resource_id_count_(0),
       resource_list_load_count_(0),
       change_list_load_count_(0),
       directory_load_count_(0),
       about_resource_load_count_(0),
-      offline_(false) {
+      offline_(false),
+      weak_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 FakeDriveService::~FakeDriveService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 bool FakeDriveService::LoadResourceListForWapi(
     const std::string& relative_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 391 matching lines @@
   if (!entry) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback, HTTP_NOT_FOUND, base::FilePath()));
     return CancelCallback();
   }
 
   // Write "x"s of the file size specified in the entry.
   std::string file_size_string;
   entry->GetString("docs$size.$t", &file_size_string);
-  // TODO(satorux): To be correct, we should update docs$md5Checksum.$t here.
   int64 file_size = 0;
   if (base::StringToInt64(file_size_string, &file_size)) {
     base::BinaryValue* content_binary_data;
     std::string content_data;
     if (entry->GetBinary("test$data", &content_binary_data)) {
       content_data = std::string(content_binary_data->GetBuffer(),
           content_binary_data->GetSize());
     }
     DCHECK_EQ(static_cast<size_t>(file_size), content_data.size());
 
@@ skipping 323 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
-  // Content length should be zero, as we'll create an empty file first. The
-  // content will be added in ResumeUpload().
-  const base::DictionaryValue* new_entry = AddNewEntry(content_type,
-                                                       "",  // content_data
-                                                       parent_resource_id,
-                                                       title,
-                                                       false,  // shared_with_me
-                                                       "file");
-  if (!new_entry) {
+  if (parent_resource_id != GetRootResourceId() &&
+      !FindEntryByResourceId(parent_resource_id)) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return CancelCallback();
   }
-  const GURL upload_url = GetUploadUrl(*new_entry);
-  DCHECK(upload_url.is_valid());
+
+  GURL session_url = net::AppendQueryParameter(
+      GetNewUploadSessionUrl(), "mode", "newfile");
+  upload_session_[session_url] =
+      UploadSession(content_type, content_length,
+                    parent_resource_id,
+                    "",  // resource_id
+                    "",  // etag
+                    title);
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(callback, HTTP_SUCCESS,
-                 net::AppendQueryParameter(upload_url, "mode", "newfile")));
+      base::Bind(callback, HTTP_SUCCESS, session_url));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::InitiateUploadExistingFile(
     const base::FilePath& drive_file_path,
     const std::string& content_type,
     int64 content_length,
     const std::string& resource_id,
     const std::string& etag,
     const InitiateUploadCallback& callback) {
@@ skipping 16 matching lines @@
   }
 
   std::string entry_etag;
   entry->GetString("gd$etag", &entry_etag);
   if (!etag.empty() && etag != entry_etag) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_PRECONDITION, GURL()));
     return CancelCallback();
   }
-  entry->SetString("docs$size.$t", "0");
 
-  const GURL upload_url = GetUploadUrl(*entry);
-  DCHECK(upload_url.is_valid());
+  GURL session_url = net::AppendQueryParameter(
+      GetNewUploadSessionUrl(), "mode", "existing");
+  upload_session_[session_url] =
+      UploadSession(content_type, content_length,
+                    "",  // parent_resource_id
+                    resource_id,
+                    entry_etag,
+                    "" /* title */);
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(callback, HTTP_SUCCESS,
-                 net::AppendQueryParameter(upload_url, "mode", "existing")));
+      base::Bind(callback, HTTP_SUCCESS, session_url));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetUploadStatus(
     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());
+
+  if (!ContainsKey(upload_session_, upload_url)) {

[hashimoto, 2013/06/21 04:16:21]

nit: Hmn, I didn't know that we had this function in stl_util.h.
We usually use std::map::count to do this kind of check.
What is the merit of this function over upload_session_.count(upload_url) > 0?

[tzik, 2013/06/21 05:06:52]

Changed this to count().
They are exactly same in their functionality or performance.

+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, UploadRangeResponse(HTTP_NOT_FOUND, 0, 0),
+                   base::Passed(scoped_ptr<ResourceEntry>())));
+    return CancelCallback();
+  }
+
+  const UploadSession& session = upload_session_[upload_url];
+  if (session.uploaded_size == session.content_length) {
+    if (session.resource_id.empty()) {
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(callback, UploadRangeResponse(HTTP_CREATED, 0, 0),
+                     base::Passed(scoped_ptr<ResourceEntry>())));

[hashimoto, 2013/06/21 04:16:21]

Why are you returning null pointers even in success cases?

BTW, is this part needed to be in this change?
Please add tests for this method if you change the implementation.

[tzik, 2013/06/21 05:06:52]

IIUC, the server doesn't return resource entry for this request. Let me check
it.

[tzik, 2013/06/21 05:35:04]

Done. I move this part of change to another CL.

+      return CancelCallback();
+    }
+
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, UploadRangeResponse(HTTP_SUCCESS, 0, 0),
+                   base::Passed(scoped_ptr<ResourceEntry>())));
+    return CancelCallback();
+  }
+
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback,
+                 UploadRangeResponse(HTTP_RESUME_INCOMPLETE,
+                                     0, session.uploaded_size),
+                 base::Passed(scoped_ptr<ResourceEntry>())));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::ResumeUpload(
       const base::FilePath& drive_file_path,
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<ResourceEntry> result_entry;
-
   if (offline_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(GDATA_NO_CONNECTION,
                                        start_position,
                                        end_position),
-                   base::Passed(&result_entry)));
+                   base::Passed(scoped_ptr<ResourceEntry>())));
     return CancelCallback();
   }
 
-  DictionaryValue* entry = NULL;
-  entry = FindEntryByUploadUrl(RemoveQueryParameter(upload_url));
-  if (!entry) {
+  if (!ContainsKey(upload_session_, upload_url)) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(HTTP_NOT_FOUND,
                                        start_position,
                                        end_position),
-                   base::Passed(&result_entry)));
+                   base::Passed(scoped_ptr<ResourceEntry>())));
     return CancelCallback();
   }
 
+  UploadSession* session = &upload_session_[upload_url];
+
   // Chunks are required to be sent in such a ways that they fill from the start
   // of the not-yet-uploaded part with no gaps nor overlaps.
-  std::string current_size_string;
-  int64 current_size;
-  if (!entry->GetString("docs$size.$t", &current_size_string) ||
-      !base::StringToInt64(current_size_string, &current_size) ||
-      current_size != start_position) {
+  int64 current_size = session->uploaded_size;

[hashimoto, 2013/06/21 04:16:21]

nit: Do we need this variable?

[tzik, 2013/06/21 05:06:52]

Done.

+  if (current_size != start_position) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(HTTP_BAD_REQUEST,
                                        start_position,
                                        end_position),
-                   base::Passed(&result_entry)));
+                   base::Passed(scoped_ptr<ResourceEntry>())));
     return CancelCallback();
   }
 
-  entry->SetString("docs$size.$t", base::Int64ToString(end_position));
-
   if (!progress_callback.is_null()) {
     // In the real GDataWapi/Drive DriveService, progress is reported in
     // nondeterministic timing. In this fake implementation, we choose to call
     // it twice per one ResumeUpload. This is for making sure that client code
     // works fine even if the callback is invoked more than once; it is the
     // crucial difference of the progress callback from others.
     // Note that progress is notified in the relative offset in each chunk.
     const int64 chunk_size = end_position - start_position;
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(progress_callback, chunk_size / 2, chunk_size));
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(progress_callback, chunk_size, chunk_size));
   }
 
   if (content_length != end_position) {
+    session->uploaded_size = end_position;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(HTTP_RESUME_INCOMPLETE,
                                        start_position,
                                        end_position),
-                    base::Passed(&result_entry)));
+                   base::Passed(scoped_ptr<ResourceEntry>())));
     return CancelCallback();
   }
 
+  std::string content_data;
+  if (!file_util::ReadFileToString(local_file_path, &content_data)) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   UploadRangeResponse(GDATA_FILE_ERROR,
+                                       start_position,
+                                       end_position),
+                   base::Passed(scoped_ptr<ResourceEntry>())));
+    return CancelCallback();
+  }
+  session->uploaded_size = end_position;
+
+  if (session->resource_id.empty()) {

[hashimoto, 2013/06/21 04:16:21]

resource_id.empty() is true iff the upload is for a new file, right?
I think having a comment about it would help future readers.

BTW, do we still need to append mode=newfile|existing parameter for URLs?

[tzik, 2013/06/21 05:06:52]

Done.

+    const DictionaryValue* new_entry = AddNewEntry(
+        session->content_type,
+        content_data,
+        session->parent_resource_id,
+        session->title,
+        false,  // shared_with_me
+        "file");
+    if (!new_entry) {
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(callback,
+                     UploadRangeResponse(HTTP_NOT_FOUND,
+                                         start_position,
+                                         end_position),
+                     base::Passed(scoped_ptr<ResourceEntry>())));
+      return CancelCallback();
+    }
+
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   UploadRangeResponse(HTTP_CREATED,
+                                       start_position,
+                                       end_position),
+                   base::Passed(ResourceEntry::CreateFrom(*new_entry))));
+    return CancelCallback();
+  }
+
+  DictionaryValue* entry = FindEntryByResourceId(session->resource_id);
+  if (!entry) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   UploadRangeResponse(HTTP_NOT_FOUND,
+                                       start_position,
+                                       end_position),
+                   base::Passed(scoped_ptr<ResourceEntry>())));
+    return CancelCallback();
+  }
+
+  std::string entry_etag;
+  entry->GetString("gd$etag", &entry_etag);
+  if (entry_etag.empty() || session->etag != entry_etag) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   UploadRangeResponse(HTTP_PRECONDITION,
+                                       start_position,
+                                       end_position),
+                   base::Passed(scoped_ptr<ResourceEntry>())));
+    return CancelCallback();
+  }
+
+  entry->SetString("docs$md5Checksum.$t", base::MD5String(content_data));
+  entry->Set("test$data",
+             base::BinaryValue::CreateWithCopiedBuffer(
+                 content_data.data(), content_data.size()));
+  entry->SetString("docs$size.$t", base::Int64ToString(end_position));
   AddNewChangestamp(entry);
-  result_entry = ResourceEntry::CreateFrom(*entry).Pass();
-
-  std::string upload_mode;
-  bool upload_mode_found =
-      net::GetValueForKeyInQuery(upload_url, "mode", &upload_mode);
-  DCHECK(upload_mode_found &&
-         (upload_mode == "newfile" || upload_mode == "existing"));
-
-  GDataErrorCode return_code =
-      upload_mode == "newfile" ? HTTP_CREATED : HTTP_SUCCESS;
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
-                 UploadRangeResponse(return_code,
+                 UploadRangeResponse(HTTP_SUCCESS,

[hashimoto, 2013/06/21 04:16:21]

Please return HTTP_CREATED for new files.

[tzik, 2013/06/21 05:06:52]

Uploads for new file are handled around 1111, so this is existing file case.

[hashimoto, 2013/06/21 05:41:24]

You're right, thanks.

                                      start_position,
                                      end_position),
-                 base::Passed(&result_entry)));
+                 base::Passed(ResourceEntry::CreateFrom(*entry))));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::AuthorizeApp(
     const std::string& resource_id,
     const std::string& app_id,
     const AuthorizeAppCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   return CancelCallback();
@@ skipping 121 matching lines @@
           entry->GetString("content.src", &current_content_url) &&
           content_url == GURL(current_content_url)) {
         return entry;
       }
     }
   }
 
   return NULL;
 }
 
-base::DictionaryValue* FakeDriveService::FindEntryByUploadUrl(
-    const GURL& upload_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  base::ListValue* entries = NULL;
-  // Go through entries and return the one that matches |upload_url|.
-  if (resource_list_value_->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));
 
   ++resource_id_count_;
   return base::StringPrintf("resource_id_%d", resource_id_count_);
 }
 
 void FakeDriveService::AddNewChangestamp(base::DictionaryValue* entry) {

[hashimoto, 2013/06/21 04:16:21]

How about renaming this method to something like AddNewChangestampAndETag?
Please update the method comment too.

[tzik, 2013/06/21 05:06:52]

Done.

   ++largest_changestamp_;
   entry->SetString("docs$changestamp.value",
                    base::Int64ToString(largest_changestamp_));
+  entry->SetString("gd$etag",
+                   "etag_" + base::Int64ToString(largest_changestamp_));
 }
 
 const base::DictionaryValue* FakeDriveService::AddNewEntry(
     const std::string& content_type,
     const std::string& content_data,
     const std::string& parent_resource_id,
     const std::string& title,
     bool shared_with_me,
     const std::string& entry_kind) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 11 matching lines @@
   new_entry->SetString("gd$resourceId.$t", resource_id);
   new_entry->SetString("title.$t", title);
   new_entry->SetString("docs$filename", title);
   // Set the contents, size and MD5 for a file.
   if (entry_kind == "file") {
     new_entry->Set("test$data",
         base::BinaryValue::CreateWithCopiedBuffer(
             content_data.c_str(), content_data.size()));
     new_entry->SetString("docs$size.$t",
                          base::Int64ToString(content_data.size()));
-    // TODO(satorux): Set the correct MD5 here.
     new_entry->SetString("docs$md5Checksum.$t",
-                         "3b4385ebefec6e743574c76bbd0575de");
+                         base::MD5String(content_data));
   }
 
   // Add "category" which sets the resource type to |entry_kind|.
   base::ListValue* categories = new base::ListValue;
   base::DictionaryValue* category = new base::DictionaryValue;
   category->SetString("scheme", "http://schemas.google.com/g/2005#kind");
   category->SetString("term", "http://schemas.google.com/docs/2007#" +
                       entry_kind);
   categories->Append(category);
   new_entry->Set("category", categories);
@@ skipping 164 matching lines @@
 
   if (load_counter)
     *load_counter += 1;
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS,
                  base::Passed(&resource_list)));
 }
 
+GURL FakeDriveService::GetNewUploadSessionUrl() {
+  return GURL("https://upload_session_url/" +
+              base::Int64ToString(next_upload_sequence_number_++));
+}
+
 }  // namespace drive