Eliminate CopyResultsFromGetResourceEntryCallback.

chrome/browser/google_apis/fake_drive_service_unittest.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/files/scoped_temp_dir.h"
@@ skipping 16 matching lines @@
   FakeDriveServiceTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_) {
   }
 
   // Returns the resource entry that matches |resource_id|.
   scoped_ptr<ResourceEntry> FindEntry(const std::string& resource_id) {
     GDataErrorCode error = GDATA_OTHER_ERROR;
     scoped_ptr<ResourceEntry> resource_entry;
     fake_service_.GetResourceEntry(
         resource_id,
-        base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                   &error,
-                   &resource_entry));
+        test_util::CreateCopyResultCallback(&error, &resource_entry));
     message_loop_.RunUntilIdle();
     return resource_entry.Pass();
   }
 
   // Returns true if the resource identified by |resource_id| exists.
   bool Exists(const std::string& resource_id) {
     scoped_ptr<ResourceEntry> resource_entry = FindEntry(resource_id);
     return resource_entry;
   }
 
   // Adds a new directory at |parent_resource_id| with the given name.
   // Returns true on success.
   bool AddNewDirectory(const std::string& parent_resource_id,
                        const std::string& directory_name) {
     GDataErrorCode error = GDATA_OTHER_ERROR;
     scoped_ptr<ResourceEntry> resource_entry;
     fake_service_.AddNewDirectory(
         parent_resource_id,
         directory_name,
-        base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                   &error,
-                   &resource_entry));
+        test_util::CreateCopyResultCallback(&error, &resource_entry));
     message_loop_.RunUntilIdle();
     return error == HTTP_CREATED;
   }
 
   // Returns true if the resource identified by |resource_id| has a parent
   // identified by |parent_id|.
   bool HasParent(const std::string& resource_id, const std::string& parent_id) {
     const GURL parent_url = FakeDriveService::GetFakeLinkUrl(parent_id);
     scoped_ptr<ResourceEntry> resource_entry = FindEntry(resource_id);
     if (resource_entry.get()) {
@@ skipping 442 matching lines @@
 
 TEST_F(FakeDriveServiceTest, GetResourceEntry_ExistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   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));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(resource_entry);
   // Do some sanity check.
   EXPECT_EQ(kResourceId, resource_entry->resource_id());
 }
 
 TEST_F(FakeDriveServiceTest, GetResourceEntry_NonexistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   const std::string kResourceId = "file:nonexisting_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.GetResourceEntry(
       kResourceId,
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   ASSERT_FALSE(resource_entry);
 }
 
 TEST_F(FakeDriveServiceTest, GetResourceEntry_Offline) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/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));
+      test_util::CreateCopyResultCallback(&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(
       "chromeos/gdata/root_feed.json"));
 
@@ skipping 126 matching lines @@
       "chromeos/gdata/account_metadata.json"));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "document:5_document_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.CopyHostedDocument(
       kResourceId,
       "new name",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(resource_entry);
   // The copied entry should have the new resource ID and the title.
   EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id());
   EXPECT_EQ("new name", resource_entry->title());
   // Should be incremented as a new hosted document was created.
   EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, CopyHostedDocument_NonexistingHostedDocument) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   const std::string kResourceId = "document:nonexisting_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.CopyHostedDocument(
       kResourceId,
       "new name",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, CopyHostedDocument_ExistingRegularFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   const std::string kResourceId = "file:2_file_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.CopyHostedDocument(
       kResourceId,
       "new name",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   // The copy should fail as this is not a hosted document.
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_FALSE(resource_entry);
 }
 
 TEST_F(FakeDriveServiceTest, CopyHostedDocument_Offline) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/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,
       "new name",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&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(
       "chromeos/gdata/root_feed.json"));
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
@@ skipping 278 matching lines @@
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json"));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.AddNewDirectory(
       fake_service_.GetRootResourceId(),
       "new directory",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(resource_entry);
   EXPECT_EQ("resource_id_1", resource_entry->resource_id());
   EXPECT_EQ("new directory", resource_entry->title());
   EXPECT_TRUE(HasParent(resource_entry->resource_id(),
                         fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectoryOnEmptyFileSystem) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/empty_feed.json"));
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json"));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.AddNewDirectory(
       fake_service_.GetRootResourceId(),
       "new directory",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(resource_entry);
   EXPECT_EQ("resource_id_1", resource_entry->resource_id());
   EXPECT_EQ("new directory", resource_entry->title());
   EXPECT_TRUE(HasParent(resource_entry->resource_id(),
                         fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonRootDirectory) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json"));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kParentResourceId = "folder:1_folder_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.AddNewDirectory(
       kParentResourceId,
       "new directory",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(resource_entry);
   EXPECT_EQ("resource_id_1", resource_entry->resource_id());
   EXPECT_EQ("new directory", resource_entry->title());
   EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonexistingDirectory) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   const std::string kParentResourceId = "folder:nonexisting_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.AddNewDirectory(
       kParentResourceId,
       "new directory",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_FALSE(resource_entry);
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_Offline) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceEntry> resource_entry;
   fake_service_.AddNewDirectory(
       fake_service_.GetRootResourceId(),
       "new directory",
-      base::Bind(&test_util::CopyResultsFromGetResourceEntryCallback,
-                 &error,
-                 &resource_entry));
+      test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(resource_entry);
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_Offline) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
   fake_service_.set_offline(true);
@@ skipping 319 matching lines @@
 
   EXPECT_EQ(HTTP_CREATED, response.code);
   EXPECT_TRUE(entry.get());
   EXPECT_EQ(15L, entry->file_size());
   EXPECT_TRUE(Exists(entry->resource_id()));
 }
 
 }  // namespace
 
 }  // namespace google_apis