google_apis: Add set_offline() to 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 "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace google_apis {
 
 FakeDriveService::FakeDriveService()
-    : resource_id_count_(0) {
+    : resource_id_count_(0),
+      offline_(false) {
   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 70 matching lines @@
 void FakeDriveService::GetResourceList(
     const GURL& feed_url,
     int64 start_changestamp,
     const std::string& search_query,
     bool shared_with_me,
     const std::string& directory_resource_id,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  if (offline_) {
+    scoped_ptr<ResourceList> null;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   GDATA_NO_CONNECTION,
+                   base::Passed(&null)));
+    return;
+  }
+
   scoped_ptr<ResourceList> resource_list =
       ResourceList::CreateFrom(*resource_list_value_);
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS,
                  base::Passed(&resource_list)));
 }
 
 void FakeDriveService::GetResourceEntry(
     const std::string& resource_id,
     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> resource_entry =
         ResourceEntry::CreateFrom(*entry);
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, base::Passed(&resource_entry)));
     return;
   }
 
   scoped_ptr<ResourceEntry> null;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
 }
 
 void FakeDriveService::GetAccountMetadata(
     const GetAccountMetadataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  if (offline_) {
+    scoped_ptr<AccountMetadataFeed> null;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   GDATA_NO_CONNECTION,
+                   base::Passed(&null)));
+    return;
+  }
   scoped_ptr<AccountMetadataFeed> account_metadata =
       AccountMetadataFeed::CreateFrom(*account_metadata_value_);
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS,
                  base::Passed(&account_metadata)));
 }
 
 void FakeDriveService::GetApplicationInfo(
     const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  if (offline_) {
+    scoped_ptr<base::Value> null;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   GDATA_NO_CONNECTION,
+                   base::Passed(&null)));
+    return;
+  }
+
   scoped_ptr<base::Value> copied_app_info_value(
       app_info_value_->DeepCopy());
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS,
                  base::Passed(&copied_app_info_value)));
 
 }
 
 void FakeDriveService::DeleteResource(
     const GURL& edit_url,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  if (offline_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
+    return;
+  }
+
   base::DictionaryValue* resource_list_dict = NULL;
   base::ListValue* entries = NULL;
   // Go through entries and remove the one that matches |edit_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)) {
@@ skipping 32 matching lines @@
 
 void FakeDriveService::DownloadFile(
     const FilePath& virtual_path,
     const FilePath& local_cache_path,
     const GURL& content_url,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!download_action_callback.is_null());
 
+  if (offline_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(download_action_callback,
+                   GDATA_NO_CONNECTION,
+                   FilePath()));
+    return;
+  }
+
   base::DictionaryValue* entry = FindEntryByContentUrl(content_url);
   if (!entry) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback, HTTP_NOT_FOUND, FilePath()));
     return;
   }
 
   // Write the content URL as the content of the file.
   if (static_cast<int>(content_url.spec().size()) !=
@@ skipping 11 matching lines @@
       base::Bind(download_action_callback, HTTP_SUCCESS, local_cache_path));
 }
 
 void FakeDriveService::CopyHostedDocument(
     const std::string& resource_id,
     const FilePath::StringType& new_name,
     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* resource_list_dict = NULL;
   base::ListValue* entries = NULL;
   // Go through entries and copy 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) {
       base::DictionaryValue* entry = NULL;
       base::DictionaryValue* resource_id_dict = NULL;
       base::ListValue* categories = NULL;
       std::string current_resource_id;
@@ skipping 43 matching lines @@
       base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
 }
 
 void FakeDriveService::RenameResource(
     const GURL& edit_url,
     const FilePath::StringType& new_name,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  if (offline_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
+    return;
+  }
+
   base::DictionaryValue* entry = FindEntryByEditUrl(edit_url);
   if (entry) {
     entry->SetString("title.$t",
                      FilePath(new_name).AsUTF8Unsafe());
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
     return;
   }
 
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
 }
 
 void FakeDriveService::AddResourceToDirectory(
     const GURL& parent_content_url,
     const GURL& edit_url,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  if (offline_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
+    return;
+  }
+
   base::DictionaryValue* entry = FindEntryByEditUrl(edit_url);
   if (entry) {
     base::ListValue* links = NULL;
     if (entry->GetList("link", &links)) {
       bool parent_link_found = false;
       for (size_t i = 0; i < links->GetSize(); ++i) {
         base::DictionaryValue* link = NULL;
         std::string rel;
         if (links->GetDictionary(i, &link) &&
             link->GetString("rel", &rel) &&
@@ skipping 21 matching lines @@
       FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
 }
 
 void FakeDriveService::RemoveResourceFromDirectory(
     const GURL& parent_content_url,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  if (offline_) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
+    return;
+  }
+
   base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (entry) {
     base::ListValue* links = NULL;
     if (entry->GetList("link", &links)) {
       for (size_t i = 0; i < links->GetSize(); ++i) {
         base::DictionaryValue* link = NULL;
         std::string rel;
         std::string href;
         if (links->GetDictionary(i, &link) &&
             link->GetString("rel", &rel) &&
@@ skipping 13 matching lines @@
       FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
 }
 
 void FakeDriveService::AddNewDirectory(
     const GURL& parent_content_url,
     const FilePath::StringType& directory_name,
     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;
+  }
+
   // If the parent content URL is not empty, the parent should exist.
   if (!parent_content_url.is_empty()) {
     base::DictionaryValue* parent_entry =
         FindEntryByContentUrl(parent_content_url);
     if (!parent_entry) {
       scoped_ptr<ResourceEntry> null;
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
       return;
@@ skipping 156 matching lines @@
           content_url == GURL(current_content_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_);
 }
 
 }  // namespace google_apis