drive: Rename DriveScheduler to JobScheduler

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/drive_scheduler.h"
+#include "chrome/browser/chromeos/drive/job_scheduler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
@@ skipping 75 matching lines @@
   virtual void OnJobDone(const JobInfo& info, FileError error) OVERRIDE {
     events.push_back(EventLog(DONE, info));
   }
 
  private:
   std::vector<EventLog> events;
 };
 
 }  // namespace
 
-class DriveSchedulerTest : public testing::Test {
+class JobSchedulerTest : public testing::Test {
  public:
-  DriveSchedulerTest()
+  JobSchedulerTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         profile_(new TestingProfile) {
   }
 
   virtual void SetUp() OVERRIDE {
     fake_network_change_notifier_.reset(new FakeNetworkChangeNotifier);
 
     fake_drive_service_.reset(new google_apis::FakeDriveService());
     fake_drive_service_->LoadResourceListForWapi(
         "chromeos/gdata/root_feed.json");
     fake_drive_service_->LoadAccountMetadataForWapi(
         "chromeos/gdata/account_metadata.json");
     fake_drive_service_->LoadAppListForDriveApi(
         "chromeos/drive/applist.json");
 
-    scheduler_.reset(new DriveScheduler(profile_.get(),
-                                        fake_drive_service_.get()));
+    scheduler_.reset(new JobScheduler(profile_.get(),
+                                      fake_drive_service_.get()));
     scheduler_->SetDisableThrottling(true);
   }
 
   virtual void TearDown() OVERRIDE {
     // The scheduler should be deleted before NetworkLibrary, as it
     // registers itself as observer of NetworkLibrary.
     scheduler_.reset();
     google_apis::test_util::RunBlockingPoolTask();
     fake_drive_service_.reset();
     fake_network_change_notifier_.reset();
@@ skipping 26 matching lines @@
   }
 
   // Sets up FakeNetworkChangeNotifier as if it's disconnected.
   void ConnectToNone() {
     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_NONE);
   }
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   scoped_ptr<TestingProfile> profile_;
-  scoped_ptr<DriveScheduler> scheduler_;
+  scoped_ptr<JobScheduler> scheduler_;
   scoped_ptr<FakeNetworkChangeNotifier> fake_network_change_notifier_;
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
 };
 
-TEST_F(DriveSchedulerTest, GetAboutResource) {
+TEST_F(JobSchedulerTest, GetAboutResource) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::AboutResource> about_resource;
   scheduler_->GetAboutResource(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &about_resource));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(about_resource);
 }
 
-TEST_F(DriveSchedulerTest, GetAppList) {
+TEST_F(JobSchedulerTest, GetAppList) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::AppList> app_list;
 
   scheduler_->GetAppList(
       google_apis::test_util::CreateCopyResultCallback(&error, &app_list));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(app_list);
 }
 
-TEST_F(DriveSchedulerTest, GetAccountMetadata) {
+TEST_F(JobSchedulerTest, GetAccountMetadata) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::AccountMetadata> account_metadata;
 
   scheduler_->GetAccountMetadata(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &account_metadata));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(account_metadata);
 }
 
-TEST_F(DriveSchedulerTest, GetAllResourceList) {
+TEST_F(JobSchedulerTest, GetAllResourceList) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceList> resource_list;
 
   scheduler_->GetAllResourceList(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &resource_list));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(resource_list);
 }
 
-TEST_F(DriveSchedulerTest, GetResourceListInDirectory) {
+TEST_F(JobSchedulerTest, GetResourceListInDirectory) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceList> resource_list;
 
   scheduler_->GetResourceListInDirectory(
       fake_drive_service_->GetRootResourceId(),
       google_apis::test_util::CreateCopyResultCallback(
           &error, &resource_list));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(resource_list);
 }
 
-TEST_F(DriveSchedulerTest, Search) {
+TEST_F(JobSchedulerTest, Search) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceList> resource_list;
 
   scheduler_->Search(
       "File",  // search query
       google_apis::test_util::CreateCopyResultCallback(
           &error, &resource_list));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(resource_list);
 }
 
-TEST_F(DriveSchedulerTest, GetChangeList) {
+TEST_F(JobSchedulerTest, GetChangeList) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 
   // Create a new directory.
   // The loaded (initial) changestamp is 654321. Thus, by this operation,
   // it should become 654322.
   {
     scoped_ptr<google_apis::ResourceEntry> resource_entry;
     fake_drive_service_->AddNewDirectory(
@@ skipping 10 matching lines @@
   scheduler_->GetChangeList(
       654321 + 1,  // start_changestamp
       google_apis::test_util::CreateCopyResultCallback(
           &error, &resource_list));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(resource_list);
 }
 
-TEST_F(DriveSchedulerTest, ContinueGetResourceList) {
+TEST_F(JobSchedulerTest, ContinueGetResourceList) {
   ConnectToWifi();
   fake_drive_service_->set_default_max_results(2);
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceList> resource_list;
 
   scheduler_->GetAllResourceList(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &resource_list));
   google_apis::test_util::RunBlockingPoolTask();
@@ skipping 13 matching lines @@
   scheduler_->ContinueGetResourceList(
       next_url,
       google_apis::test_util::CreateCopyResultCallback(
           &error, &resource_list));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(resource_list);
 }
 
-TEST_F(DriveSchedulerTest, GetResourceEntry) {
+TEST_F(JobSchedulerTest, GetResourceEntry) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceEntry> entry;
 
   scheduler_->GetResourceEntry(
       "file:2_file_resource_id",  // resource ID
       DriveClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
 }
 
-TEST_F(DriveSchedulerTest, DeleteResource) {
+TEST_F(JobSchedulerTest, DeleteResource) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 
   scheduler_->DeleteResource(
       "file:2_file_resource_id",
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
-TEST_F(DriveSchedulerTest, CopyHostedDocument) {
+TEST_F(JobSchedulerTest, CopyHostedDocument) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceEntry> entry;
 
   scheduler_->CopyHostedDocument(
       "document:5_document_resource_id",  // resource ID
       "New Document",  // new name
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
 }
 
-TEST_F(DriveSchedulerTest, RenameResource) {
+TEST_F(JobSchedulerTest, RenameResource) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 
   scheduler_->RenameResource(
       "file:2_file_resource_id",
       "New Name",
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
-TEST_F(DriveSchedulerTest, AddResourceToDirectory) {
+TEST_F(JobSchedulerTest, AddResourceToDirectory) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 
   scheduler_->AddResourceToDirectory(
       "folder:1_folder_resource_id",
       "file:2_file_resource_id",
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
-TEST_F(DriveSchedulerTest, RemoveResourceFromDirectory) {
+TEST_F(JobSchedulerTest, RemoveResourceFromDirectory) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 
   scheduler_->RemoveResourceFromDirectory(
       "folder:1_folder_resource_id",
       "file:subdirectory_file_1_id",  // resource ID
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
-TEST_F(DriveSchedulerTest, AddNewDirectory) {
+TEST_F(JobSchedulerTest, AddNewDirectory) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceEntry> entry;
 
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),  // Root directory.
       "New Directory",
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(google_apis::HTTP_CREATED, error);
   ASSERT_TRUE(entry);
 }
 
-TEST_F(DriveSchedulerTest, GetResourceEntryPriority) {
+TEST_F(JobSchedulerTest, GetResourceEntryPriority) {
   // Disconnect from the network to prevent jobs from starting.
   ConnectToNone();
 
   std::string resource_1("file:1_file_resource_id");
   std::string resource_2("file:2_file_resource_id");
   std::string resource_3("file:3_file_resource_id");
   std::string resource_4("file:4_file_resource_id");
   std::vector<std::string> resource_ids;
 
   scheduler_->GetResourceEntry(
@@ skipping 25 matching lines @@
   ConnectToWifi();
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(resource_ids.size(), 4ul);
   ASSERT_EQ(resource_ids[0], resource_1);
   ASSERT_EQ(resource_ids[1], resource_4);
   ASSERT_EQ(resource_ids[2], resource_3);
   ASSERT_EQ(resource_ids[3], resource_2);
 }
 
-TEST_F(DriveSchedulerTest, GetResourceEntryNoConnection) {
+TEST_F(JobSchedulerTest, GetResourceEntryNoConnection) {
   ConnectToNone();
 
   std::string resource("file:1_file_resource_id");
   std::vector<std::string> resource_ids;
 
   scheduler_->GetResourceEntry(
       resource,  // resource ID
       DriveClientContext(BACKGROUND),
       base::Bind(&CopyResourceIdFromGetResourceEntryCallback,
                  &resource_ids,
                  resource));
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(resource_ids.size(), 0ul);
 
   // Reconnect to the net.
   ConnectToWifi();
 
   google_apis::test_util::RunBlockingPoolTask();
 
   ASSERT_EQ(resource_ids.size(), 1ul);
   ASSERT_EQ(resource_ids[0], resource);
 }
 
-TEST_F(DriveSchedulerTest, DownloadFileCellularDisabled) {
+TEST_F(JobSchedulerTest, DownloadFileCellularDisabled) {
   ConnectToCellular();
 
   // Disable fetching over cellular network.
   profile_->GetPrefs()->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   // Try to get a file in the background
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const GURL kContentUrl("https://file_content_url/");
@@ skipping 33 matching lines @@
 
   // Check the download again
   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
   std::string content;
   EXPECT_EQ(output_file_path, kOutputFilePath);
   ASSERT_TRUE(file_util::ReadFileToString(output_file_path, &content));
   // The content is "x"s of the file size specified in root_feed.json.
   EXPECT_EQ("xxxxxxxxxx", content);
 }
 
-TEST_F(DriveSchedulerTest, DownloadFileWimaxDisabled) {
+TEST_F(JobSchedulerTest, DownloadFileWimaxDisabled) {
   ConnectToWimax();
 
   // Disable fetching over cellular network.
   profile_->GetPrefs()->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   // Try to get a file in the background
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const GURL kContentUrl("https://file_content_url/");
@@ skipping 33 matching lines @@
 
   // Check the download again
   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
   std::string content;
   EXPECT_EQ(output_file_path, kOutputFilePath);
   ASSERT_TRUE(file_util::ReadFileToString(output_file_path, &content));
   // The content is "x"s of the file size specified in root_feed.json.
   EXPECT_EQ("xxxxxxxxxx", content);
 }
 
-TEST_F(DriveSchedulerTest, DownloadFileCellularEnabled) {
+TEST_F(JobSchedulerTest, DownloadFileCellularEnabled) {
   ConnectToCellular();
 
   // Enable fetching over cellular network.
   profile_->GetPrefs()->SetBoolean(prefs::kDisableDriveOverCellular, false);
 
   // Try to get a file in the background
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const GURL kContentUrl("https://file_content_url/");
@@ skipping 25 matching lines @@
 
   // Check the download
   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
   std::string content;
   EXPECT_EQ(output_file_path, kOutputFilePath);
   ASSERT_TRUE(file_util::ReadFileToString(output_file_path, &content));
   // The content is "x"s of the file size specified in root_feed.json.
   EXPECT_EQ("xxxxxxxxxx", content);
 }
 
-TEST_F(DriveSchedulerTest, DownloadFileWimaxEnabled) {
+TEST_F(JobSchedulerTest, DownloadFileWimaxEnabled) {
   ConnectToWimax();
 
   // Enable fetching over cellular network.
   profile_->GetPrefs()->SetBoolean(prefs::kDisableDriveOverCellular, false);
 
   // Try to get a file in the background
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const GURL kContentUrl("https://file_content_url/");
@@ skipping 25 matching lines @@
 
   // Check the download
   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
   std::string content;
   EXPECT_EQ(output_file_path, kOutputFilePath);
   ASSERT_TRUE(file_util::ReadFileToString(output_file_path, &content));
   // The content is "x"s of the file size specified in root_feed.json.
   EXPECT_EQ("xxxxxxxxxx", content);
 }
 
-TEST_F(DriveSchedulerTest, JobInfo) {
+TEST_F(JobSchedulerTest, JobInfo) {
   JobListLogger logger;
   scheduler_->AddObserver(&logger);
 
   // Disable background upload/download.
   ConnectToWimax();
   profile_->GetPrefs()->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
@@ skipping 95 matching lines @@
   ConnectToWifi();
   google_apis::test_util::RunBlockingPoolTask();
 
   // All jobs should have finished.
   EXPECT_EQ(0U, scheduler_->GetJobInfoList().size());
   EXPECT_TRUE(logger.Has(JobListLogger::UPDATED, TYPE_DOWNLOAD_FILE));
   EXPECT_TRUE(logger.Has(JobListLogger::DONE, TYPE_DOWNLOAD_FILE));
 }
 
 
-TEST_F(DriveSchedulerTest, JobInfoProgress) {
+TEST_F(JobSchedulerTest, JobInfoProgress) {
   JobListLogger logger;
   scheduler_->AddObserver(&logger);
 
   ConnectToWifi();
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   base::FilePath path;
@@ skipping 35 matching lines @@
 
   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(), 5);
 }
 
 }  // namespace drive