Drive: Move inner structures of DriveAPIService under drive namespace.

chrome/browser/chromeos/drive/job_scheduler_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/chromeos/drive/job_scheduler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 254 matching lines @@
 
   int64 old_largest_change_id =
       fake_drive_service_->about_resource().largest_change_id();
 
   google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
 
   // Create a new directory.
   {
     scoped_ptr<google_apis::FileResource> entry;
     fake_drive_service_->AddNewDirectory(
-        fake_drive_service_->GetRootResourceId(),
-        "new directory",
-        DriveServiceInterface::AddNewDirectoryOptions(),
-        google_apis::test_util::CreateCopyResultCallback(
-            &error, &entry));
+        fake_drive_service_->GetRootResourceId(), "new directory",
+        AddNewDirectoryOptions(),
+        google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(google_apis::HTTP_CREATED, error);
   }
 
   error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::ChangeList> change_list;
   scheduler_->GetChangeList(
       old_largest_change_id + 1,
       google_apis::test_util::CreateCopyResultCallback(&error, &change_list));
   base::RunLoop().RunUntilIdle();
@@ skipping 176 matching lines @@
 }
 
 TEST_F(JobSchedulerTest, AddNewDirectory) {
   ConnectToWifi();
 
   google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),  // Root directory.
-      "New Directory",
-      DriveServiceInterface::AddNewDirectoryOptions(),
-      ClientContext(USER_INITIATED),
+      "New Directory", AddNewDirectoryOptions(), ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_CREATED, error);
   ASSERT_TRUE(entry);
 }
 
 TEST_F(JobSchedulerTest, PriorityHandling) {
   // Saturate the metadata job queue with uninteresting jobs to prevent
   // following jobs from starting.
@@ skipping 10 matching lines @@
   }
 
   // Start jobs with different priorities.
   std::string title_1("new file 1");
   std::string title_2("new file 2");
   std::string title_3("new file 3");
   std::string title_4("new file 4");
   std::vector<std::string> titles;
 
   scheduler_->AddNewDirectory(
-      fake_drive_service_->GetRootResourceId(),
-      title_1,
-      DriveServiceInterface::AddNewDirectoryOptions(),
-      ClientContext(USER_INITIATED),
+      fake_drive_service_->GetRootResourceId(), title_1,
+      AddNewDirectoryOptions(), ClientContext(USER_INITIATED),
       base::Bind(&CopyTitleFromFileResourceCallback, &titles));
   scheduler_->AddNewDirectory(
-      fake_drive_service_->GetRootResourceId(),
-      title_2,
-      DriveServiceInterface::AddNewDirectoryOptions(),
-      ClientContext(BACKGROUND),
+      fake_drive_service_->GetRootResourceId(), title_2,
+      AddNewDirectoryOptions(), ClientContext(BACKGROUND),
       base::Bind(&CopyTitleFromFileResourceCallback, &titles));
   scheduler_->AddNewDirectory(
-      fake_drive_service_->GetRootResourceId(),
-      title_3,
-      DriveServiceInterface::AddNewDirectoryOptions(),
-      ClientContext(BACKGROUND),
+      fake_drive_service_->GetRootResourceId(), title_3,
+      AddNewDirectoryOptions(), ClientContext(BACKGROUND),
       base::Bind(&CopyTitleFromFileResourceCallback, &titles));
   scheduler_->AddNewDirectory(
-      fake_drive_service_->GetRootResourceId(),
-      title_4,
-      DriveServiceInterface::AddNewDirectoryOptions(),
-      ClientContext(USER_INITIATED),
+      fake_drive_service_->GetRootResourceId(), title_4,
+      AddNewDirectoryOptions(), ClientContext(USER_INITIATED),
       base::Bind(&CopyTitleFromFileResourceCallback, &titles));
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(4ul, titles.size());
   EXPECT_EQ(title_1, titles[0]);
   EXPECT_EQ(title_4, titles[1]);
   EXPECT_EQ(title_2, titles[2]);
   EXPECT_EQ(title_3, titles[3]);
 }
@@ skipping 256 matching lines @@
   google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
   scoped_ptr<google_apis::AboutResource> about_resource;
   base::FilePath path;
 
   std::set<JobType> expected_types;
 
   // Add many jobs.
   expected_types.insert(TYPE_ADD_NEW_DIRECTORY);
   scheduler_->AddNewDirectory(
-      fake_drive_service_->GetRootResourceId(),
-      "New Directory",
-      DriveServiceInterface::AddNewDirectoryOptions(),
-      ClientContext(USER_INITIATED),
+      fake_drive_service_->GetRootResourceId(), "New Directory",
+      AddNewDirectoryOptions(), ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   expected_types.insert(TYPE_GET_ABOUT_RESOURCE);
   scheduler_->GetAboutResource(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &about_resource));
   expected_types.insert(TYPE_UPDATE_RESOURCE);
   scheduler_->UpdateResource(
       "2_file_resource_id", std::string(), "New Title", base::Time(),
       base::Time(), google_apis::drive::Properties(),
       ClientContext(USER_INITIATED),
@@ skipping 115 matching lines @@
 
   // Upload job.
   path = temp_dir.path().AppendASCII("new_file.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(path, "Hello"));
   google_apis::DriveApiErrorCode upload_error =
       google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
-      base::FilePath::FromUTF8Unsafe("drive/new_file.txt"),
-      path,
-      "dummy title",
-      "plain/plain",
-      DriveUploader::UploadNewFileOptions(),
-      ClientContext(BACKGROUND),
+      base::FilePath::FromUTF8Unsafe("drive/new_file.txt"), path, "dummy title",
+      "plain/plain", UploadNewFileOptions(), ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&upload_error, &entry));
   base::RunLoop().RunUntilIdle();
 
   std::vector<int64> upload_progress;
   logger.GetProgressInfo(TYPE_UPLOAD_NEW_FILE, &upload_progress);
   ASSERT_TRUE(!upload_progress.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress));
   EXPECT_GE(upload_progress.front(), 0);
   EXPECT_LE(upload_progress.back(), 13);
 }
 
 TEST_F(JobSchedulerTest, CancelPendingJob) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath upload_path = temp_dir.path().AppendASCII("new_file.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(upload_path, "Hello"));
 
   // To create a pending job for testing, set the mode to cellular connection
   // and issue BACKGROUND jobs.
   ConnectToCellular();
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   // Start the first job and record its job ID.
   google_apis::DriveApiErrorCode error1 = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
-      base::FilePath::FromUTF8Unsafe("dummy/path"),
-      upload_path,
-      "dummy title 1",
-      "text/plain",
-      DriveUploader::UploadNewFileOptions(),
+      base::FilePath::FromUTF8Unsafe("dummy/path"), upload_path,
+      "dummy title 1", "text/plain", UploadNewFileOptions(),
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&error1, &entry));
 
   const std::vector<JobInfo>& jobs = scheduler_->GetJobInfoList();
   ASSERT_EQ(1u, jobs.size());
   ASSERT_EQ(STATE_NONE, jobs[0].state);  // Not started yet.
   JobID first_job_id = jobs[0].job_id;
 
   // Start the second job.
   google_apis::DriveApiErrorCode error2 = google_apis::DRIVE_OTHER_ERROR;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
-      base::FilePath::FromUTF8Unsafe("dummy/path"),
-      upload_path,
-      "dummy title 2",
-      "text/plain",
-      DriveUploader::UploadNewFileOptions(),
+      base::FilePath::FromUTF8Unsafe("dummy/path"), upload_path,
+      "dummy title 2", "text/plain", UploadNewFileOptions(),
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&error2, &entry));
 
   // Cancel the first one.
   scheduler_->CancelJob(first_job_id);
 
   // Only the first job should be cancelled.
   ConnectToWifi();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(google_apis::DRIVE_CANCELLED, error1);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
   EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
 }
 
 TEST_F(JobSchedulerTest, CancelRunningJob) {
   ConnectToWifi();
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath upload_path = temp_dir.path().AppendASCII("new_file.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(upload_path, "Hello"));
 
   // Run as a cancelable task.
   fake_drive_service_->set_upload_new_file_cancelable(true);
   google_apis::DriveApiErrorCode error1 = google_apis::DRIVE_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> entry;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
-      base::FilePath::FromUTF8Unsafe("dummy/path"),
-      upload_path,
-      "dummy title 1",
-      "text/plain",
-      DriveUploader::UploadNewFileOptions(),
+      base::FilePath::FromUTF8Unsafe("dummy/path"), upload_path,
+      "dummy title 1", "text/plain", UploadNewFileOptions(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error1, &entry));
 
   const std::vector<JobInfo>& jobs = scheduler_->GetJobInfoList();
   ASSERT_EQ(1u, jobs.size());
   ASSERT_EQ(STATE_RUNNING, jobs[0].state);  // It's running.
   JobID first_job_id = jobs[0].job_id;
 
   // Start the second job normally.
   fake_drive_service_->set_upload_new_file_cancelable(false);
   google_apis::DriveApiErrorCode error2 = google_apis::DRIVE_OTHER_ERROR;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
-      base::FilePath::FromUTF8Unsafe("dummy/path"),
-      upload_path,
-      "dummy title 2",
-      "text/plain",
-      DriveUploader::UploadNewFileOptions(),
+      base::FilePath::FromUTF8Unsafe("dummy/path"), upload_path,
+      "dummy title 2", "text/plain", UploadNewFileOptions(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error2, &entry));
 
   // Cancel the first one.
   scheduler_->CancelJob(first_job_id);
 
   // Only the first job should be cancelled.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(google_apis::DRIVE_CANCELLED, error1);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
   EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
 }
 
 }  // namespace drive