drive: Remove WAPI legacy from DriveServiceInterface and DriveUploader

BUG=231125
TEST=git cl try

Review URL: https://codereview.chromium.org/319603006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@275038 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 81 insertions, 125 deletions

diff --git a/chrome/browser/drive/drive_api_service.cc b/chrome/browser/drive/drive_api_service.cc
index 8a0fd9c..11755c2 100644
--- a/chrome/browser/drive/drive_api_service.cc
+++ b/chrome/browser/drive/drive_api_service.cc
@@ -51,8 +51,6 @@ using google_apis::InitiateUploadCallback;
 using google_apis::Link;
 using google_apis::ProgressCallback;
 using google_apis::RequestSender;
-using google_apis::ResourceEntry;
-using google_apis::UploadRangeCallback;
 using google_apis::UploadRangeResponse;
 using google_apis::drive::AboutGetRequest;
 using google_apis::drive::AppsListRequest;
@@ -73,6 +71,7 @@ using google_apis::drive::GetUploadStatusRequest;
 using google_apis::drive::InitiateUploadExistingFileRequest;
 using google_apis::drive::InitiateUploadNewFileRequest;
 using google_apis::drive::ResumeUploadRequest;
+using google_apis::drive::UploadRangeCallback;
 
 namespace drive {
 
@@ -123,34 +122,6 @@ const char kChangeListFields[] =
     "lastViewedByMeDate,shared),deleted,id,fileId,modificationDate),nextLink,"
     "largestChangeId";
 
-// Converts the FileResource value to ResourceEntry for upload range request,
-// and runs |callback| on the UI thread.
-void ConvertFileResourceToResourceEntryForUploadRangeAndRun(
-    const UploadRangeCallback& callback,
-    const UploadRangeResponse& response,
-    scoped_ptr<FileResource> value) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
-
-  if (!value) {
-    callback.Run(response, scoped_ptr<ResourceEntry>());
-    return;
-  }
-
-  // Converting to ResourceEntry is cheap enough to do on UI thread.
-  scoped_ptr<ResourceEntry> entry =
-      util::ConvertFileResourceToResourceEntry(*value);
-  if (!entry) {
-    callback.Run(UploadRangeResponse(GDATA_PARSE_ERROR,
-                                     response.start_position_received,
-                                     response.end_position_received),
-                 scoped_ptr<ResourceEntry>());
-    return;
-  }
-
-  callback.Run(response, entry.Pass());
-}
-
 void ExtractOpenUrlAndRun(const std::string& app_id,
                           const AuthorizeAppCallback& callback,
                           GDataErrorCode error,
@@ -659,8 +630,7 @@ CancelCallback DriveAPIService::ResumeUpload(
           content_length,
           content_type,
           local_file_path,
-          base::Bind(&ConvertFileResourceToResourceEntryForUploadRangeAndRun,
-                     callback),
+          callback,
           progress_callback));
 }
 
@@ -675,8 +645,7 @@ CancelCallback DriveAPIService::GetUploadStatus(
       sender_.get(),
       upload_url,
       content_length,
-      base::Bind(&ConvertFileResourceToResourceEntryForUploadRangeAndRun,
-                 callback)));
+      callback));
 }
 
 CancelCallback DriveAPIService::AuthorizeApp(
diff --git a/chrome/browser/drive/drive_api_service.h b/chrome/browser/drive/drive_api_service.h
index 4d3dc0c..a6ca822 100644
--- a/chrome/browser/drive/drive_api_service.h
+++ b/chrome/browser/drive/drive_api_service.h
@@ -169,12 +169,12 @@ class DriveAPIService : public DriveServiceInterface,
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
-      const google_apis::UploadRangeCallback& callback,
+      const google_apis::drive::UploadRangeCallback& callback,
       const google_apis::ProgressCallback& progress_callback) OVERRIDE;
   virtual google_apis::CancelCallback GetUploadStatus(
       const GURL& upload_url,
       int64 content_length,
-      const google_apis::UploadRangeCallback& callback) OVERRIDE;
+      const google_apis::drive::UploadRangeCallback& callback) OVERRIDE;
   virtual google_apis::CancelCallback AuthorizeApp(
       const std::string& resource_id,
       const std::string& app_id,
diff --git a/chrome/browser/drive/drive_service_interface.h b/chrome/browser/drive/drive_service_interface.h
index 7f78bb9..8478700 100644
--- a/chrome/browser/drive/drive_service_interface.h
+++ b/chrome/browser/drive/drive_service_interface.h
@@ -389,7 +389,7 @@ class DriveServiceInterface {
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
-      const google_apis::UploadRangeCallback& callback,
+      const google_apis::drive::UploadRangeCallback& callback,
       const google_apis::ProgressCallback& progress_callback) = 0;
 
   // Gets the current status of the uploading to |upload_url| from the server.
@@ -399,7 +399,7 @@ class DriveServiceInterface {
   virtual google_apis::CancelCallback GetUploadStatus(
       const GURL& upload_url,
       int64 content_length,
-      const google_apis::UploadRangeCallback& callback) = 0;
+      const google_apis::drive::UploadRangeCallback& callback) = 0;
 
   // Authorizes a Drive app with the id |app_id| to open the given file.
   // Upon completion, invokes |callback| with the link to open the file with
diff --git a/chrome/browser/drive/drive_uploader.cc b/chrome/browser/drive/drive_uploader.cc
index 6ef9545..5ea3375 100644
--- a/chrome/browser/drive/drive_uploader.cc
+++ b/chrome/browser/drive/drive_uploader.cc
@@ -14,10 +14,11 @@
 #include "chrome/browser/drive/drive_service_interface.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/power_save_blocker.h"
-#include "google_apis/drive/gdata_wapi_parser.h"
+#include "google_apis/drive/drive_api_parser.h"
 
 using content::BrowserThread;
 using google_apis::CancelCallback;
+using google_apis::FileResource;
 using google_apis::GDATA_CANCELLED;
 using google_apis::GDataErrorCode;
 using google_apis::GDATA_NO_SPACE;
@@ -29,7 +30,6 @@ using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
 using google_apis::ProgressCallback;
-using google_apis::ResourceEntry;
 using google_apis::UploadRangeResponse;
 
 namespace drive {
@@ -355,7 +355,7 @@ void DriveUploader::UploadNextChunk(
 void DriveUploader::OnUploadRangeResponseReceived(
     scoped_ptr<UploadFileInfo> upload_file_info,
     const UploadRangeResponse& response,
-    scoped_ptr<ResourceEntry> entry) {
+    scoped_ptr<FileResource> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (response.code == HTTP_CREATED || response.code == HTTP_SUCCESS) {
@@ -428,7 +428,7 @@ void DriveUploader::UploadFailed(scoped_ptr<UploadFileInfo> upload_file_info,
   }
 
   upload_file_info->completion_callback.Run(
-      error, upload_file_info->upload_location, scoped_ptr<ResourceEntry>());
+      error, upload_file_info->upload_location, scoped_ptr<FileResource>());
 }
 
 }  // namespace drive
diff --git a/chrome/browser/drive/drive_uploader.h b/chrome/browser/drive/drive_uploader.h
index 1fd8191..cbb74b9 100644
--- a/chrome/browser/drive/drive_uploader.h
+++ b/chrome/browser/drive/drive_uploader.h
@@ -13,7 +13,6 @@
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/drive/drive_service_interface.h"
 #include "google_apis/drive/gdata_errorcode.h"
-#include "google_apis/drive/gdata_wapi_parser.h"
 
 class GURL;
 
@@ -36,7 +35,7 @@ class DriveServiceInterface;
 typedef base::Callback<void(
     google_apis::GDataErrorCode error,
     const GURL& upload_location,
-    scoped_ptr<google_apis::ResourceEntry> resource_entry)>
+    scoped_ptr<google_apis::FileResource> resource_entry)>
     UploadCompletionCallback;
 
 class DriveUploaderInterface {
@@ -186,7 +185,7 @@ class DriveUploader : public DriveUploaderInterface {
   void OnUploadRangeResponseReceived(
       scoped_ptr<UploadFileInfo> upload_file_info,
       const google_apis::UploadRangeResponse& response,
-      scoped_ptr<google_apis::ResourceEntry> entry);
+      scoped_ptr<google_apis::FileResource> entry);
   void OnUploadProgress(const google_apis::ProgressCallback& callback,
                         int64 start_position,
                         int64 total_size,
diff --git a/chrome/browser/drive/drive_uploader_unittest.cc b/chrome/browser/drive/drive_uploader_unittest.cc
index ccbbc97..1f1b36f 100644
--- a/chrome/browser/drive/drive_uploader_unittest.cc
+++ b/chrome/browser/drive/drive_uploader_unittest.cc
@@ -15,10 +15,12 @@
 #include "base/values.h"
 #include "chrome/browser/drive/dummy_drive_service.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using google_apis::CancelCallback;
+using google_apis::FileResource;
 using google_apis::GDataErrorCode;
 using google_apis::GDATA_NO_CONNECTION;
 using google_apis::GDATA_OTHER_ERROR;
@@ -30,16 +32,15 @@ using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
 using google_apis::InitiateUploadCallback;
 using google_apis::ProgressCallback;
-using google_apis::ResourceEntry;
-using google_apis::UploadRangeCallback;
 using google_apis::UploadRangeResponse;
+using google_apis::drive::UploadRangeCallback;
 namespace test_util = google_apis::test_util;
 
 namespace drive {
 
 namespace {
 
-const char kTestDummyId[] = "file:dummy_id";
+const char kTestDummyMd5[] = "dummy_md5";
 const char kTestDocumentTitle[] = "Hello world";
 const char kTestInitiateUploadParentResourceId[] = "parent_resource_id";
 const char kTestInitiateUploadResourceId[] = "resource_id";
@@ -179,16 +180,15 @@ class MockDriveServiceWithUploadExpectation : public DummyDriveService {
                                const UploadRangeCallback& callback) {
     // Callback with response.
     UploadRangeResponse response;
-    scoped_ptr<ResourceEntry> entry;
+    scoped_ptr<FileResource> entry;
     if (received_bytes_ == expected_content_length_) {
       GDataErrorCode response_code =
           upload_location == GURL(kTestUploadNewFileURL) ?
           HTTP_CREATED : HTTP_SUCCESS;
       response = UploadRangeResponse(response_code, -1, -1);
 
-      base::DictionaryValue dict;
-      dict.Set("id.$t", new base::StringValue(kTestDummyId));
-      entry = ResourceEntry::CreateFrom(dict);
+      entry.reset(new FileResource);
+      entry->set_md5_checksum(kTestDummyMd5);
     } else {
       response = UploadRangeResponse(
           HTTP_RESUME_INCOMPLETE, 0, received_bytes_);
@@ -284,7 +284,7 @@ class MockDriveServiceNoConnectionAtResume : public DummyDriveService {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(GDATA_NO_CONNECTION, -1, -1),
-                   base::Passed(scoped_ptr<ResourceEntry>())));
+                   base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 };
@@ -299,7 +299,7 @@ class MockDriveServiceNoConnectionAtGetUploadStatus : public DummyDriveService {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(GDATA_NO_CONNECTION, -1, -1),
-                   base::Passed(scoped_ptr<ResourceEntry>())));
+                   base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 };
@@ -325,7 +325,7 @@ TEST_F(DriveUploaderTest, UploadExisting0KB) {
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
@@ -337,7 +337,7 @@ TEST_F(DriveUploaderTest, UploadExisting0KB) {
       kTestMimeType,
       DriveUploader::UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(
-          &error, &upload_location, &resource_entry),
+          &error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
@@ -346,8 +346,8 @@ TEST_F(DriveUploaderTest, UploadExisting0KB) {
   EXPECT_EQ(0, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
-  ASSERT_TRUE(resource_entry);
-  EXPECT_EQ(kTestDummyId, resource_entry->id());
+  ASSERT_TRUE(entry);
+  EXPECT_EQ(kTestDummyMd5, entry->md5_checksum());
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(0, 0), upload_progress_values[0]);
 }
@@ -360,7 +360,7 @@ TEST_F(DriveUploaderTest, UploadExisting512KB) {
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
@@ -372,7 +372,7 @@ TEST_F(DriveUploaderTest, UploadExisting512KB) {
       kTestMimeType,
       DriveUploader::UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(
-          &error, &upload_location, &resource_entry),
+          &error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
@@ -382,8 +382,8 @@ TEST_F(DriveUploaderTest, UploadExisting512KB) {
   EXPECT_EQ(512 * 1024, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
-  ASSERT_TRUE(resource_entry);
-  EXPECT_EQ(kTestDummyId, resource_entry->id());
+  ASSERT_TRUE(entry);
+  EXPECT_EQ(kTestDummyMd5, entry->md5_checksum());
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(512 * 1024, 512 * 1024),
             upload_progress_values[0]);
@@ -397,7 +397,7 @@ TEST_F(DriveUploaderTest, InitiateUploadFail) {
 
   GDataErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtInitiate mock_service;
   DriveUploader uploader(&mock_service,
@@ -407,13 +407,13 @@ TEST_F(DriveUploaderTest, InitiateUploadFail) {
                               kTestMimeType,
                               DriveUploader::UploadExistingFileOptions(),
                               test_util::CreateCopyResultCallback(
-                                  &error, &upload_location, &resource_entry),
+                                  &error, &upload_location, &entry),
                               google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
-  EXPECT_FALSE(resource_entry);
+  EXPECT_FALSE(entry);
 }
 
 TEST_F(DriveUploaderTest, InitiateUploadNoConflict) {
@@ -424,7 +424,7 @@ TEST_F(DriveUploaderTest, InitiateUploadNoConflict) {
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
@@ -436,7 +436,7 @@ TEST_F(DriveUploaderTest, InitiateUploadNoConflict) {
                               kTestMimeType,
                               options,
                               test_util::CreateCopyResultCallback(
-                                  &error, &upload_location, &resource_entry),
+                                  &error, &upload_location, &entry),
                               google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
@@ -453,7 +453,7 @@ TEST_F(DriveUploaderTest, InitiateUploadConflict) {
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
@@ -465,7 +465,7 @@ TEST_F(DriveUploaderTest, InitiateUploadConflict) {
                               kTestMimeType,
                               options,
                               test_util::CreateCopyResultCallback(
-                                  &error, &upload_location, &resource_entry),
+                                  &error, &upload_location, &entry),
                               google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
@@ -481,7 +481,7 @@ TEST_F(DriveUploaderTest, ResumeUploadFail) {
 
   GDataErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtResume mock_service;
   DriveUploader uploader(&mock_service,
@@ -491,7 +491,7 @@ TEST_F(DriveUploaderTest, ResumeUploadFail) {
                               kTestMimeType,
                               DriveUploader::UploadExistingFileOptions(),
                               test_util::CreateCopyResultCallback(
-                                  &error, &upload_location, &resource_entry),
+                                  &error, &upload_location, &entry),
                               google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
@@ -507,7 +507,7 @@ TEST_F(DriveUploaderTest, GetUploadStatusFail) {
 
   GDataErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtGetUploadStatus mock_service;
   DriveUploader uploader(&mock_service,
@@ -516,7 +516,7 @@ TEST_F(DriveUploaderTest, GetUploadStatusFail) {
                             local_path,
                             kTestMimeType,
                             test_util::CreateCopyResultCallback(
-                                &error, &upload_location, &resource_entry),
+                                &error, &upload_location, &entry),
                             google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
@@ -527,7 +527,7 @@ TEST_F(DriveUploaderTest, GetUploadStatusFail) {
 TEST_F(DriveUploaderTest, NonExistingSourceFile) {
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   DriveUploader uploader(NULL,  // NULL, the service won't be used.
                          base::MessageLoopProxy::current().get());
@@ -537,7 +537,7 @@ TEST_F(DriveUploaderTest, NonExistingSourceFile) {
       kTestMimeType,
       DriveUploader::UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(
-          &error, &upload_location, &resource_entry),
+          &error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
@@ -554,7 +554,7 @@ TEST_F(DriveUploaderTest, ResumeUpload) {
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
-  scoped_ptr<ResourceEntry> resource_entry;
+  scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
@@ -569,7 +569,7 @@ TEST_F(DriveUploaderTest, ResumeUpload) {
       local_path,
       kTestMimeType,
       test_util::CreateCopyResultCallback(
-          &error, &upload_location, &resource_entry),
+          &error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
@@ -578,8 +578,8 @@ TEST_F(DriveUploaderTest, ResumeUpload) {
   EXPECT_EQ(1024 * 1024, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
-  ASSERT_TRUE(resource_entry);
-  EXPECT_EQ(kTestDummyId, resource_entry->id());
+  ASSERT_TRUE(entry);
+  EXPECT_EQ(kTestDummyMd5, entry->md5_checksum());
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(1024 * 1024, 1024 * 1024),
             upload_progress_values[0]);
diff --git a/chrome/browser/drive/dummy_drive_service.cc b/chrome/browser/drive/dummy_drive_service.cc
index d3d89d0..e08b849 100644
--- a/chrome/browser/drive/dummy_drive_service.cc
+++ b/chrome/browser/drive/dummy_drive_service.cc
@@ -21,7 +21,7 @@ using google_apis::GetContentCallback;
 using google_apis::GetShareUrlCallback;
 using google_apis::InitiateUploadCallback;
 using google_apis::ProgressCallback;
-using google_apis::UploadRangeCallback;
+using google_apis::drive::UploadRangeCallback;
 
 namespace drive {
 
diff --git a/chrome/browser/drive/dummy_drive_service.h b/chrome/browser/drive/dummy_drive_service.h
index 520a761..b175b06 100644
--- a/chrome/browser/drive/dummy_drive_service.h
+++ b/chrome/browser/drive/dummy_drive_service.h
@@ -125,12 +125,12 @@ class DummyDriveService : public DriveServiceInterface {
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
-      const google_apis::UploadRangeCallback& callback,
+      const google_apis::drive::UploadRangeCallback& callback,
       const google_apis::ProgressCallback& progress_callback) OVERRIDE;
   virtual google_apis::CancelCallback GetUploadStatus(
       const GURL& upload_url,
       int64 content_length,
-      const google_apis::UploadRangeCallback& callback) OVERRIDE;
+      const google_apis::drive::UploadRangeCallback& callback) OVERRIDE;
   virtual google_apis::CancelCallback AuthorizeApp(
       const std::string& resource_id,
       const std::string& app_id,
diff --git a/chrome/browser/drive/fake_drive_service.cc b/chrome/browser/drive/fake_drive_service.cc
index f36f149..37cf960 100644
--- a/chrome/browser/drive/fake_drive_service.cc
+++ b/chrome/browser/drive/fake_drive_service.cc
@@ -20,7 +20,6 @@
 #include "chrome/browser/drive/drive_api_util.h"
 #include "content/public/browser/browser_thread.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 "net/base/escape.h"
 #include "net/base/url_util.h"
@@ -47,7 +46,6 @@ using google_apis::GDATA_NO_CONNECTION;
 using google_apis::GDATA_OTHER_ERROR;
 using google_apis::GDataErrorCode;
 using google_apis::GetContentCallback;
-using google_apis::GetResourceEntryCallback;
 using google_apis::GetShareUrlCallback;
 using google_apis::HTTP_BAD_REQUEST;
 using google_apis::HTTP_CREATED;
@@ -57,18 +55,16 @@ using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
 using google_apis::InitiateUploadCallback;
-using google_apis::Link;
 using google_apis::ParentReference;
 using google_apis::ProgressCallback;
-using google_apis::ResourceEntry;
-using google_apis::UploadRangeCallback;
 using google_apis::UploadRangeResponse;
+using google_apis::drive::UploadRangeCallback;
 namespace test_util = google_apis::test_util;
 
 namespace drive {
 namespace {
 
-// Returns true if a resource entry matches with the search query.
+// Returns true if the entry matches with the search query.
 // Supports queries consist of following format.
 // - Phrases quoted by double/single quotes
 // - AND search for multiple words/phrases segmented by space
@@ -108,7 +104,7 @@ void ScheduleUploadRangeCallback(const UploadRangeCallback& callback,
                                  int64 start_position,
                                  int64 end_position,
                                  GDataErrorCode error,
-                                 scoped_ptr<ResourceEntry> entry) {
+                                 scoped_ptr<FileResource> entry) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
@@ -466,7 +462,6 @@ CancelCallback FakeDriveService::GetShareUrl(
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    scoped_ptr<ResourceEntry> null;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
@@ -1011,17 +1006,17 @@ CancelCallback FakeDriveService::ResumeUpload(
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  GetResourceEntryCallback completion_callback
+  FileResourceCallback completion_callback
       = base::Bind(&ScheduleUploadRangeCallback,
                    callback, start_position, end_position);
 
   if (offline_) {
-    completion_callback.Run(GDATA_NO_CONNECTION, scoped_ptr<ResourceEntry>());
+    completion_callback.Run(GDATA_NO_CONNECTION, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   if (!upload_sessions_.count(upload_url)) {
-    completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<ResourceEntry>());
+    completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
@@ -1030,7 +1025,7 @@ CancelCallback FakeDriveService::ResumeUpload(
   // Chunks are required to be sent in such a ways that they fill from the start
   // of the not-yet-uploaded part with no gaps nor overlaps.
   if (session->uploaded_size != start_position) {
-    completion_callback.Run(HTTP_BAD_REQUEST, scoped_ptr<ResourceEntry>());
+    completion_callback.Run(HTTP_BAD_REQUEST, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
@@ -1050,15 +1045,14 @@ CancelCallback FakeDriveService::ResumeUpload(
 
   if (content_length != end_position) {
     session->uploaded_size = end_position;
-    completion_callback.Run(HTTP_RESUME_INCOMPLETE,
-                            scoped_ptr<ResourceEntry>());
+    completion_callback.Run(HTTP_RESUME_INCOMPLETE, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   std::string content_data;
   if (!base::ReadFileToString(local_file_path, &content_data)) {
     session->uploaded_size = end_position;
-    completion_callback.Run(GDATA_FILE_ERROR, scoped_ptr<ResourceEntry>());
+    completion_callback.Run(GDATA_FILE_ERROR, scoped_ptr<FileResource>());
     return CancelCallback();
   }
   session->uploaded_size = end_position;
@@ -1075,26 +1069,25 @@ CancelCallback FakeDriveService::ResumeUpload(
         session->title,
         false);  // shared_with_me
     if (!new_entry) {
-      completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<ResourceEntry>());
+      completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
       return CancelCallback();
     }
 
-    completion_callback.Run(
-        HTTP_CREATED,
-        util::ConvertChangeResourceToResourceEntry(new_entry->change_resource));
+    completion_callback.Run(HTTP_CREATED, make_scoped_ptr(
+        new FileResource(*new_entry->change_resource.file())));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(session->resource_id);
   if (!entry) {
-    completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<ResourceEntry>());
+    completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   if (file->etag().empty() || session->etag != file->etag()) {
-    completion_callback.Run(HTTP_PRECONDITION, scoped_ptr<ResourceEntry>());
+    completion_callback.Run(HTTP_PRECONDITION, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
@@ -1104,8 +1097,8 @@ CancelCallback FakeDriveService::ResumeUpload(
   AddNewChangestamp(change);
   UpdateETag(file);
 
-  completion_callback.Run(HTTP_SUCCESS,
-                          util::ConvertChangeResourceToResourceEntry(*change));
+  completion_callback.Run(HTTP_SUCCESS, make_scoped_ptr(
+      new FileResource(*file)));
   return CancelCallback();
 }
 
diff --git a/chrome/browser/drive/fake_drive_service.h b/chrome/browser/drive/fake_drive_service.h
index 165ff1c..f429846 100644
--- a/chrome/browser/drive/fake_drive_service.h
+++ b/chrome/browser/drive/fake_drive_service.h
@@ -211,12 +211,12 @@ class FakeDriveService : public DriveServiceInterface {
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
-      const google_apis::UploadRangeCallback& callback,
+      const google_apis::drive::UploadRangeCallback& callback,
       const google_apis::ProgressCallback& progress_callback) OVERRIDE;
   virtual google_apis::CancelCallback GetUploadStatus(
       const GURL& upload_url,
       int64 content_length,
-      const google_apis::UploadRangeCallback& callback) OVERRIDE;
+      const google_apis::drive::UploadRangeCallback& callback) OVERRIDE;
   virtual google_apis::CancelCallback AuthorizeApp(
       const std::string& resource_id,
       const std::string& app_id,
diff --git a/chrome/browser/drive/fake_drive_service_unittest.cc b/chrome/browser/drive/fake_drive_service_unittest.cc
index 931d44d..a3f78923 100644
--- a/chrome/browser/drive/fake_drive_service_unittest.cc
+++ b/chrome/browser/drive/fake_drive_service_unittest.cc
@@ -17,8 +17,6 @@
 #include "chrome/browser/drive/test_util.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/gdata_wapi_requests.h"
 #include "google_apis/drive/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -38,9 +36,7 @@ using google_apis::HTTP_NO_CONTENT;
 using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
-using google_apis::Link;
 using google_apis::ProgressCallback;
-using google_apis::ResourceEntry;
 using google_apis::UploadRangeResponse;
 
 namespace drive {
@@ -1787,7 +1783,7 @@ TEST_F(FakeDriveServiceTest, ResumeUpload_Offline) {
   fake_service_.set_offline(true);
 
   UploadRangeResponse response;
-  scoped_ptr<ResourceEntry> entry;
+  scoped_ptr<FileResource> entry;
   fake_service_.ResumeUpload(
       upload_location,
       0, 13, 15, "test/foo",
@@ -1817,7 +1813,7 @@ TEST_F(FakeDriveServiceTest, ResumeUpload_NotFound) {
   ASSERT_EQ(HTTP_SUCCESS, error);
 
   UploadRangeResponse response;
-  scoped_ptr<ResourceEntry> entry;
+  scoped_ptr<FileResource> entry;
   fake_service_.ResumeUpload(
       GURL("https://foo.com/"),
       0, 13, 15, "test/foo",
@@ -1859,19 +1855,19 @@ TEST_F(FakeDriveServiceTest, ResumeUpload_ExistingFile) {
   ASSERT_EQ(HTTP_SUCCESS, error);
 
   UploadRangeResponse response;
-  scoped_ptr<ResourceEntry> resource_entry;
+  entry.reset();
   std::vector<test_util::ProgressInfo> upload_progress_values;
   fake_service_.ResumeUpload(
       upload_location,
       0, contents.size() / 2, contents.size(), "text/plain",
       local_file_path,
-      test_util::CreateCopyResultCallback(&response, &resource_entry),
+      test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
-  EXPECT_FALSE(resource_entry.get());
+  EXPECT_FALSE(entry.get());
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
@@ -1883,22 +1879,21 @@ TEST_F(FakeDriveServiceTest, ResumeUpload_ExistingFile) {
       upload_location,
       contents.size() / 2, contents.size(), contents.size(), "text/plain",
       local_file_path,
-      test_util::CreateCopyResultCallback(&response, &resource_entry),
+      test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, response.code);
-  EXPECT_TRUE(resource_entry.get());
-  EXPECT_EQ(static_cast<int64>(contents.size()),
-            resource_entry->file_size());
-  EXPECT_TRUE(Exists(resource_entry->resource_id()));
+  EXPECT_TRUE(entry.get());
+  EXPECT_EQ(static_cast<int64>(contents.size()), entry->file_size());
+  EXPECT_TRUE(Exists(entry->file_id()));
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
   EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2),
             upload_progress_values.back().first);
-  EXPECT_EQ(base::MD5String(contents), resource_entry->file_md5());
+  EXPECT_EQ(base::MD5String(contents), entry->md5_checksum());
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) {
@@ -1928,7 +1923,7 @@ TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) {
             upload_location);
 
   UploadRangeResponse response;
-  scoped_ptr<ResourceEntry> entry;
+  scoped_ptr<FileResource> entry;
   std::vector<test_util::ProgressInfo> upload_progress_values;
   fake_service_.ResumeUpload(
       upload_location,
@@ -1960,13 +1955,13 @@ TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) {
   EXPECT_EQ(HTTP_CREATED, response.code);
   EXPECT_TRUE(entry.get());
   EXPECT_EQ(static_cast<int64>(contents.size()), entry->file_size());
-  EXPECT_TRUE(Exists(entry->resource_id()));
+  EXPECT_TRUE(Exists(entry->file_id()));
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
   EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2),
             upload_progress_values.back().first);
-  EXPECT_EQ(base::MD5String(contents), entry->file_md5());
+  EXPECT_EQ(base::MD5String(contents), entry->md5_checksum());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectory) {