Home | History | Annotate | Download | only in drive 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/chromeos/drive/job_scheduler.h"
      6 
      7 #include <set>
      8 
      9 #include "base/bind.h"
     10 #include "base/file_util.h"
     11 #include "base/files/scoped_temp_dir.h"
     12 #include "base/prefs/testing_pref_service.h"
     13 #include "base/run_loop.h"
     14 #include "base/stl_util.h"
     15 #include "base/strings/stringprintf.h"
     16 #include "chrome/browser/chromeos/drive/test_util.h"
     17 #include "chrome/browser/drive/fake_drive_service.h"
     18 #include "chrome/common/pref_names.h"
     19 #include "content/public/test/test_browser_thread_bundle.h"
     20 #include "google_apis/drive/drive_api_parser.h"
     21 #include "google_apis/drive/gdata_wapi_parser.h"
     22 #include "google_apis/drive/test_util.h"
     23 #include "testing/gtest/include/gtest/gtest.h"
     24 
     25 namespace drive {
     26 
     27 namespace {
     28 
     29 // Dummy value passed for the |expected_file_size| parameter of DownloadFile().
     30 const int64 kDummyDownloadFileSize = 0;
     31 
     32 void CopyTitleFromGetResourceEntryCallback(
     33     std::vector<std::string>* title_list_out,
     34     google_apis::GDataErrorCode error_in,
     35     scoped_ptr<google_apis::ResourceEntry> resource_entry_in) {
     36   title_list_out->push_back(resource_entry_in->title());
     37 }
     38 
     39 class JobListLogger : public JobListObserver {
     40  public:
     41   enum EventType {
     42     ADDED,
     43     UPDATED,
     44     DONE,
     45   };
     46 
     47   struct EventLog {
     48     EventType type;
     49     JobInfo info;
     50 
     51     EventLog(EventType type, const JobInfo& info) : type(type), info(info) {
     52     }
     53   };
     54 
     55   // Checks whether the specified type of event has occurred.
     56   bool Has(EventType type, JobType job_type) {
     57     for (size_t i = 0; i < events.size(); ++i) {
     58       if (events[i].type == type && events[i].info.job_type == job_type)
     59         return true;
     60     }
     61     return false;
     62   }
     63 
     64   // Gets the progress event information of the specified type.
     65   void GetProgressInfo(JobType job_type, std::vector<int64>* progress) {
     66     for (size_t i = 0; i < events.size(); ++i) {
     67       if (events[i].type == UPDATED && events[i].info.job_type == job_type)
     68         progress->push_back(events[i].info.num_completed_bytes);
     69     }
     70   }
     71 
     72   // JobListObserver overrides.
     73   virtual void OnJobAdded(const JobInfo& info) OVERRIDE {
     74     events.push_back(EventLog(ADDED, info));
     75   }
     76 
     77   virtual void OnJobUpdated(const JobInfo& info) OVERRIDE {
     78     events.push_back(EventLog(UPDATED, info));
     79   }
     80 
     81   virtual void OnJobDone(const JobInfo& info, FileError error) OVERRIDE {
     82     events.push_back(EventLog(DONE, info));
     83   }
     84 
     85  private:
     86   std::vector<EventLog> events;
     87 };
     88 
     89 // Fake drive service extended for testing cancellation.
     90 // When upload_new_file_cancelable is set, this Drive service starts
     91 // returning a closure to cancel from InitiateUploadNewFile(). The task will
     92 // finish only when the cancel closure is called.
     93 class CancelTestableFakeDriveService : public FakeDriveService {
     94  public:
     95   CancelTestableFakeDriveService()
     96       : upload_new_file_cancelable_(false) {
     97   }
     98 
     99   void set_upload_new_file_cancelable(bool cancelable) {
    100     upload_new_file_cancelable_ = cancelable;
    101   }
    102 
    103   virtual google_apis::CancelCallback InitiateUploadNewFile(
    104       const std::string& content_type,
    105       int64 content_length,
    106       const std::string& parent_resource_id,
    107       const std::string& title,
    108       const google_apis::InitiateUploadCallback& callback) OVERRIDE {
    109     if (upload_new_file_cancelable_)
    110       return base::Bind(callback, google_apis::GDATA_CANCELLED, GURL());
    111 
    112     return FakeDriveService::InitiateUploadNewFile(content_type,
    113                                                    content_length,
    114                                                    parent_resource_id,
    115                                                    title,
    116                                                    callback);
    117   }
    118 
    119  private:
    120   bool upload_new_file_cancelable_;
    121 };
    122 
    123 }  // namespace
    124 
    125 class JobSchedulerTest : public testing::Test {
    126  public:
    127   JobSchedulerTest()
    128       : pref_service_(new TestingPrefServiceSimple) {
    129     test_util::RegisterDrivePrefs(pref_service_->registry());
    130   }
    131 
    132   virtual void SetUp() OVERRIDE {
    133     fake_network_change_notifier_.reset(
    134         new test_util::FakeNetworkChangeNotifier);
    135 
    136     fake_drive_service_.reset(new CancelTestableFakeDriveService);
    137     fake_drive_service_->LoadResourceListForWapi(
    138         "gdata/root_feed.json");
    139     fake_drive_service_->LoadAccountMetadataForWapi(
    140         "gdata/account_metadata.json");
    141     fake_drive_service_->LoadAppListForDriveApi(
    142         "drive/applist.json");
    143 
    144     scheduler_.reset(new JobScheduler(pref_service_.get(),
    145                                       fake_drive_service_.get(),
    146                                       base::MessageLoopProxy::current().get()));
    147     scheduler_->SetDisableThrottling(true);
    148   }
    149 
    150  protected:
    151   // Sets up FakeNetworkChangeNotifier as if it's connected to a network with
    152   // the specified connection type.
    153   void ChangeConnectionType(net::NetworkChangeNotifier::ConnectionType type) {
    154     fake_network_change_notifier_->SetConnectionType(type);
    155   }
    156 
    157   // Sets up FakeNetworkChangeNotifier as if it's connected to wifi network.
    158   void ConnectToWifi() {
    159     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_WIFI);
    160   }
    161 
    162   // Sets up FakeNetworkChangeNotifier as if it's connected to cellular network.
    163   void ConnectToCellular() {
    164     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_2G);
    165   }
    166 
    167   // Sets up FakeNetworkChangeNotifier as if it's connected to wimax network.
    168   void ConnectToWimax() {
    169     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_4G);
    170   }
    171 
    172   // Sets up FakeNetworkChangeNotifier as if it's disconnected.
    173   void ConnectToNone() {
    174     ChangeConnectionType(net::NetworkChangeNotifier::CONNECTION_NONE);
    175   }
    176 
    177   static int GetMetadataQueueMaxJobCount() {
    178     return JobScheduler::kMaxJobCount[JobScheduler::METADATA_QUEUE];
    179   }
    180 
    181   content::TestBrowserThreadBundle thread_bundle_;
    182   scoped_ptr<TestingPrefServiceSimple> pref_service_;
    183   scoped_ptr<test_util::FakeNetworkChangeNotifier>
    184       fake_network_change_notifier_;
    185   scoped_ptr<CancelTestableFakeDriveService> fake_drive_service_;
    186   scoped_ptr<JobScheduler> scheduler_;
    187 };
    188 
    189 TEST_F(JobSchedulerTest, GetAboutResource) {
    190   ConnectToWifi();
    191 
    192   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    193   scoped_ptr<google_apis::AboutResource> about_resource;
    194   scheduler_->GetAboutResource(
    195       google_apis::test_util::CreateCopyResultCallback(
    196           &error, &about_resource));
    197   base::RunLoop().RunUntilIdle();
    198   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    199   ASSERT_TRUE(about_resource);
    200 }
    201 
    202 TEST_F(JobSchedulerTest, GetAppList) {
    203   ConnectToWifi();
    204 
    205   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    206   scoped_ptr<google_apis::AppList> app_list;
    207 
    208   scheduler_->GetAppList(
    209       google_apis::test_util::CreateCopyResultCallback(&error, &app_list));
    210   base::RunLoop().RunUntilIdle();
    211 
    212   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    213   ASSERT_TRUE(app_list);
    214 }
    215 
    216 TEST_F(JobSchedulerTest, GetAllResourceList) {
    217   ConnectToWifi();
    218 
    219   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    220   scoped_ptr<google_apis::ResourceList> resource_list;
    221 
    222   scheduler_->GetAllResourceList(
    223       google_apis::test_util::CreateCopyResultCallback(
    224           &error, &resource_list));
    225   base::RunLoop().RunUntilIdle();
    226 
    227   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    228   ASSERT_TRUE(resource_list);
    229 }
    230 
    231 TEST_F(JobSchedulerTest, GetResourceListInDirectory) {
    232   ConnectToWifi();
    233 
    234   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    235   scoped_ptr<google_apis::ResourceList> resource_list;
    236 
    237   scheduler_->GetResourceListInDirectory(
    238       fake_drive_service_->GetRootResourceId(),
    239       google_apis::test_util::CreateCopyResultCallback(
    240           &error, &resource_list));
    241   base::RunLoop().RunUntilIdle();
    242 
    243   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    244   ASSERT_TRUE(resource_list);
    245 }
    246 
    247 TEST_F(JobSchedulerTest, Search) {
    248   ConnectToWifi();
    249 
    250   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    251   scoped_ptr<google_apis::ResourceList> resource_list;
    252 
    253   scheduler_->Search(
    254       "File",  // search query
    255       google_apis::test_util::CreateCopyResultCallback(
    256           &error, &resource_list));
    257   base::RunLoop().RunUntilIdle();
    258 
    259   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    260   ASSERT_TRUE(resource_list);
    261 }
    262 
    263 TEST_F(JobSchedulerTest, GetChangeList) {
    264   ConnectToWifi();
    265 
    266   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    267 
    268   // Create a new directory.
    269   // The loaded (initial) changestamp is 654321. Thus, by this operation,
    270   // it should become 654322.
    271   {
    272     scoped_ptr<google_apis::ResourceEntry> resource_entry;
    273     fake_drive_service_->AddNewDirectory(
    274         fake_drive_service_->GetRootResourceId(),
    275         "new directory",
    276         google_apis::test_util::CreateCopyResultCallback(
    277             &error, &resource_entry));
    278     base::RunLoop().RunUntilIdle();
    279     ASSERT_EQ(google_apis::HTTP_CREATED, error);
    280   }
    281 
    282   error = google_apis::GDATA_OTHER_ERROR;
    283   scoped_ptr<google_apis::ResourceList> resource_list;
    284   scheduler_->GetChangeList(
    285       654321 + 1,  // start_changestamp
    286       google_apis::test_util::CreateCopyResultCallback(
    287           &error, &resource_list));
    288   base::RunLoop().RunUntilIdle();
    289 
    290   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    291   ASSERT_TRUE(resource_list);
    292 }
    293 
    294 TEST_F(JobSchedulerTest, GetRemainingChangeList) {
    295   ConnectToWifi();
    296   fake_drive_service_->set_default_max_results(2);
    297 
    298   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    299   scoped_ptr<google_apis::ResourceList> resource_list;
    300 
    301   scheduler_->GetAllResourceList(
    302       google_apis::test_util::CreateCopyResultCallback(
    303           &error, &resource_list));
    304   base::RunLoop().RunUntilIdle();
    305 
    306   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    307   ASSERT_TRUE(resource_list);
    308 
    309   const google_apis::Link* next_link =
    310       resource_list->GetLinkByType(google_apis::Link::LINK_NEXT);
    311   ASSERT_TRUE(next_link);
    312   // Keep the next url before releasing the |resource_list|.
    313   GURL next_url(next_link->href());
    314 
    315   error = google_apis::GDATA_OTHER_ERROR;
    316   resource_list.reset();
    317 
    318   scheduler_->GetRemainingChangeList(
    319       next_url,
    320       google_apis::test_util::CreateCopyResultCallback(
    321           &error, &resource_list));
    322   base::RunLoop().RunUntilIdle();
    323 
    324   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    325   ASSERT_TRUE(resource_list);
    326 }
    327 
    328 TEST_F(JobSchedulerTest, GetRemainingFileList) {
    329   ConnectToWifi();
    330   fake_drive_service_->set_default_max_results(2);
    331 
    332   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    333   scoped_ptr<google_apis::ResourceList> resource_list;
    334 
    335   scheduler_->GetResourceListInDirectory(
    336       fake_drive_service_->GetRootResourceId(),
    337       google_apis::test_util::CreateCopyResultCallback(
    338           &error, &resource_list));
    339   base::RunLoop().RunUntilIdle();
    340 
    341   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    342   ASSERT_TRUE(resource_list);
    343 
    344   const google_apis::Link* next_link =
    345       resource_list->GetLinkByType(google_apis::Link::LINK_NEXT);
    346   ASSERT_TRUE(next_link);
    347   // Keep the next url before releasing the |resource_list|.
    348   GURL next_url(next_link->href());
    349 
    350   error = google_apis::GDATA_OTHER_ERROR;
    351   resource_list.reset();
    352 
    353   scheduler_->GetRemainingFileList(
    354       next_url,
    355       google_apis::test_util::CreateCopyResultCallback(
    356           &error, &resource_list));
    357   base::RunLoop().RunUntilIdle();
    358 
    359   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    360   ASSERT_TRUE(resource_list);
    361 }
    362 
    363 TEST_F(JobSchedulerTest, GetResourceEntry) {
    364   ConnectToWifi();
    365 
    366   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    367   scoped_ptr<google_apis::ResourceEntry> entry;
    368 
    369   scheduler_->GetResourceEntry(
    370       "file:2_file_resource_id",  // resource ID
    371       ClientContext(USER_INITIATED),
    372       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
    373   base::RunLoop().RunUntilIdle();
    374 
    375   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    376   ASSERT_TRUE(entry);
    377 }
    378 
    379 TEST_F(JobSchedulerTest, GetShareUrl) {
    380   ConnectToWifi();
    381 
    382   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    383   GURL share_url;
    384 
    385   scheduler_->GetShareUrl(
    386       "file:2_file_resource_id",  // resource ID
    387       GURL("chrome-extension://test-id/"), // embed origin
    388       ClientContext(USER_INITIATED),
    389       google_apis::test_util::CreateCopyResultCallback(&error, &share_url));
    390   base::RunLoop().RunUntilIdle();
    391 
    392   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    393   ASSERT_FALSE(share_url.is_empty());
    394 }
    395 
    396 TEST_F(JobSchedulerTest, TrashResource) {
    397   ConnectToWifi();
    398 
    399   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    400 
    401   scheduler_->TrashResource(
    402       "file:2_file_resource_id",
    403       ClientContext(USER_INITIATED),
    404       google_apis::test_util::CreateCopyResultCallback(&error));
    405   base::RunLoop().RunUntilIdle();
    406 
    407   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    408 }
    409 
    410 TEST_F(JobSchedulerTest, CopyResource) {
    411   ConnectToWifi();
    412 
    413   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    414   scoped_ptr<google_apis::ResourceEntry> entry;
    415 
    416   scheduler_->CopyResource(
    417       "file:2_file_resource_id",  // resource ID
    418       "folder:1_folder_resource_id",  // parent resource ID
    419       "New Document",  // new title
    420       base::Time(),
    421       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
    422   base::RunLoop().RunUntilIdle();
    423 
    424   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    425   ASSERT_TRUE(entry);
    426 }
    427 
    428 TEST_F(JobSchedulerTest, UpdateResource) {
    429   ConnectToWifi();
    430 
    431   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    432   scoped_ptr<google_apis::ResourceEntry> entry;
    433 
    434   scheduler_->UpdateResource(
    435       "file:2_file_resource_id",  // resource ID
    436       "folder:1_folder_resource_id",  // parent resource ID
    437       "New Document",  // new title
    438       base::Time(),
    439       base::Time(),
    440       ClientContext(USER_INITIATED),
    441       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
    442   base::RunLoop().RunUntilIdle();
    443 
    444   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    445   ASSERT_TRUE(entry);
    446 }
    447 
    448 TEST_F(JobSchedulerTest, RenameResource) {
    449   ConnectToWifi();
    450 
    451   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    452 
    453   scheduler_->RenameResource(
    454       "file:2_file_resource_id",
    455       "New Title",
    456       google_apis::test_util::CreateCopyResultCallback(&error));
    457   base::RunLoop().RunUntilIdle();
    458 
    459   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    460 }
    461 
    462 TEST_F(JobSchedulerTest, AddResourceToDirectory) {
    463   ConnectToWifi();
    464 
    465   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    466 
    467   scheduler_->AddResourceToDirectory(
    468       "folder:1_folder_resource_id",
    469       "file:2_file_resource_id",
    470       google_apis::test_util::CreateCopyResultCallback(&error));
    471   base::RunLoop().RunUntilIdle();
    472 
    473   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
    474 }
    475 
    476 TEST_F(JobSchedulerTest, RemoveResourceFromDirectory) {
    477   ConnectToWifi();
    478 
    479   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    480 
    481   scheduler_->RemoveResourceFromDirectory(
    482       "folder:1_folder_resource_id",
    483       "file:subdirectory_file_1_id",  // resource ID
    484       ClientContext(USER_INITIATED),
    485       google_apis::test_util::CreateCopyResultCallback(&error));
    486   base::RunLoop().RunUntilIdle();
    487 
    488   ASSERT_EQ(google_apis::HTTP_NO_CONTENT, error);
    489 }
    490 
    491 TEST_F(JobSchedulerTest, AddNewDirectory) {
    492   ConnectToWifi();
    493 
    494   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    495   scoped_ptr<google_apis::ResourceEntry> entry;
    496 
    497   scheduler_->AddNewDirectory(
    498       fake_drive_service_->GetRootResourceId(),  // Root directory.
    499       "New Directory",
    500       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
    501   base::RunLoop().RunUntilIdle();
    502 
    503   ASSERT_EQ(google_apis::HTTP_CREATED, error);
    504   ASSERT_TRUE(entry);
    505 }
    506 
    507 TEST_F(JobSchedulerTest, PriorityHandling) {
    508   const base::FilePath kDummyFilePath(FILE_PATH_LITERAL("dummy"));
    509 
    510   // Saturate the metadata job queue with uninteresting jobs to prevent
    511   // following jobs from starting.
    512   google_apis::GDataErrorCode error_dontcare = google_apis::GDATA_OTHER_ERROR;
    513   scoped_ptr<google_apis::ResourceEntry> entry_dontcare;
    514   for (int i = 0; i < GetMetadataQueueMaxJobCount(); ++i) {
    515     scheduler_->CreateFile(
    516         fake_drive_service_->GetRootResourceId(),
    517         kDummyFilePath,
    518         base::StringPrintf("uninteresting file %d", i),
    519         "text/plain",
    520         ClientContext(USER_INITIATED),
    521         google_apis::test_util::CreateCopyResultCallback(&error_dontcare,
    522                                                          &entry_dontcare));
    523   }
    524 
    525   // Start jobs with different priorities.
    526   std::string title_1("new file 1");
    527   std::string title_2("new file 2");
    528   std::string title_3("new file 3");
    529   std::string title_4("new file 4");
    530   std::vector<std::string> titles;
    531 
    532   scheduler_->CreateFile(
    533       fake_drive_service_->GetRootResourceId(),
    534       kDummyFilePath,
    535       title_1,
    536       "text/plain",
    537       ClientContext(USER_INITIATED),
    538       base::Bind(&CopyTitleFromGetResourceEntryCallback, &titles));
    539   scheduler_->CreateFile(
    540       fake_drive_service_->GetRootResourceId(),
    541       kDummyFilePath,
    542       title_2,
    543       "text/plain",
    544       ClientContext(BACKGROUND),
    545       base::Bind(&CopyTitleFromGetResourceEntryCallback, &titles));
    546   scheduler_->CreateFile(
    547       fake_drive_service_->GetRootResourceId(),
    548       kDummyFilePath,
    549       title_3,
    550       "text/plain",
    551       ClientContext(BACKGROUND),
    552       base::Bind(&CopyTitleFromGetResourceEntryCallback, &titles));
    553   scheduler_->CreateFile(
    554       fake_drive_service_->GetRootResourceId(),
    555       kDummyFilePath,
    556       title_4,
    557       "text/plain",
    558       ClientContext(USER_INITIATED),
    559       base::Bind(&CopyTitleFromGetResourceEntryCallback, &titles));
    560 
    561   base::RunLoop().RunUntilIdle();
    562 
    563   ASSERT_EQ(4ul, titles.size());
    564   EXPECT_EQ(title_1, titles[0]);
    565   EXPECT_EQ(title_4, titles[1]);
    566   EXPECT_EQ(title_2, titles[2]);
    567   EXPECT_EQ(title_3, titles[3]);
    568 }
    569 
    570 TEST_F(JobSchedulerTest, NoConnectionUserInitiated) {
    571   ConnectToNone();
    572 
    573   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    574   scoped_ptr<google_apis::ResourceEntry> entry;
    575   scheduler_->CreateFile(
    576       fake_drive_service_->GetRootResourceId(),
    577       base::FilePath(FILE_PATH_LITERAL("dummy")),
    578       "title",
    579       "text/plain",
    580       ClientContext(USER_INITIATED),
    581       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
    582   base::RunLoop().RunUntilIdle();
    583 
    584   EXPECT_EQ(google_apis::GDATA_NO_CONNECTION, error);
    585 }
    586 
    587 TEST_F(JobSchedulerTest, NoConnectionBackground) {
    588   ConnectToNone();
    589 
    590   std::string resource_id("file:2_file_resource_id");
    591 
    592   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    593   scoped_ptr<google_apis::ResourceEntry> entry;
    594   scheduler_->CreateFile(
    595       fake_drive_service_->GetRootResourceId(),
    596       base::FilePath(FILE_PATH_LITERAL("dummy")),
    597       "title",
    598       "text/plain",
    599       ClientContext(BACKGROUND),
    600       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
    601   base::RunLoop().RunUntilIdle();
    602 
    603   EXPECT_FALSE(entry);
    604 
    605   // Reconnect to the net.
    606   ConnectToWifi();
    607 
    608   base::RunLoop().RunUntilIdle();
    609 
    610   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
    611   ASSERT_TRUE(entry);
    612   EXPECT_EQ("title", entry->title());
    613 }
    614 
    615 TEST_F(JobSchedulerTest, DownloadFileCellularDisabled) {
    616   ConnectToCellular();
    617 
    618   // Disable fetching over cellular network.
    619   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
    620 
    621   // Try to get a file in the background
    622   base::ScopedTempDir temp_dir;
    623   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    624 
    625   const base::FilePath kOutputFilePath =
    626       temp_dir.path().AppendASCII("whatever.txt");
    627   google_apis::GDataErrorCode download_error = google_apis::GDATA_OTHER_ERROR;
    628   base::FilePath output_file_path;
    629   scheduler_->DownloadFile(
    630       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
    631       kDummyDownloadFileSize,
    632       kOutputFilePath,
    633       "file:2_file_resource_id",
    634       ClientContext(BACKGROUND),
    635       google_apis::test_util::CreateCopyResultCallback(
    636           &download_error, &output_file_path),
    637       google_apis::GetContentCallback());
    638   // Metadata should still work
    639   google_apis::GDataErrorCode metadata_error = google_apis::GDATA_OTHER_ERROR;
    640   scoped_ptr<google_apis::AboutResource> about_resource;
    641 
    642   // Try to get the metadata
    643   scheduler_->GetAboutResource(
    644       google_apis::test_util::CreateCopyResultCallback(
    645           &metadata_error, &about_resource));
    646   base::RunLoop().RunUntilIdle();
    647 
    648   // Check the metadata
    649   ASSERT_EQ(google_apis::HTTP_SUCCESS, metadata_error);
    650   ASSERT_TRUE(about_resource);
    651 
    652   // Check the download
    653   EXPECT_EQ(google_apis::GDATA_OTHER_ERROR, download_error);
    654 
    655   // Switch to a Wifi connection
    656   ConnectToWifi();
    657 
    658   base::RunLoop().RunUntilIdle();
    659 
    660   // Check the download again
    661   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
    662   std::string content;
    663   EXPECT_EQ(output_file_path, kOutputFilePath);
    664   ASSERT_TRUE(base::ReadFileToString(output_file_path, &content));
    665   EXPECT_EQ("This is some test content.", content);
    666 }
    667 
    668 TEST_F(JobSchedulerTest, DownloadFileWimaxDisabled) {
    669   ConnectToWimax();
    670 
    671   // Disable fetching over cellular network.
    672   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
    673 
    674   // Try to get a file in the background
    675   base::ScopedTempDir temp_dir;
    676   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    677 
    678   const base::FilePath kOutputFilePath =
    679       temp_dir.path().AppendASCII("whatever.txt");
    680   google_apis::GDataErrorCode download_error = google_apis::GDATA_OTHER_ERROR;
    681   base::FilePath output_file_path;
    682   scheduler_->DownloadFile(
    683       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
    684       kDummyDownloadFileSize,
    685       kOutputFilePath,
    686       "file:2_file_resource_id",
    687       ClientContext(BACKGROUND),
    688       google_apis::test_util::CreateCopyResultCallback(
    689           &download_error, &output_file_path),
    690       google_apis::GetContentCallback());
    691   // Metadata should still work
    692   google_apis::GDataErrorCode metadata_error = google_apis::GDATA_OTHER_ERROR;
    693   scoped_ptr<google_apis::AboutResource> about_resource;
    694 
    695   // Try to get the metadata
    696   scheduler_->GetAboutResource(
    697       google_apis::test_util::CreateCopyResultCallback(
    698           &metadata_error, &about_resource));
    699   base::RunLoop().RunUntilIdle();
    700 
    701   // Check the metadata
    702   ASSERT_EQ(google_apis::HTTP_SUCCESS, metadata_error);
    703   ASSERT_TRUE(about_resource);
    704 
    705   // Check the download
    706   EXPECT_EQ(google_apis::GDATA_OTHER_ERROR, download_error);
    707 
    708   // Switch to a Wifi connection
    709   ConnectToWifi();
    710 
    711   base::RunLoop().RunUntilIdle();
    712 
    713   // Check the download again
    714   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
    715   std::string content;
    716   EXPECT_EQ(output_file_path, kOutputFilePath);
    717   ASSERT_TRUE(base::ReadFileToString(output_file_path, &content));
    718   EXPECT_EQ("This is some test content.", content);
    719 }
    720 
    721 TEST_F(JobSchedulerTest, DownloadFileCellularEnabled) {
    722   ConnectToCellular();
    723 
    724   // Enable fetching over cellular network.
    725   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, false);
    726 
    727   // Try to get a file in the background
    728   base::ScopedTempDir temp_dir;
    729   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    730 
    731   const base::FilePath kOutputFilePath =
    732       temp_dir.path().AppendASCII("whatever.txt");
    733   google_apis::GDataErrorCode download_error = google_apis::GDATA_OTHER_ERROR;
    734   base::FilePath output_file_path;
    735   scheduler_->DownloadFile(
    736       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
    737       kDummyDownloadFileSize,
    738       kOutputFilePath,
    739       "file:2_file_resource_id",
    740       ClientContext(BACKGROUND),
    741       google_apis::test_util::CreateCopyResultCallback(
    742           &download_error, &output_file_path),
    743       google_apis::GetContentCallback());
    744   // Metadata should still work
    745   google_apis::GDataErrorCode metadata_error = google_apis::GDATA_OTHER_ERROR;
    746   scoped_ptr<google_apis::AboutResource> about_resource;
    747 
    748   // Try to get the metadata
    749   scheduler_->GetAboutResource(
    750       google_apis::test_util::CreateCopyResultCallback(
    751           &metadata_error, &about_resource));
    752   base::RunLoop().RunUntilIdle();
    753 
    754   // Check the metadata
    755   ASSERT_EQ(google_apis::HTTP_SUCCESS, metadata_error);
    756   ASSERT_TRUE(about_resource);
    757 
    758   // Check the download
    759   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
    760   std::string content;
    761   EXPECT_EQ(output_file_path, kOutputFilePath);
    762   ASSERT_TRUE(base::ReadFileToString(output_file_path, &content));
    763   EXPECT_EQ("This is some test content.", content);
    764 }
    765 
    766 TEST_F(JobSchedulerTest, DownloadFileWimaxEnabled) {
    767   ConnectToWimax();
    768 
    769   // Enable fetching over cellular network.
    770   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, false);
    771 
    772   // Try to get a file in the background
    773   base::ScopedTempDir temp_dir;
    774   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    775 
    776   const base::FilePath kOutputFilePath =
    777       temp_dir.path().AppendASCII("whatever.txt");
    778   google_apis::GDataErrorCode download_error = google_apis::GDATA_OTHER_ERROR;
    779   base::FilePath output_file_path;
    780   scheduler_->DownloadFile(
    781       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
    782       kDummyDownloadFileSize,
    783       kOutputFilePath,
    784       "file:2_file_resource_id",
    785       ClientContext(BACKGROUND),
    786       google_apis::test_util::CreateCopyResultCallback(
    787           &download_error, &output_file_path),
    788       google_apis::GetContentCallback());
    789   // Metadata should still work
    790   google_apis::GDataErrorCode metadata_error = google_apis::GDATA_OTHER_ERROR;
    791   scoped_ptr<google_apis::AboutResource> about_resource;
    792 
    793   // Try to get the metadata
    794   scheduler_->GetAboutResource(
    795       google_apis::test_util::CreateCopyResultCallback(
    796           &metadata_error, &about_resource));
    797   base::RunLoop().RunUntilIdle();
    798 
    799   // Check the metadata
    800   ASSERT_EQ(google_apis::HTTP_SUCCESS, metadata_error);
    801   ASSERT_TRUE(about_resource);
    802 
    803   // Check the download
    804   EXPECT_EQ(google_apis::HTTP_SUCCESS, download_error);
    805   std::string content;
    806   EXPECT_EQ(output_file_path, kOutputFilePath);
    807   ASSERT_TRUE(base::ReadFileToString(output_file_path, &content));
    808   EXPECT_EQ("This is some test content.", content);
    809 }
    810 
    811 TEST_F(JobSchedulerTest, JobInfo) {
    812   JobListLogger logger;
    813   scheduler_->AddObserver(&logger);
    814 
    815   // Disable background upload/download.
    816   ConnectToWimax();
    817   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
    818 
    819   base::ScopedTempDir temp_dir;
    820   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    821 
    822   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    823   scoped_ptr<google_apis::ResourceEntry> entry;
    824   scoped_ptr<google_apis::AboutResource> about_resource;
    825   base::FilePath path;
    826 
    827   std::set<JobType> expected_types;
    828 
    829   // Add many jobs.
    830   expected_types.insert(TYPE_ADD_NEW_DIRECTORY);
    831   scheduler_->AddNewDirectory(
    832       fake_drive_service_->GetRootResourceId(),
    833       "New Directory",
    834       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
    835   expected_types.insert(TYPE_GET_ABOUT_RESOURCE);
    836   scheduler_->GetAboutResource(
    837       google_apis::test_util::CreateCopyResultCallback(
    838           &error, &about_resource));
    839   expected_types.insert(TYPE_RENAME_RESOURCE);
    840   scheduler_->RenameResource(
    841       "file:2_file_resource_id",
    842       "New Title",
    843       google_apis::test_util::CreateCopyResultCallback(&error));
    844   expected_types.insert(TYPE_DOWNLOAD_FILE);
    845   scheduler_->DownloadFile(
    846       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
    847       kDummyDownloadFileSize,
    848       temp_dir.path().AppendASCII("whatever.txt"),
    849       "file:2_file_resource_id",
    850       ClientContext(BACKGROUND),
    851       google_apis::test_util::CreateCopyResultCallback(&error, &path),
    852       google_apis::GetContentCallback());
    853 
    854   // The number of jobs queued so far.
    855   EXPECT_EQ(4U, scheduler_->GetJobInfoList().size());
    856   EXPECT_TRUE(logger.Has(JobListLogger::ADDED, TYPE_ADD_NEW_DIRECTORY));
    857   EXPECT_TRUE(logger.Has(JobListLogger::ADDED, TYPE_GET_ABOUT_RESOURCE));
    858   EXPECT_TRUE(logger.Has(JobListLogger::ADDED, TYPE_RENAME_RESOURCE));
    859   EXPECT_TRUE(logger.Has(JobListLogger::ADDED, TYPE_DOWNLOAD_FILE));
    860   EXPECT_FALSE(logger.Has(JobListLogger::DONE, TYPE_ADD_NEW_DIRECTORY));
    861   EXPECT_FALSE(logger.Has(JobListLogger::DONE, TYPE_GET_ABOUT_RESOURCE));
    862   EXPECT_FALSE(logger.Has(JobListLogger::DONE, TYPE_RENAME_RESOURCE));
    863   EXPECT_FALSE(logger.Has(JobListLogger::DONE, TYPE_DOWNLOAD_FILE));
    864 
    865   // Add more jobs.
    866   expected_types.insert(TYPE_ADD_RESOURCE_TO_DIRECTORY);
    867   scheduler_->AddResourceToDirectory(
    868       "folder:1_folder_resource_id",
    869       "file:2_file_resource_id",
    870       google_apis::test_util::CreateCopyResultCallback(&error));
    871   expected_types.insert(TYPE_COPY_RESOURCE);
    872   scheduler_->CopyResource(
    873       "document:5_document_resource_id",
    874       fake_drive_service_->GetRootResourceId(),
    875       "New Document",
    876       base::Time(),  // last_modified
    877       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
    878 
    879   // 6 jobs in total were queued.
    880   std::vector<JobInfo> jobs = scheduler_->GetJobInfoList();
    881   EXPECT_EQ(6U, jobs.size());
    882   std::set<JobType> actual_types;
    883   std::set<JobID> job_ids;
    884   for (size_t i = 0; i < jobs.size(); ++i) {
    885     actual_types.insert(jobs[i].job_type);
    886     job_ids.insert(jobs[i].job_id);
    887   }
    888   EXPECT_EQ(expected_types, actual_types);
    889   EXPECT_EQ(6U, job_ids.size()) << "All job IDs must be unique";
    890   EXPECT_TRUE(logger.Has(JobListLogger::ADDED, TYPE_ADD_RESOURCE_TO_DIRECTORY));
    891   EXPECT_TRUE(logger.Has(JobListLogger::ADDED, TYPE_COPY_RESOURCE));
    892   EXPECT_FALSE(logger.Has(JobListLogger::DONE, TYPE_ADD_RESOURCE_TO_DIRECTORY));
    893   EXPECT_FALSE(logger.Has(JobListLogger::DONE, TYPE_COPY_RESOURCE));
    894 
    895   // Run the jobs.
    896   base::RunLoop().RunUntilIdle();
    897 
    898   // All jobs except the BACKGROUND job should have started running (UPDATED)
    899   // and then finished (DONE).
    900   jobs = scheduler_->GetJobInfoList();
    901   ASSERT_EQ(1U, jobs.size());
    902   EXPECT_EQ(TYPE_DOWNLOAD_FILE, jobs[0].job_type);
    903 
    904   EXPECT_TRUE(logger.Has(JobListLogger::UPDATED, TYPE_ADD_NEW_DIRECTORY));
    905   EXPECT_TRUE(logger.Has(JobListLogger::UPDATED, TYPE_GET_ABOUT_RESOURCE));
    906   EXPECT_TRUE(logger.Has(JobListLogger::UPDATED, TYPE_RENAME_RESOURCE));
    907   EXPECT_TRUE(logger.Has(JobListLogger::UPDATED,
    908                          TYPE_ADD_RESOURCE_TO_DIRECTORY));
    909   EXPECT_TRUE(logger.Has(JobListLogger::UPDATED, TYPE_COPY_RESOURCE));
    910   EXPECT_FALSE(logger.Has(JobListLogger::UPDATED, TYPE_DOWNLOAD_FILE));
    911 
    912   EXPECT_TRUE(logger.Has(JobListLogger::DONE, TYPE_ADD_NEW_DIRECTORY));
    913   EXPECT_TRUE(logger.Has(JobListLogger::DONE, TYPE_GET_ABOUT_RESOURCE));
    914   EXPECT_TRUE(logger.Has(JobListLogger::DONE, TYPE_RENAME_RESOURCE));
    915   EXPECT_TRUE(logger.Has(JobListLogger::DONE, TYPE_ADD_RESOURCE_TO_DIRECTORY));
    916   EXPECT_TRUE(logger.Has(JobListLogger::DONE, TYPE_COPY_RESOURCE));
    917   EXPECT_FALSE(logger.Has(JobListLogger::DONE, TYPE_DOWNLOAD_FILE));
    918 
    919   // Run the background downloading job as well.
    920   ConnectToWifi();
    921   base::RunLoop().RunUntilIdle();
    922 
    923   // All jobs should have finished.
    924   EXPECT_EQ(0U, scheduler_->GetJobInfoList().size());
    925   EXPECT_TRUE(logger.Has(JobListLogger::UPDATED, TYPE_DOWNLOAD_FILE));
    926   EXPECT_TRUE(logger.Has(JobListLogger::DONE, TYPE_DOWNLOAD_FILE));
    927 }
    928 
    929 TEST_F(JobSchedulerTest, JobInfoProgress) {
    930   JobListLogger logger;
    931   scheduler_->AddObserver(&logger);
    932 
    933   ConnectToWifi();
    934 
    935   base::ScopedTempDir temp_dir;
    936   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    937 
    938   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
    939   base::FilePath path;
    940 
    941   // Download job.
    942   scheduler_->DownloadFile(
    943       base::FilePath::FromUTF8Unsafe("drive/whatever.txt"),  // virtual path
    944       kDummyDownloadFileSize,
    945       temp_dir.path().AppendASCII("whatever.txt"),
    946       "file:2_file_resource_id",
    947       ClientContext(BACKGROUND),
    948       google_apis::test_util::CreateCopyResultCallback(&error, &path),
    949       google_apis::GetContentCallback());
    950   base::RunLoop().RunUntilIdle();
    951 
    952   std::vector<int64> download_progress;
    953   logger.GetProgressInfo(TYPE_DOWNLOAD_FILE, &download_progress);
    954   ASSERT_TRUE(!download_progress.empty());
    955   EXPECT_TRUE(base::STLIsSorted(download_progress));
    956   EXPECT_GE(download_progress.front(), 0);
    957   EXPECT_LE(download_progress.back(), 26);
    958 
    959   // Upload job.
    960   path = temp_dir.path().AppendASCII("new_file.txt");
    961   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(path, "Hello"));
    962   google_apis::GDataErrorCode upload_error =
    963       google_apis::GDATA_OTHER_ERROR;
    964   scoped_ptr<google_apis::ResourceEntry> entry;
    965 
    966   scheduler_->UploadNewFile(
    967       fake_drive_service_->GetRootResourceId(),
    968       base::FilePath::FromUTF8Unsafe("drive/new_file.txt"),
    969       path,
    970       "dummy title",
    971       "plain/plain",
    972       ClientContext(BACKGROUND),
    973       google_apis::test_util::CreateCopyResultCallback(&upload_error, &entry));
    974   base::RunLoop().RunUntilIdle();
    975 
    976   std::vector<int64> upload_progress;
    977   logger.GetProgressInfo(TYPE_UPLOAD_NEW_FILE, &upload_progress);
    978   ASSERT_TRUE(!upload_progress.empty());
    979   EXPECT_TRUE(base::STLIsSorted(upload_progress));
    980   EXPECT_GE(upload_progress.front(), 0);
    981   EXPECT_LE(upload_progress.back(), 13);
    982 }
    983 
    984 TEST_F(JobSchedulerTest, CancelPendingJob) {
    985   base::ScopedTempDir temp_dir;
    986   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    987   base::FilePath upload_path = temp_dir.path().AppendASCII("new_file.txt");
    988   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(upload_path, "Hello"));
    989 
    990   // To create a pending job for testing, set the mode to cellular connection
    991   // and issue BACKGROUND jobs.
    992   ConnectToCellular();
    993   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
    994 
    995   // Start the first job and record its job ID.
    996   google_apis::GDataErrorCode error1 = google_apis::GDATA_OTHER_ERROR;
    997   scoped_ptr<google_apis::ResourceEntry> entry;
    998   scheduler_->UploadNewFile(
    999       fake_drive_service_->GetRootResourceId(),
   1000       base::FilePath::FromUTF8Unsafe("dummy/path"),
   1001       upload_path,
   1002       "dummy title 1",
   1003       "text/plain",
   1004       ClientContext(BACKGROUND),
   1005       google_apis::test_util::CreateCopyResultCallback(&error1, &entry));
   1006 
   1007   const std::vector<JobInfo>& jobs = scheduler_->GetJobInfoList();
   1008   ASSERT_EQ(1u, jobs.size());
   1009   ASSERT_EQ(STATE_NONE, jobs[0].state);  // Not started yet.
   1010   JobID first_job_id = jobs[0].job_id;
   1011 
   1012   // Start the second job.
   1013   google_apis::GDataErrorCode error2 = google_apis::GDATA_OTHER_ERROR;
   1014   scheduler_->UploadNewFile(
   1015       fake_drive_service_->GetRootResourceId(),
   1016       base::FilePath::FromUTF8Unsafe("dummy/path"),
   1017       upload_path,
   1018       "dummy title 2",
   1019       "text/plain",
   1020       ClientContext(BACKGROUND),
   1021       google_apis::test_util::CreateCopyResultCallback(&error2, &entry));
   1022 
   1023   // Cancel the first one.
   1024   scheduler_->CancelJob(first_job_id);
   1025 
   1026   // Only the first job should be cancelled.
   1027   ConnectToWifi();
   1028   base::RunLoop().RunUntilIdle();
   1029   EXPECT_EQ(google_apis::GDATA_CANCELLED, error1);
   1030   EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
   1031   EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
   1032 }
   1033 
   1034 TEST_F(JobSchedulerTest, CancelRunningJob) {
   1035   ConnectToWifi();
   1036 
   1037   base::ScopedTempDir temp_dir;
   1038   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   1039   base::FilePath upload_path = temp_dir.path().AppendASCII("new_file.txt");
   1040   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(upload_path, "Hello"));
   1041 
   1042   // Run as a cancelable task.
   1043   fake_drive_service_->set_upload_new_file_cancelable(true);
   1044   google_apis::GDataErrorCode error1 = google_apis::GDATA_OTHER_ERROR;
   1045   scoped_ptr<google_apis::ResourceEntry> entry;
   1046   scheduler_->UploadNewFile(
   1047       fake_drive_service_->GetRootResourceId(),
   1048       base::FilePath::FromUTF8Unsafe("dummy/path"),
   1049       upload_path,
   1050       "dummy title 1",
   1051       "text/plain",
   1052       ClientContext(USER_INITIATED),
   1053       google_apis::test_util::CreateCopyResultCallback(&error1, &entry));
   1054 
   1055   const std::vector<JobInfo>& jobs = scheduler_->GetJobInfoList();
   1056   ASSERT_EQ(1u, jobs.size());
   1057   ASSERT_EQ(STATE_RUNNING, jobs[0].state);  // It's running.
   1058   JobID first_job_id = jobs[0].job_id;
   1059 
   1060   // Start the second job normally.
   1061   fake_drive_service_->set_upload_new_file_cancelable(false);
   1062   google_apis::GDataErrorCode error2 = google_apis::GDATA_OTHER_ERROR;
   1063   scheduler_->UploadNewFile(
   1064       fake_drive_service_->GetRootResourceId(),
   1065       base::FilePath::FromUTF8Unsafe("dummy/path"),
   1066       upload_path,
   1067       "dummy title 2",
   1068       "text/plain",
   1069       ClientContext(USER_INITIATED),
   1070       google_apis::test_util::CreateCopyResultCallback(&error2, &entry));
   1071 
   1072   // Cancel the first one.
   1073   scheduler_->CancelJob(first_job_id);
   1074 
   1075   // Only the first job should be cancelled.
   1076   base::RunLoop().RunUntilIdle();
   1077   EXPECT_EQ(google_apis::GDATA_CANCELLED, error1);
   1078   EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
   1079   EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
   1080 }
   1081 
   1082 }  // namespace drive
   1083