google_apis: DriveServiceInterface::GetResourceEntry() returns ResourceEntry

chrome/browser/sync_file_system/drive_file_sync_client_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/sync_file_system/drive_file_sync_client.h"
 
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "chrome/browser/google_apis/drive_uploader.h"
@@ skipping 149 matching lines @@
 };
 
 // Invokes |arg0| as a GetDataCallback.
 ACTION_P2(InvokeGetDataCallback0, error, result) {
   scoped_ptr<base::Value> value(result.Pass());
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(arg0, error, base::Passed(&value)));
 }
 
-// Invokes |arg1| as a GetDataCallback.
-ACTION_P2(InvokeGetDataCallback1, error, result) {
-  scoped_ptr<base::Value> value(result.Pass());
+// Invokes |arg1| as a GetResourceEntryCallback.
+ACTION_P2(InvokeGetResourceEntryCallback1, error, result) {
+  scoped_ptr<google_apis::ResourceEntry> entry(result.Pass());
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(arg1, error, base::Passed(&value)));
+      base::Bind(arg1, error, base::Passed(&entry)));
 }
 
 // Invokes |arg2| as a GetDataCallback.
 ACTION_P2(InvokeGetDataCallback2, error, result) {
   scoped_ptr<base::Value> value(result.Pass());
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(arg2, error, base::Passed(&value)));
 }
 
@@ skipping 198 matching lines @@
 TEST_F(DriveFileSyncClientTest, CreateOriginDirectory) {
   const std::string kParentResourceId("folder:sync_root_resource_id");
   const GURL kOrigin("chrome-extension://example");
 
   scoped_ptr<base::Value> not_found_result_value(
       google_apis::test_util::LoadJSONFile(
           "sync_file_system/origin_directory_not_found.json").Pass());
   scoped_ptr<google_apis::ResourceList> not_found_result =
       google_apis::ResourceList::ExtractAndParse(*not_found_result_value);
 
-  scoped_ptr<base::Value> got_parent_result(
+  scoped_ptr<base::Value> got_parent_result_value(
       google_apis::test_util::LoadJSONFile(
           "sync_file_system/origin_directory_get_parent.json").Pass());
+  scoped_ptr<google_apis::ResourceEntry> got_parent_result
+      = google_apis::ResourceEntry::ExtractAndParse(*got_parent_result_value);
   scoped_ptr<base::Value> created_result(google_apis::test_util::LoadJSONFile(
       "sync_file_system/origin_directory_created.json").Pass());
 
   testing::InSequence sequence;
 
   // Expected to call GetResourceList from GetDriveDirectoryForOrigin.
   EXPECT_CALL(*mock_drive_service(),
               GetResourceList(GURL(),             // feed_url
                               0,                  // start_changestamp
                               FormatOriginQuery(kOrigin),
                               false,              // shared_with_me
                               kParentResourceId,  // directory_resource_id
                               _))
       .WillOnce(InvokeGetResourceListCallback5(
           google_apis::HTTP_SUCCESS,
           base::Passed(&not_found_result)));
 
   // Expected to call GetResourceEntry from GetDriveDirectoryForOrigin.
   EXPECT_CALL(*mock_drive_service(),
               GetResourceEntry(kParentResourceId, _))
-      .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
-                                       base::Passed(&got_parent_result)));
+      .WillOnce(InvokeGetResourceEntryCallback1(
+          google_apis::HTTP_SUCCESS,
+          base::Passed(&got_parent_result)));
 
   std::string dir_title(DriveFileSyncClient::OriginToDirectoryTitle(kOrigin));
   // Expected to call AddNewDirectory from GetDriveDirectoryForOrigin.
   EXPECT_CALL(*mock_drive_service(),
               AddNewDirectory(GURL("https://sync_root_content_url"),
                               FilePath().AppendASCII(dir_title).value(),
                               _))
       .WillOnce(InvokeGetDataCallback2(google_apis::HTTP_CREATED,
                                        base::Passed(&created_result)));
 
@@ skipping 173 matching lines @@
   EXPECT_FALSE(document_feed->entries().empty());
 }
 
 TEST_F(DriveFileSyncClientTest, DownloadFile) {
   const std::string kResourceId = "file:resource_id";
   const std::string kLocalFileMD5 = "123456";
   const FilePath kLocalFilePath(FPL("/tmp/dir/file"));
 
   scoped_ptr<base::Value> file_entry_data(
       google_apis::test_util::LoadJSONFile("gdata/file_entry.json").Pass());
-  scoped_ptr<ResourceEntry> entry(
+  scoped_ptr<ResourceEntry> file_entry(
+      ResourceEntry::ExtractAndParse(*file_entry_data));
+  // We need another copy as |file_entry| will be passed to
+  // InvokeGetResourceEntryCallback1.
+  scoped_ptr<ResourceEntry> file_entry_copy(
       ResourceEntry::ExtractAndParse(*file_entry_data));
 
   testing::InSequence sequence;
 
   // Expected to call GetResourceEntry from DriveFileSyncClient::UploadNewFile.
   EXPECT_CALL(*mock_drive_service(),
               GetResourceEntry(kResourceId, _))
-      .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
-                                       base::Passed(&file_entry_data)))
+      .WillOnce(InvokeGetResourceEntryCallback1(
+          google_apis::HTTP_SUCCESS,
+          base::Passed(&file_entry)))
       .RetiresOnSaturation();
 
   // Expected to call DriveUploaderInterface::DownloadFile from
   // DidGetResourceEntryForDownloadFile.
   EXPECT_CALL(*mock_drive_service(),
               DownloadFile(_,  // drive_path
                            kLocalFilePath,
-                           entry->content_url(),
+                           file_entry_copy->content_url(),
                            _, _))
       .WillOnce(InvokeDownloadActionCallback3(google_apis::HTTP_SUCCESS,
                                               kLocalFilePath))
       .RetiresOnSaturation();
 
   bool done = false;
   std::string file_md5;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   sync_client()->DownloadFile(kResourceId,
                               kLocalFileMD5,
                               kLocalFilePath,
                               base::Bind(&DidDownloadFile,
                                          &done, &file_md5, &error));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
-  EXPECT_EQ(entry->file_md5(), file_md5);
+  EXPECT_EQ(file_entry_copy->file_md5(), file_md5);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
 TEST_F(DriveFileSyncClientTest, DownloadFileInNotModified) {
   const std::string kResourceId = "file:resource_id";
   const FilePath kLocalFilePath(FPL("/tmp/dir/file"));
 
   scoped_ptr<base::Value> file_entry_data(
       google_apis::test_util::LoadJSONFile("gdata/file_entry.json").Pass());
-  scoped_ptr<ResourceEntry> entry(
+  scoped_ptr<ResourceEntry> file_entry(
+      ResourceEntry::ExtractAndParse(*file_entry_data));
+  // We need another copy as |file_entry| will be passed to
+  // InvokeGetResourceEntryCallback1.
+  scoped_ptr<ResourceEntry> file_entry_copy(
       ResourceEntry::ExtractAndParse(*file_entry_data));
 
   // Since local file's hash value is equal to remote file's one, it is expected
   // to cancel download the file and to return NOT_MODIFIED status code.
-  const std::string kLocalFileMD5 = entry->file_md5();
+  const std::string kLocalFileMD5 = file_entry_copy->file_md5();
 
   testing::InSequence sequence;
 
   // Expected to call GetResourceEntry from DriveFileSyncClient::UploadNewFile.
   EXPECT_CALL(*mock_drive_service(),
               GetResourceEntry(kResourceId, _))
-      .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
-                                       base::Passed(&file_entry_data)))
+      .WillOnce(InvokeGetResourceEntryCallback1(
+          google_apis::HTTP_SUCCESS,
+          base::Passed(&file_entry)))
       .RetiresOnSaturation();
 
   bool done = false;
   std::string file_md5;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   sync_client()->DownloadFile(kResourceId,
                               kLocalFileMD5,
                               kLocalFilePath,
                               base::Bind(&DidDownloadFile,
                                          &done, &file_md5, &error));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
-  EXPECT_EQ(entry->file_md5(), file_md5);
+  EXPECT_EQ(file_entry_copy->file_md5(), file_md5);
   EXPECT_EQ(google_apis::HTTP_NOT_MODIFIED, error);
 }
 
 TEST_F(DriveFileSyncClientTest, UploadNewFile) {
   const std::string kDirectoryResourceId = "folder:directory_resource_id";
   const FilePath kLocalFilePath(FPL("/tmp/dir/file"));
   const std::string kTitle("testfile");
   int64 kFileSize = 1024;
 
   scoped_ptr<base::Value> dir_entry_data(google_apis::test_util::LoadJSONFile(
       "gdata/directory_entry.json").Pass());
   scoped_ptr<ResourceEntry> dir_entry(
       ResourceEntry::ExtractAndParse(*dir_entry_data));
   const GURL link_url =
       dir_entry->GetLinkByType(Link::LINK_RESUMABLE_CREATE_MEDIA)->href();
 
   testing::InSequence sequence;
 
   // Expected to call GetResourceEntry from DriveFileSyncClient::UploadNewFile.
   EXPECT_CALL(*mock_drive_service(),
               GetResourceEntry(kDirectoryResourceId, _))
-      .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
-                                       base::Passed(&dir_entry_data)))
+      .WillOnce(InvokeGetResourceEntryCallback1(
+          google_apis::HTTP_SUCCESS,
+          base::Passed(&dir_entry)))
       .RetiresOnSaturation();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   sync_client()->UploadNewFile(kDirectoryResourceId,
                                kLocalFilePath,
                                kTitle,
                                kFileSize,
                                base::Bind(&DidUploadFile,
                                           &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
 TEST_F(DriveFileSyncClientTest, UploadExistingFile) {
   const std::string kResourceId = "file:resource_id";
   const FilePath kLocalFilePath(FPL("/tmp/dir/file"));
   int64 kFileSize = 1024;
 
   scoped_ptr<base::Value> file_entry_data(
       google_apis::test_util::LoadJSONFile("gdata/file_entry.json").Pass());
-  scoped_ptr<ResourceEntry> entry(
+  scoped_ptr<ResourceEntry> file_entry(
       ResourceEntry::ExtractAndParse(*file_entry_data));
-  const std::string expected_remote_file_md5 = entry->file_md5();
+  const std::string expected_remote_file_md5 = file_entry->file_md5();
   const GURL link_url =
-      entry->GetLinkByType(Link::LINK_RESUMABLE_EDIT_MEDIA)->href();
+      file_entry->GetLinkByType(Link::LINK_RESUMABLE_EDIT_MEDIA)->href();
 
   testing::InSequence sequence;
 
   // Expected to call GetResourceEntry from
   // DriveFileSyncClient::UploadExistingFile.
   EXPECT_CALL(*mock_drive_service(),
               GetResourceEntry(kResourceId, _))
-      .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
-                                       base::Passed(&file_entry_data)))
+      .WillOnce(InvokeGetResourceEntryCallback1(
+          google_apis::HTTP_SUCCESS,
+          base::Passed(&file_entry)))
       .RetiresOnSaturation();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   sync_client()->UploadExistingFile(kResourceId,
                                     expected_remote_file_md5,
                                     kLocalFilePath,
                                     kFileSize,
                                     base::Bind(&DidUploadFile,
                                                &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
 TEST_F(DriveFileSyncClientTest, UploadExistingFileInConflict) {
   const std::string kResourceId = "file:resource_id";
   const FilePath kLocalFilePath(FPL("/tmp/dir/file"));
   int64 kFileSize = 1024;
 
   // Since remote file's hash value is different from the expected one, it is
   // expected to cancel upload the file and to return CONFLICT status code.
   const std::string kExpectedRemoteFileMD5 = "123456";
 
   scoped_ptr<base::Value> file_entry_data(
       google_apis::test_util::LoadJSONFile("gdata/file_entry.json").Pass());
-  scoped_ptr<ResourceEntry> entry(
+  scoped_ptr<ResourceEntry> file_entry(
       ResourceEntry::ExtractAndParse(*file_entry_data));
 
   testing::InSequence sequence;
 
   // Expected to call GetResourceEntry from
   // DriveFileSyncClient::UploadExistingFile.
   EXPECT_CALL(*mock_drive_service(),
               GetResourceEntry(kResourceId, _))
-      .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
-                                       base::Passed(&file_entry_data)))
+      .WillOnce(InvokeGetResourceEntryCallback1(
+          google_apis::HTTP_SUCCESS,
+          base::Passed(&file_entry)))
       .RetiresOnSaturation();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   sync_client()->UploadExistingFile(kResourceId,
                                     kExpectedRemoteFileMD5,
                                     kLocalFilePath,
                                     kFileSize,
                                     base::Bind(&DidUploadFile,
                                                &done, &error, &resource_id));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_CONFLICT, error);
 }
 
 TEST_F(DriveFileSyncClientTest, DeleteFile) {
   const std::string kResourceId = "file:resource_id";
 
   scoped_ptr<base::Value> file_entry_data(
       google_apis::test_util::LoadJSONFile("gdata/file_entry.json").Pass());
-  scoped_ptr<ResourceEntry> entry(
+  scoped_ptr<ResourceEntry> file_entry(
       ResourceEntry::ExtractAndParse(*file_entry_data));
-  const std::string kExpectedRemoteFileMD5 = entry->file_md5();
+  // We need another copy as |file_entry| will be passed to
+  // InvokeGetResourceEntryCallback1.
+  scoped_ptr<ResourceEntry> file_entry_copy(
+      ResourceEntry::ExtractAndParse(*file_entry_data));
+  const std::string kExpectedRemoteFileMD5 = file_entry_copy->file_md5();
 
   testing::InSequence sequence;
 
   // Expected to call GetResourceEntry from DriveFileSyncClient::DeleteFile.
   EXPECT_CALL(*mock_drive_service(), GetResourceEntry(kResourceId, _))
-      .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
-                                       base::Passed(&file_entry_data)))
+      .WillOnce(InvokeGetResourceEntryCallback1(
+          google_apis::HTTP_SUCCESS,
+          base::Passed(&file_entry)))
       .RetiresOnSaturation();
 
   // Expected to call DriveUploaderInterface::DeleteResource from
   // DidGetResourceEntryForDeleteFile.
   EXPECT_CALL(*mock_drive_service(),
-              DeleteResource(entry->GetLinkByType(Link::LINK_SELF)->href(), _))
+              DeleteResource(
+                  file_entry_copy->GetLinkByType(Link::LINK_SELF)->href(), _))
       .WillOnce(InvokeEntryActionCallback2(google_apis::HTTP_SUCCESS))
       .RetiresOnSaturation();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   sync_client()->DeleteFile(kResourceId,
                             kExpectedRemoteFileMD5,
                             base::Bind(&DidDeleteFile, &done, &error));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
 }
 
 TEST_F(DriveFileSyncClientTest, DeleteFileInConflict) {
   const std::string kResourceId = "file:resource_id";
 
   // Since remote file's hash value is different from the expected one, it is
   // expected to cancel delete the file and to return CONFLICT status code.
   const std::string kExpectedRemoteFileMD5 = "123456";
 
   scoped_ptr<base::Value> file_entry_data(
       google_apis::test_util::LoadJSONFile("gdata/file_entry.json").Pass());
-  scoped_ptr<ResourceEntry> entry(
+  scoped_ptr<ResourceEntry> file_entry(
       ResourceEntry::ExtractAndParse(*file_entry_data));
 
   testing::InSequence sequence;
 
   // Expected to call GetResourceEntry from DriveFileSyncClient::DeleteFile.
   EXPECT_CALL(*mock_drive_service(), GetResourceEntry(kResourceId, _))
-      .WillOnce(InvokeGetDataCallback1(google_apis::HTTP_SUCCESS,
-                                       base::Passed(&file_entry_data)))
+      .WillOnce(InvokeGetResourceEntryCallback1(
+          google_apis::HTTP_SUCCESS,
+          base::Passed(&file_entry)))
       .RetiresOnSaturation();
 
   bool done = false;
   GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   std::string resource_id;
   sync_client()->DeleteFile(kResourceId,
                             kExpectedRemoteFileMD5,
                             base::Bind(&DidDeleteFile, &done, &error));
   message_loop()->RunUntilIdle();
 
   EXPECT_TRUE(done);
   EXPECT_EQ(google_apis::HTTP_CONFLICT, error);
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace sync_file_system