drive: Stop returning ResourceEntry from 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"
 #include "base/files/scoped_temp_dir.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/drive/event_logger.h"
 #include "chrome/browser/drive/fake_drive_service.h"
 #include "chrome/browser/drive/test_util.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/drive/drive_api_parser.h"
-#include "google_apis/drive/gdata_wapi_parser.h"
 #include "google_apis/drive/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 
 namespace {
 
 // Dummy value passed for the |expected_file_size| parameter of DownloadFile().
 const int64 kDummyDownloadFileSize = 0;
 
-void CopyTitleFromGetResourceEntryCallback(
+void CopyTitleFromFileResourceCallback(
     std::vector<std::string>* title_list_out,
     google_apis::GDataErrorCode error_in,
-    scoped_ptr<google_apis::ResourceEntry> resource_entry_in) {
-  title_list_out->push_back(resource_entry_in->title());
+    scoped_ptr<google_apis::FileResource> entry_in) {
+  title_list_out->push_back(entry_in->title());
 }
 
 class JobListLogger : public JobListObserver {
  public:
   enum EventType {
     ADDED,
     UPDATED,
     DONE,
   };
 
@@ skipping 297 matching lines @@
 
   scheduler_->GetRemainingFileList(
       next_url,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
 }
 
-TEST_F(JobSchedulerTest, GetResourceEntry) {
+TEST_F(JobSchedulerTest, GetFileResource) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
+  scoped_ptr<google_apis::FileResource> entry;
 
-  scheduler_->GetResourceEntry(
+  scheduler_->GetFileResource(
       "file:2_file_resource_id",  // resource ID
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
 }
 
 TEST_F(JobSchedulerTest, GetShareUrl) {
@@ skipping 24 matching lines @@
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
 TEST_F(JobSchedulerTest, CopyResource) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
+  scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->CopyResource(
       "file:2_file_resource_id",  // resource ID
       "folder:1_folder_resource_id",  // parent resource ID
       "New Document",  // new title
       base::Time(),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
 }
 
 TEST_F(JobSchedulerTest, UpdateResource) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
+  scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->UpdateResource(
       "file:2_file_resource_id",  // resource ID
       "folder:1_folder_resource_id",  // parent resource ID
       "New Document",  // new title
       base::Time(),
       base::Time(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
@@ skipping 42 matching lines @@
       google_apis::test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_NO_CONTENT, error);
 }
 
 TEST_F(JobSchedulerTest, AddNewDirectory) {
   ConnectToWifi();
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
+  scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),  // Root directory.
       "New Directory",
       DriveServiceInterface::AddNewDirectoryOptions(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(google_apis::HTTP_CREATED, error);
   ASSERT_TRUE(entry);
 }
 
 TEST_F(JobSchedulerTest, PriorityHandling) {
   // Saturate the metadata job queue with uninteresting jobs to prevent
   // following jobs from starting.
   google_apis::GDataErrorCode error_dontcare = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry_dontcare;
+  scoped_ptr<google_apis::FileResource> entry_dontcare;
   for (int i = 0; i < GetMetadataQueueMaxJobCount(); ++i) {
     std::string resource_id("file:2_file_resource_id");
-    scheduler_->GetResourceEntry(
+    scheduler_->GetFileResource(
         resource_id,
         ClientContext(USER_INITIATED),
         google_apis::test_util::CreateCopyResultCallback(&error_dontcare,
                                                          &entry_dontcare));
   }
 
   // Start jobs with different priorities.
   std::string title_1("new file 1");
   std::string title_2("new file 2");
   std::string title_3("new file 3");
   std::string title_4("new file 4");
   std::vector<std::string> titles;
 
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),
       title_1,
       DriveServiceInterface::AddNewDirectoryOptions(),
       ClientContext(USER_INITIATED),
-      base::Bind(&CopyTitleFromGetResourceEntryCallback, &titles));
+      base::Bind(&CopyTitleFromFileResourceCallback, &titles));
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),
       title_2,
       DriveServiceInterface::AddNewDirectoryOptions(),
       ClientContext(BACKGROUND),
-      base::Bind(&CopyTitleFromGetResourceEntryCallback, &titles));
+      base::Bind(&CopyTitleFromFileResourceCallback, &titles));
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),
       title_3,
       DriveServiceInterface::AddNewDirectoryOptions(),
       ClientContext(BACKGROUND),
-      base::Bind(&CopyTitleFromGetResourceEntryCallback, &titles));
+      base::Bind(&CopyTitleFromFileResourceCallback, &titles));
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),
       title_4,
       DriveServiceInterface::AddNewDirectoryOptions(),
       ClientContext(USER_INITIATED),
-      base::Bind(&CopyTitleFromGetResourceEntryCallback, &titles));
+      base::Bind(&CopyTitleFromFileResourceCallback, &titles));
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(4ul, titles.size());
   EXPECT_EQ(title_1, titles[0]);
   EXPECT_EQ(title_4, titles[1]);
   EXPECT_EQ(title_2, titles[2]);
   EXPECT_EQ(title_3, titles[3]);
 }
 
 TEST_F(JobSchedulerTest, NoConnectionUserInitiated) {
   ConnectToNone();
 
   std::string resource_id("file:2_file_resource_id");
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
-  scheduler_->GetResourceEntry(
+  scoped_ptr<google_apis::FileResource> entry;
+  scheduler_->GetFileResource(
       resource_id,
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(google_apis::GDATA_NO_CONNECTION, error);
 }
 
 TEST_F(JobSchedulerTest, NoConnectionBackground) {
   ConnectToNone();
 
   std::string resource_id("file:2_file_resource_id");
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
-  scheduler_->GetResourceEntry(
+  scoped_ptr<google_apis::FileResource> entry;
+  scheduler_->GetFileResource(
       resource_id,
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(entry);
 
   // Reconnect to the net.
   ConnectToWifi();
 
@@ skipping 204 matching lines @@
   scheduler_->AddObserver(&logger);
 
   // Disable background upload/download.
   ConnectToWimax();
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
+  scoped_ptr<google_apis::FileResource> entry;
   scoped_ptr<google_apis::AboutResource> about_resource;
   base::FilePath path;
 
   std::set<JobType> expected_types;
 
   // Add many jobs.
   expected_types.insert(TYPE_ADD_NEW_DIRECTORY);
   scheduler_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),
       "New Directory",
@@ skipping 122 matching lines @@
   ASSERT_TRUE(!download_progress.empty());
   EXPECT_TRUE(base::STLIsSorted(download_progress));
   EXPECT_GE(download_progress.front(), 0);
   EXPECT_LE(download_progress.back(), 26);
 
   // Upload job.
   path = temp_dir.path().AppendASCII("new_file.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(path, "Hello"));
   google_apis::GDataErrorCode upload_error =
       google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
+  scoped_ptr<google_apis::FileResource> entry;
 
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
       base::FilePath::FromUTF8Unsafe("drive/new_file.txt"),
       path,
       "dummy title",
       "plain/plain",
       DriveUploader::UploadNewFileOptions(),
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&upload_error, &entry));
@@ skipping 13 matching lines @@
   base::FilePath upload_path = temp_dir.path().AppendASCII("new_file.txt");
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(upload_path, "Hello"));
 
   // To create a pending job for testing, set the mode to cellular connection
   // and issue BACKGROUND jobs.
   ConnectToCellular();
   pref_service_->SetBoolean(prefs::kDisableDriveOverCellular, true);
 
   // Start the first job and record its job ID.
   google_apis::GDataErrorCode error1 = google_apis::GDATA_OTHER_ERROR;
-  scoped_ptr<google_apis::ResourceEntry> entry;
+  scoped_ptr<google_apis::FileResource> entry;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
       base::FilePath::FromUTF8Unsafe("dummy/path"),
       upload_path,
       "dummy title 1",
       "text/plain",
       DriveUploader::UploadNewFileOptions(),
       ClientContext(BACKGROUND),
       google_apis::test_util::CreateCopyResultCallback(&error1, &entry));
 
@@ skipping 29 matching lines @@
   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;
+  scoped_ptr<google_apis::FileResource> entry;
   scheduler_->UploadNewFile(
       fake_drive_service_->GetRootResourceId(),
       base::FilePath::FromUTF8Unsafe("dummy/path"),
       upload_path,
       "dummy title 1",
       "text/plain",
       DriveUploader::UploadNewFileOptions(),
       ClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error1, &entry));
 
@@ skipping 19 matching lines @@
   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