google_apis: Introduce AddNewFile() and SetLastModifiedTime() in FakeDriveService

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"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/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"
+#include "chrome/browser/google_apis/time_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 
 using content::BrowserThread;
 
 namespace google_apis {
 namespace {
 
 // Rel property of upload link in the entries dictionary value.
 const char kUploadUrlRel[] =
@@ skipping 881 matching lines @@
                  base::Passed(&result_entry)));
 }
 
 void FakeDriveService::AuthorizeApp(const std::string& resource_id,
                                     const std::string& app_id,
                                     const AuthorizeAppCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 }
 
+void FakeDriveService::AddNewFile(const std::string& content_type,
+                                  int64 content_length,
+                                  const std::string& parent_resource_id,
+                                  const std::string& title,
+                                  const GetResourceEntryCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
+  if (offline_) {
+    scoped_ptr<ResourceEntry> null;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   GDATA_NO_CONNECTION,
+                   base::Passed(&null)));
+    return;
+  }
+
+  const base::DictionaryValue* new_entry = AddNewEntry(content_type,
+                                                       content_length,
+                                                       parent_resource_id,
+                                                       title,
+                                                       "file");
+  if (!new_entry) {
+    scoped_ptr<ResourceEntry> null;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
+    return;
+  }
+
+  scoped_ptr<ResourceEntry> parsed_entry(
+      ResourceEntry::CreateFrom(*new_entry));
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, HTTP_CREATED, base::Passed(&parsed_entry)));
+}
+
+void FakeDriveService::SetLastModifiedTime(
+    const std::string& resource_id,
+    const base::Time& last_modified_time,
+    const GetResourceEntryCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
+  if (offline_) {
+    scoped_ptr<ResourceEntry> null;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   GDATA_NO_CONNECTION,
+                   base::Passed(&null)));
+    return;
+  }
+
+  base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
+  if (!entry) {
+    scoped_ptr<ResourceEntry> null;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
+    return;
+  }
+
+  entry->SetString("updated.$t", util::FormatTimeAsString(last_modified_time));
+
+  scoped_ptr<ResourceEntry> parsed_entry(
+      ResourceEntry::CreateFrom(*entry));
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, HTTP_SUCCESS, base::Passed(&parsed_entry)));
+}
+
 base::DictionaryValue* FakeDriveService::FindEntryByResourceId(
     const std::string& resource_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::DictionaryValue* resource_list_dict = NULL;
   base::ListValue* entries = NULL;
   // Go through entries and return the one that matches |resource_id|.
   if (resource_list_value_->GetAsDictionary(&resource_list_dict) &&
       resource_list_dict->GetList("entry", &entries)) {
     for (size_t i = 0; i < entries->GetSize(); ++i) {
@@ skipping 158 matching lines @@
 
   base::DictionaryValue* raw_new_entry = new_entry.release();
   base::ListValue* entries = NULL;
   if (resource_list_dict->GetList("entry", &entries))
     entries->Append(raw_new_entry);
 
   return raw_new_entry;
 }
 
 }  // namespace google_apis