Drive: Move inner structures of DriveAPIService under drive namespace.

chrome/browser/drive/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/drive/fake_drive_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_util.h"
@@ skipping 61 matching lines @@
     return entry && !entry->labels().is_trashed();
   }
 
   // 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_title) {
     DriveApiErrorCode error = DRIVE_OTHER_ERROR;
     scoped_ptr<FileResource> entry;
     fake_service_.AddNewDirectory(
-        parent_resource_id,
-        directory_title,
-        DriveServiceInterface::AddNewDirectoryOptions(),
+        parent_resource_id, directory_title, AddNewDirectoryOptions(),
         test_util::CreateCopyResultCallback(&error, &entry));
     base::RunLoop().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) {
     scoped_ptr<FileResource> entry = FindEntry(resource_id);
     if (entry) {
@@ skipping 1379 matching lines @@
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_EmptyParent) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
-      std::string(),
-      "new directory",
-      DriveServiceInterface::AddNewDirectoryOptions(),
+      std::string(), "new directory", AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->IsDirectory());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ("new directory", entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
-      fake_service_.GetRootResourceId(),
-      "new directory",
-      DriveServiceInterface::AddNewDirectoryOptions(),
+      fake_service_.GetRootResourceId(), "new directory",
+      AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->IsDirectory());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ("new directory", entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectoryOnEmptyFileSystem) {
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
-      fake_service_.GetRootResourceId(),
-      "new directory",
-      DriveServiceInterface::AddNewDirectoryOptions(),
+      fake_service_.GetRootResourceId(), "new directory",
+      AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->IsDirectory());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ("new directory", entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kParentResourceId = "1_folder_resource_id";
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
-      kParentResourceId,
-      "new directory",
-      DriveServiceInterface::AddNewDirectoryOptions(),
+      kParentResourceId, "new directory", AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->IsDirectory());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ("new directory", entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), kParentResourceId));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonexistingDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   const std::string kParentResourceId = "nonexisting_resource_id";
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
-      kParentResourceId,
-      "new directory",
-      DriveServiceInterface::AddNewDirectoryOptions(),
+      kParentResourceId, "new directory", AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
-      fake_service_.GetRootResourceId(),
-      "new directory",
-      DriveServiceInterface::AddNewDirectoryOptions(),
+      fake_service_.GetRootResourceId(), "new directory",
+      AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo", 13, "1_folder_resource_id", "new file.foo",
-      FakeDriveService::UploadNewFileOptions(),
+      UploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_NotFound) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo", 13, "non_existent", "new file.foo",
-      FakeDriveService::UploadNewFileOptions(),
+      UploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo", 13, "1_folder_resource_id", "new file.foo",
-      FakeDriveService::UploadNewFileOptions(),
+      UploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(upload_location.is_empty());
   EXPECT_NE(GURL("https://1_folder_resumable_create_media_link?mode=newfile"),
             upload_location);
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "test/foo", 13, "2_file_resource_id",
-      FakeDriveService::UploadExistingFileOptions(),
+      UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_Forbidden) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   EXPECT_EQ(HTTP_SUCCESS, fake_service_.SetUserPermission(
       "2_file_resource_id", google_apis::drive::PERMISSION_ROLE_READER));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "test/foo", 13, "2_file_resource_id",
-      FakeDriveService::UploadExistingFileOptions(),
+      UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_FORBIDDEN, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_NotFound) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "test/foo", 13, "non_existent",
-      FakeDriveService::UploadExistingFileOptions(),
+      UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_WrongETag) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  FakeDriveService::UploadExistingFileOptions options;
+  UploadExistingFileOptions options;
   options.etag = "invalid_etag";
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "text/plain",
       13,
       "2_file_resource_id",
       options,
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_PRECONDITION, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUpload_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   scoped_ptr<FileResource> entry = FindEntry("2_file_resource_id");
   ASSERT_TRUE(entry);
 
-  FakeDriveService::UploadExistingFileOptions options;
+  UploadExistingFileOptions options;
   options.etag = entry->etag();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "text/plain",
       13,
       "2_file_resource_id",
       options,
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_valid());
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo", 15, "1_folder_resource_id", "new file.foo",
-      FakeDriveService::UploadNewFileOptions(),
+      UploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(upload_location.is_empty());
   EXPECT_NE(GURL("https://1_folder_resumable_create_media_link"),
             upload_location);
 
   fake_service_.set_offline(true);
 
@@ skipping 11 matching lines @@
   EXPECT_FALSE(entry.get());
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_NotFound) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo", 15, "1_folder_resource_id", "new file.foo",
-      FakeDriveService::UploadNewFileOptions(),
+      UploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(HTTP_SUCCESS, error);
 
   UploadRangeResponse response;
   scoped_ptr<FileResource> entry;
   fake_service_.ResumeUpload(
       GURL("https://foo.com/"),
       0, 13, 15, "test/foo",
@@ skipping 12 matching lines @@
   base::FilePath local_file_path =
       temp_dir.path().Append(FILE_PATH_LITERAL("File 1.txt"));
   std::string contents("hogefugapiyo");
   ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents));
 
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   scoped_ptr<FileResource> entry = FindEntry("2_file_resource_id");
   ASSERT_TRUE(entry);
 
-  FakeDriveService::UploadExistingFileOptions options;
+  UploadExistingFileOptions options;
   options.etag = entry->etag();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "text/plain",
       contents.size(),
       "2_file_resource_id",
       options,
       test_util::CreateCopyResultCallback(&error, &upload_location));
@@ skipping 50 matching lines @@
       temp_dir.path().Append(FILE_PATH_LITERAL("new file.foo"));
   std::string contents("hogefugapiyo");
   ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents));
 
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo", contents.size(), "1_folder_resource_id", "new file.foo",
-      FakeDriveService::UploadNewFileOptions(),
+      UploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(upload_location.is_empty());
   EXPECT_NE(GURL("https://1_folder_resumable_create_media_link"),
             upload_location);
 
   UploadRangeResponse response;
   scoped_ptr<FileResource> entry;
@@ skipping 274 matching lines @@
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_FALSE(entry);
 }
 
 }  // namespace
 
 }  // namespace drive