google_apis: Add set_offline() to FakeDriveService

This can be used to simulate the offline state.

BUG=162350
TEST=none; no changes in production code.

Review URL: https://codereview.chromium.org/11827045

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@176040 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/google_apis/fake_drive_service.cc

@@ -17,7 +17,8 @@ using content::BrowserThread;
 namespace google_apis {
 
 FakeDriveService::FakeDriveService()
-    : resource_id_count_(0) {
+    : resource_id_count_(0),
+      offline_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
@@ -108,6 +109,16 @@ void FakeDriveService::GetResourceList(
   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(
@@ -123,6 +134,16 @@ void FakeDriveService::GetResourceEntry(
   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 =
@@ -144,6 +165,15 @@ void FakeDriveService::GetAccountMetadata(
   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(
@@ -158,6 +188,16 @@ void FakeDriveService::GetApplicationInfo(
   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(
@@ -174,6 +214,12 @@ void FakeDriveService::DeleteResource(
   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|.
@@ -226,6 +272,15 @@ void FakeDriveService::DownloadFile(
   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(
@@ -257,6 +312,16 @@ void FakeDriveService::CopyHostedDocument(
   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|.
@@ -320,6 +385,12 @@ void FakeDriveService::RenameResource(
   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",
@@ -340,6 +411,12 @@ void FakeDriveService::AddResourceToDirectory(
   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;
@@ -381,6 +458,12 @@ void FakeDriveService::RemoveResourceFromDirectory(
   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;
@@ -414,6 +497,16 @@ void FakeDriveService::AddNewDirectory(
   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 =
@@ -590,6 +683,8 @@ base::DictionaryValue* FakeDriveService::FindEntryByContentUrl(
 }
 
 std::string FakeDriveService::GetNewResourceId() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   ++resource_id_count_;
   return base::StringPrintf("resource_id_%d", resource_id_count_);
 }

chrome/browser/google_apis/fake_drive_service.h

@@ -32,6 +32,10 @@ class FakeDriveService : public DriveServiceInterface {
   // Loads the application info for Drive API. Returns true on success.
   bool LoadApplicationInfoForDriveApi(const std::string& relative_path);
 
+  // Changes the offline state. All functions fail with GDATA_NO_CONNECTION
+  // when offline. By default the offline state is false.
+  void set_offline(bool offline) { offline_ = offline; }
+
   // DriveServiceInterface Overrides
   virtual void Initialize(Profile* profile) OVERRIDE;
   virtual void AddObserver(DriveServiceObserver* observer) OVERRIDE;
@@ -119,6 +123,7 @@ class FakeDriveService : public DriveServiceInterface {
   scoped_ptr<base::Value> account_metadata_value_;
   scoped_ptr<base::Value> app_info_value_;
   int resource_id_count_;
+  bool offline_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDriveService);
 };

chrome/browser/google_apis/fake_drive_service_unittest.cc

@@ -68,6 +68,27 @@ TEST_F(FakeDriveServiceTest, GetResourceList) {
   EXPECT_EQ(12U, resource_list->entries().size());
 }
 
+TEST_F(FakeDriveServiceTest, GetResourceList_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  scoped_ptr<ResourceList> resource_list;
+  fake_service_.GetResourceList(
+      GURL(),
+      0,  // start_changestamp
+      "",  // search_query
+      false, // shared_with_me
+      "",  // directory_resource_id
+      base::Bind(&test_util::CopyResultsFromGetResourceListCallback,
+                 &error,
+                 &resource_list));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+  EXPECT_FALSE(resource_list);
+}
+
 TEST_F(FakeDriveServiceTest, GetAccountMetadata) {
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "gdata/account_metadata.json"));
@@ -87,6 +108,23 @@ TEST_F(FakeDriveServiceTest, GetAccountMetadata) {
   EXPECT_EQ(2U, account_metadata->installed_apps().size());
 }
 
+TEST_F(FakeDriveServiceTest, GetAccountMetadata_Offline) {
+  ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
+      "gdata/account_metadata.json"));
+  fake_service_.set_offline(true);
+
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  scoped_ptr<AccountMetadataFeed> account_metadata;
+  fake_service_.GetAccountMetadata(
+      base::Bind(&test_util::CopyResultsFromGetAccountMetadataCallback,
+                 &error,
+                 &account_metadata));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+  EXPECT_FALSE(account_metadata);
+}
+
 TEST_F(FakeDriveServiceTest, GetApplicationInfo) {
   ASSERT_TRUE(fake_service_.LoadApplicationInfoForDriveApi(
       "drive/applist.json"));
@@ -104,6 +142,23 @@ TEST_F(FakeDriveServiceTest, GetApplicationInfo) {
   ASSERT_TRUE(app_info);
 }
 
+TEST_F(FakeDriveServiceTest, GetApplicationInfo_Offline) {
+  ASSERT_TRUE(fake_service_.LoadApplicationInfoForDriveApi(
+      "drive/applist.json"));
+  fake_service_.set_offline(true);
+
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  scoped_ptr<base::Value> app_info;
+  fake_service_.GetApplicationInfo(
+      base::Bind(&test_util::CopyResultsFromGetDataCallback,
+                 &error,
+                 &app_info));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+  EXPECT_FALSE(app_info);
+}
+
 TEST_F(FakeDriveServiceTest, GetResourceEntry_ExistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
 
@@ -140,6 +195,24 @@ TEST_F(FakeDriveServiceTest, GetResourceEntry_NonexistingFile) {
   ASSERT_FALSE(resource_entry);
 }
 
+TEST_F(FakeDriveServiceTest, GetResourceEntry_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  const std::string kResourceId = "file:2_file_resource_id";
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  scoped_ptr<ResourceEntry> resource_entry;
+  fake_service_.GetResourceEntry(
+      kResourceId,
+      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
+                 &error,
+                 &resource_entry));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+  EXPECT_FALSE(resource_entry);
+}
+
 TEST_F(FakeDriveServiceTest, DeleteResource_ExistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
 
@@ -171,6 +244,20 @@ TEST_F(FakeDriveServiceTest, DeleteResource_NonexistingFile) {
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
+TEST_F(FakeDriveServiceTest, DeleteResource_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  fake_service_.DeleteResource(
+      GURL("https://file1_link_self/file:2_file_resource_id"),
+      base::Bind(&test_util::CopyResultsFromEntryActionCallback,
+                 &error));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+}
+
 TEST_F(FakeDriveServiceTest, DownloadFile_ExistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
 
@@ -221,6 +308,30 @@ TEST_F(FakeDriveServiceTest, DownloadFile_NonexistingFile) {
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
+TEST_F(FakeDriveServiceTest, DownloadFile_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  const GURL kContentUrl("https://file_content_url/");
+  const FilePath kOutputFilePath = temp_dir.path().AppendASCII("whatever.txt");
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  FilePath output_file_path;
+  fake_service_.DownloadFile(
+      FilePath::FromUTF8Unsafe("/drive/whatever.txt"),  // virtual path
+      kOutputFilePath,
+      kContentUrl,
+      base::Bind(&test_util::CopyResultsFromDownloadActionCallback,
+                 &error,
+                 &output_file_path),
+      GetContentCallback());
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+}
+
 TEST_F(FakeDriveServiceTest, CopyHostedDocument_ExistingHostedDocument) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
 
@@ -279,6 +390,25 @@ TEST_F(FakeDriveServiceTest, CopyHostedDocument_ExistingRegularFile) {
   EXPECT_FALSE(resource_entry);
 }
 
+TEST_F(FakeDriveServiceTest, CopyHostedDocument_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  const std::string kResourceId = "document:5_document_resource_id";
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  scoped_ptr<ResourceEntry> resource_entry;
+  fake_service_.CopyHostedDocument(
+      kResourceId,
+      FILE_PATH_LITERAL("new name"),
+      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
+                 &error,
+                 &resource_entry));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+  EXPECT_FALSE(resource_entry);
+}
+
 TEST_F(FakeDriveServiceTest, RenameResource_ExistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
 
@@ -316,6 +446,24 @@ TEST_F(FakeDriveServiceTest, RenameResource_NonexistingFile) {
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
+TEST_F(FakeDriveServiceTest, RenameResource_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  const std::string kResourceId = "file:2_file_resource_id";
+  const GURL kEditUrl("https://file1_link_self/file:2_file_resource_id");
+
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  fake_service_.RenameResource(
+      kEditUrl,
+      FILE_PATH_LITERAL("new name"),
+      base::Bind(&test_util::CopyResultsFromEntryActionCallback,
+                 &error));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+}
+
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInRootDirectory) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
 
@@ -400,6 +548,25 @@ TEST_F(FakeDriveServiceTest, AddResourceToDirectory_NonexistingFile) {
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
+TEST_F(FakeDriveServiceTest, AddResourceToDirectory_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  const std::string kResourceId = "file:2_file_resource_id";
+  const GURL kEditUrl("https://file1_link_self/file:2_file_resource_id");
+  const GURL kNewParentContentUrl("https://new_url");
+
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  fake_service_.AddResourceToDirectory(
+      kNewParentContentUrl,
+      kEditUrl,
+      base::Bind(&test_util::CopyResultsFromEntryActionCallback,
+                 &error));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+}
+
 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_ExistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
 
@@ -449,6 +616,25 @@ TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_NonexistingFile) {
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
+TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  const std::string kResourceId("file:subdirectory_file_1_id");
+  const GURL kParentContentUrl(
+      "https://dir_1_self_link/folder:1_folder_resource_id");
+
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  fake_service_.RemoveResourceFromDirectory(
+      kParentContentUrl,
+      kResourceId,
+      base::Bind(&test_util::CopyResultsFromEntryActionCallback,
+                 &error));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+}
+
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectory) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
 
@@ -519,4 +705,22 @@ TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonexistingDirectory) {
   EXPECT_FALSE(resource_entry);
 }
 
+TEST_F(FakeDriveServiceTest, AddNewDirectory_Offline) {
+  ASSERT_TRUE(fake_service_.LoadResourceListForWapi("gdata/root_feed.json"));
+  fake_service_.set_offline(true);
+
+  GDataErrorCode error = GDATA_OTHER_ERROR;
+  scoped_ptr<ResourceEntry> resource_entry;
+  fake_service_.AddNewDirectory(
+      GURL(),  // Empty means add it to the root directory.
+      FILE_PATH_LITERAL("new directory"),
+      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
+                 &error,
+                 &resource_entry));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(GDATA_NO_CONNECTION, error);
+  EXPECT_FALSE(resource_entry);
+}
+
 }  // namespace google_apis