chrome/browser/chromeos/drive/job_scheduler_unittest.cc

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