Add a test for canceling in-flight jobs in drive::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/job_scheduler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 68 matching lines @@
   }
 
   virtual void OnJobDone(const JobInfo& info, FileError error) OVERRIDE {
     events.push_back(EventLog(DONE, info));
   }
 
  private:
   std::vector<EventLog> events;
 };
 
+// Fake drive service extended for testing cancellation.
+// When set_upload_new_file_cancelable is set, this Drive service starts

[hashimoto, 2013/10/16 05:50:10]

nit: "upload_new_file_cancelable is set" or "set_upload_new_file_cancelable is
called"?

[kinaba, 2013/10/16 06:10:53]

Done.

+// returning a closure to cancel from InitiateUploadNewFile(). The task will
+// finish only when the cancel closure is called.
+class CancelTestableFakeDriveService : public FakeDriveService {
+ public:
+  CancelTestableFakeDriveService()
+      : upload_new_file_cancelable_(false) {
+  }
+
+  void set_upload_new_file_cancelable(bool cancelable) {
+    upload_new_file_cancelable_ = cancelable;
+  }
+
+  virtual google_apis::CancelCallback InitiateUploadNewFile(
+      const std::string& content_type,
+      int64 content_length,
+      const std::string& parent_resource_id,
+      const std::string& title,
+      const google_apis::InitiateUploadCallback& callback) OVERRIDE {
+    if (upload_new_file_cancelable_)
+      return base::Bind(callback, google_apis::GDATA_CANCELLED, GURL());
+
+    return FakeDriveService::InitiateUploadNewFile(content_type,
+                                                   content_length,
+                                                   parent_resource_id,
+                                                   title,
+                                                   callback);
+  }
+
+ private:
+  bool upload_new_file_cancelable_;
+};
+
 }  // namespace
 
 class JobSchedulerTest : public testing::Test {
  public:
   JobSchedulerTest()
       : pref_service_(new TestingPrefServiceSimple) {
     test_util::RegisterDrivePrefs(pref_service_->registry());
   }
 
   virtual void SetUp() OVERRIDE {
     fake_network_change_notifier_.reset(
         new test_util::FakeNetworkChangeNotifier);
 
-    fake_drive_service_.reset(new FakeDriveService());
+    fake_drive_service_.reset(new CancelTestableFakeDriveService);
     fake_drive_service_->LoadResourceListForWapi(
         "gdata/root_feed.json");
     fake_drive_service_->LoadAccountMetadataForWapi(
         "gdata/account_metadata.json");
     fake_drive_service_->LoadAppListForDriveApi(
         "drive/applist.json");
 
     scheduler_.reset(new JobScheduler(pref_service_.get(),
                                       fake_drive_service_.get(),
                                       base::MessageLoopProxy::current().get()));
@@ skipping 28 matching lines @@
   }
 
   static int GetMetadataQueueMaxJobCount() {
     return JobScheduler::kMaxJobCount[JobScheduler::METADATA_QUEUE];
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingPrefServiceSimple> pref_service_;
   scoped_ptr<test_util::FakeNetworkChangeNotifier>
       fake_network_change_notifier_;
-  scoped_ptr<FakeDriveService> fake_drive_service_;
+  scoped_ptr<CancelTestableFakeDriveService> fake_drive_service_;
   scoped_ptr<JobScheduler> scheduler_;
 };
 
 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(
@@ skipping 819 matching lines @@
       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::GDATA_CANCELLED, error1);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
+  EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
 }
 
 TEST_F(JobSchedulerTest, CancelRunningJob) {
-  // TODO(kinaba): test for canceling jobs running in the Drive service.
-  // We need to slightly extend FakeDriveService to support CancelCallback.
+  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::GDataErrorCode error1 = google_apis::GDATA_OTHER_ERROR;
+  scoped_ptr<google_apis::ResourceEntry> entry;
+  scheduler_->UploadNewFile(
+      fake_drive_service_->GetRootResourceId(),
+      base::FilePath::FromUTF8Unsafe("dummy/path"),
+      upload_path,
+      "dummy title 1",
+      "text/plain",
+      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::GDataErrorCode error2 = google_apis::GDATA_OTHER_ERROR;
+  scheduler_->UploadNewFile(
+      fake_drive_service_->GetRootResourceId(),
+      base::FilePath::FromUTF8Unsafe("dummy/path"),
+      upload_path,
+      "dummy title 2",
+      "text/plain",
+      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::GDATA_CANCELLED, error1);
+  EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
+  EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
 }
 
 }  // namespace drive