Drive: Move inner structures of DriveAPIService under drive namespace.

chrome/browser/drive/drive_uploader_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/drive_uploader.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 416 matching lines @@
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
-      kTestInitiateUploadResourceId,
-      local_path,
-      kTestMimeType,
-      DriveUploader::UploadExistingFileOptions(),
-      test_util::CreateCopyResultCallback(
-          &error, &upload_location, &entry),
+      kTestInitiateUploadResourceId, local_path, kTestMimeType,
+      UploadExistingFileOptions(),
+      test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, mock_service.resume_upload_call_count());
   EXPECT_EQ(1, mock_service.multipart_upload_call_count());
   EXPECT_EQ(0, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
   ASSERT_TRUE(entry);
@@ skipping 10 matching lines @@
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
-      kTestInitiateUploadResourceId,
-      local_path,
-      kTestMimeType,
-      DriveUploader::UploadExistingFileOptions(),
-      test_util::CreateCopyResultCallback(
-          &error, &upload_location, &entry),
+      kTestInitiateUploadResourceId, local_path, kTestMimeType,
+      UploadExistingFileOptions(),
+      test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   // 512KB upload should be uploaded as multipart body.
   EXPECT_EQ(0, mock_service.resume_upload_call_count());
   EXPECT_EQ(1, mock_service.multipart_upload_call_count());
   EXPECT_EQ(512 * 1024, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
@@ skipping 13 matching lines @@
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType,
-      DriveUploader::UploadExistingFileOptions(),
+      UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   // 2MB upload should not be split into multiple chunks.
   EXPECT_EQ(1, mock_service.resume_upload_call_count());
   EXPECT_EQ(0, mock_service.multipart_upload_call_count());
   EXPECT_EQ(2 * 1024 * 1024, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
@@ skipping 13 matching lines @@
 
   DriveApiErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtInitiate mock_service;
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType,
-      DriveUploader::UploadExistingFileOptions(),
+      UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
   EXPECT_FALSE(entry);
 }
 
 TEST_F(DriveUploaderTest, MultipartUploadFail) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(temp_dir_.path(), 512 * 1024,
                                                    &local_path, &data));
 
   DriveApiErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtInitiate mock_service;
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
-  uploader.UploadExistingFile(kTestInitiateUploadResourceId,
-                              local_path,
-                              kTestMimeType,
-                              DriveUploader::UploadExistingFileOptions(),
-                              test_util::CreateCopyResultCallback(
-                                  &error, &upload_location, &entry),
-                              google_apis::ProgressCallback());
+  uploader.UploadExistingFile(
+      kTestInitiateUploadResourceId, local_path, kTestMimeType,
+      UploadExistingFileOptions(),
+      test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
+      google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
   EXPECT_FALSE(entry);
 }
 
 TEST_F(DriveUploaderTest, InitiateUploadNoConflict) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
-  DriveUploader::UploadExistingFileOptions options;
+  UploadExistingFileOptions options;
   options.etag = kTestETag;
   uploader.UploadExistingFile(kTestInitiateUploadResourceId,
                               local_path,
                               kTestMimeType,
                               options,
                               test_util::CreateCopyResultCallback(
                                   &error, &upload_location, &entry),
                               google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, MultipartUploadConflict) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
   const std::string kDestinationETag("destination_etag");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
-  DriveUploader::UploadExistingFileOptions options;
+  UploadExistingFileOptions options;
   options.etag = kDestinationETag;
   uploader.UploadExistingFile(kTestInitiateUploadResourceId,
                               local_path,
                               kTestMimeType,
                               options,
                               test_util::CreateCopyResultCallback(
                                   &error, &upload_location, &entry),
                               google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CONFLICT, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, InitiateUploadConflict) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 2 * 1024 * 1024, &local_path, &data));
   const std::string kDestinationETag("destination_etag");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
-  DriveUploader::UploadExistingFileOptions options;
+  UploadExistingFileOptions options;
   options.etag = kDestinationETag;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType, options,
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CONFLICT, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, ResumeUploadFail) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 2 * 1024 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtResume mock_service;
   DriveUploader uploader(&mock_service,
                          base::MessageLoopProxy::current().get());
-  uploader.UploadExistingFile(kTestInitiateUploadResourceId,
-                              local_path,
-                              kTestMimeType,
-                              DriveUploader::UploadExistingFileOptions(),
-                              test_util::CreateCopyResultCallback(
-                                  &error, &upload_location, &entry),
-                              google_apis::ProgressCallback());
+  uploader.UploadExistingFile(
+      kTestInitiateUploadResourceId, local_path, kTestMimeType,
+      UploadExistingFileOptions(),
+      test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
+      google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_EQ(GURL(kTestUploadExistingFileURL), upload_location);
 }
 
 TEST_F(DriveUploaderTest, GetUploadStatusFail) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
@@ skipping 21 matching lines @@
 TEST_F(DriveUploaderTest, NonExistingSourceFile) {
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   DriveUploader uploader(NULL,  // NULL, the service won't be used.
                          base::MessageLoopProxy::current().get());
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId,
       temp_dir_.path().AppendASCII("_this_path_should_not_exist_"),
-      kTestMimeType,
-      DriveUploader::UploadExistingFileOptions(),
-      test_util::CreateCopyResultCallback(
-          &error, &upload_location, &entry),
+      kTestMimeType, UploadExistingFileOptions(),
+      test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   // Should return failure without doing any attempt to connect to the server.
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, ResumeUpload) {
   base::FilePath local_path;
@@ skipping 28 matching lines @@
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
   ASSERT_TRUE(entry);
   EXPECT_EQ(kTestDummyMd5, entry->md5_checksum());
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(1024 * 1024, 1024 * 1024),
             upload_progress_values[0]);
 }
 
 }  // namespace drive