Add SetCapabilities to FakeDriveService

Create a SetCapabilities in FakeDriveService and call it from
file_manager_browsertest_base.cc, which sets the capabilities for entries added
in browser tests.

This patch unlocks support for capabilities in browser tests.

Bug: 719959
Cq-Include-Trybots: master.tryserver.chromium.linux:closure_compilation
Change-Id: I39be97972f9aaf013849d1150a2a25a7e88bc62d
Reviewed-on: https://chromium-review.googlesource.com/1081772
Commit-Queue: Sasha Morrissey <sashab@chromium.org>
Reviewed-by: Stuart Langley <slangley@chromium.org>
Cr-Commit-Position: refs/heads/master@{#566319}

chrome/browser/chromeos/file_manager/file_manager_browsertest_base.cc

@@ -515,16 +515,24 @@ class DriveTestVolume : public TestVolume {
     ASSERT_EQ(drive::FILE_ERROR_OK, error);
     ASSERT_TRUE(parent_entry);
 
+    // Create the capabilities object.
+    google_apis::FileResourceCapabilities capabilities;
+    capabilities.set_can_copy(entry.capabilities.can_copy);
+    capabilities.set_can_delete(entry.capabilities.can_delete);
+    capabilities.set_can_rename(entry.capabilities.can_rename);
+    capabilities.set_can_add_children(entry.capabilities.can_add_children);
+    capabilities.set_can_share(entry.capabilities.can_share);
+
     switch (entry.type) {
       case AddEntriesMessage::FILE:
         CreateFile(entry.source_file_name, parent_entry->resource_id(),
                    target_name, entry.mime_type,
                    entry.shared_option == AddEntriesMessage::SHARED,
-                   entry.last_modified_time);
+                   entry.last_modified_time, capabilities);
         break;
       case AddEntriesMessage::DIRECTORY:
         CreateDirectory(parent_entry->resource_id(), target_name,
-                        entry.last_modified_time);
+                        entry.last_modified_time, capabilities);
         break;
     }
 
@@ -535,9 +543,11 @@ class DriveTestVolume : public TestVolume {
   }
 
   // Creates an empty directory with the given |name| and |modification_time|.
-  void CreateDirectory(const std::string& parent_id,
-                       const std::string& target_name,
-                       const base::Time& modification_time) {
+  void CreateDirectory(
+      const std::string& parent_id,
+      const std::string& target_name,
+      const base::Time& modification_time,
+      const google_apis::FileResourceCapabilities& capabilities) {
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
 
     std::unique_ptr<google_apis::FileResource> entry;
@@ -555,6 +565,13 @@ class DriveTestVolume : public TestVolume {
     ASSERT_TRUE(error == google_apis::HTTP_SUCCESS);
     ASSERT_TRUE(entry);
 
+    fake_drive_service_->SetFileCapabilities(
+        entry->file_id(), capabilities,
+        google_apis::test_util::CreateCopyResultCallback(&error, &entry));
+    base::RunLoop().RunUntilIdle();
+    ASSERT_TRUE(error == google_apis::HTTP_SUCCESS);
+    ASSERT_TRUE(entry);
+
     CheckForUpdates();
   }
 
@@ -565,7 +582,8 @@ class DriveTestVolume : public TestVolume {
                   const std::string& target_name,
                   const std::string& mime_type,
                   bool shared_with_me,
-                  const base::Time& modification_time) {
+                  const base::Time& modification_time,
+                  const google_apis::FileResourceCapabilities& capabilities) {
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
 
     std::string content_data;
@@ -590,6 +608,13 @@ class DriveTestVolume : public TestVolume {
     ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
     ASSERT_TRUE(entry);
 
+    fake_drive_service_->SetFileCapabilities(
+        entry->file_id(), capabilities,
+        google_apis::test_util::CreateCopyResultCallback(&error, &entry));
+    base::RunLoop().RunUntilIdle();
+    ASSERT_TRUE(error == google_apis::HTTP_SUCCESS);
+    ASSERT_TRUE(entry);
+
     CheckForUpdates();
   }
 

components/drive/service/fake_drive_service.cc

@@ -1668,6 +1668,39 @@ void FakeDriveService::SetLastModifiedTime(
                                 std::make_unique<FileResource>(*file)));
 }
 
+void FakeDriveService::SetFileCapabilities(
+    const std::string& resource_id,
+    const google_apis::FileResourceCapabilities& capabilities,
+    const FileResourceCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(callback);
+
+  if (offline_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::BindOnce(callback, DRIVE_NO_CONNECTION,
+                                  std::unique_ptr<FileResource>()));
+    return;
+  }
+
+  EntryInfo* entry = FindEntryByResourceId(resource_id);
+  if (!entry) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::BindOnce(callback, HTTP_NOT_FOUND,
+                                  std::unique_ptr<FileResource>()));
+    return;
+  }
+
+  ChangeResource& change = entry->change_resource;
+  FileResource* file = change.mutable_file();
+  file->set_capabilities(capabilities);
+
+  AddNewChangestamp(&change, file->team_drive_id());
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(callback, HTTP_SUCCESS,
+                                std::make_unique<FileResource>(*file)));
+}
+
 google_apis::DriveApiErrorCode FakeDriveService::SetUserPermission(
     const std::string& resource_id,
     google_apis::drive::PermissionRole user_permission) {

components/drive/service/fake_drive_service.h

@@ -356,6 +356,14 @@ class FakeDriveService : public DriveServiceInterface {
       const base::Time& last_modified_time,
       const google_apis::FileResourceCallback& callback);
 
+  // Sets the capabilities for an entry specified by |resource_id|.
+  // On success, returns HTTP_SUCCESS with the parsed entry.
+  // |callback| must not be null.
+  void SetFileCapabilities(
+      const std::string& resource_id,
+      const google_apis::FileResourceCapabilities& capabilities,
+      const google_apis::FileResourceCallback& callback);
+
   // Sets the user's permission for an entry specified by |resource_id|.
   google_apis::DriveApiErrorCode SetUserPermission(
       const std::string& resource_id,

components/drive/service/fake_drive_service_unittest.cc

@@ -68,6 +68,64 @@ constexpr char TEAM_DRIVE_NAME_2[] = "The Seconcd Team Drive";
 constexpr char TEAM_DRIVE_ID_3[] = "the3rdTeamDriveId";
 constexpr char TEAM_DRIVE_NAME_3[] = "The Third Team Drive";
 
+// Creates a new FileResourceCapabilities object with mixed (true/false)
+// capability settings.
+google_apis::FileResourceCapabilities CreateMixedCapabilities() {
+  google_apis::FileResourceCapabilities capabilities;
+  capabilities.set_can_add_children(true);
+  capabilities.set_can_change_restricted_download(false);
+  capabilities.set_can_comment(true);
+  capabilities.set_can_copy(false);
+  capabilities.set_can_delete(true);
+  capabilities.set_can_download(false);
+  capabilities.set_can_edit(true);
+  capabilities.set_can_list_children(false);
+  capabilities.set_can_move_item_into_team_drive(true);
+  capabilities.set_can_move_team_drive_item(false);
+  capabilities.set_can_read_revisions(true);
+  capabilities.set_can_read_team_drive(false);
+  capabilities.set_can_remove_children(true);
+  capabilities.set_can_rename(false);
+  capabilities.set_can_share(true);
+  capabilities.set_can_trash(false);
+  capabilities.set_can_untrash(true);
+  return capabilities;
+}
+
+// Compares two capabilities objects with EXPECT_EQ.
+void ExpectCapabilitiesEqual(
+    const google_apis::FileResourceCapabilities& expectedCapabilities,
+    const google_apis::FileResourceCapabilities& actualCapabilities) {
+  EXPECT_EQ(expectedCapabilities.can_add_children(),
+            actualCapabilities.can_add_children());
+  EXPECT_EQ(expectedCapabilities.can_change_restricted_download(),
+            actualCapabilities.can_change_restricted_download());
+  EXPECT_EQ(expectedCapabilities.can_comment(),
+            actualCapabilities.can_comment());
+  EXPECT_EQ(expectedCapabilities.can_copy(), actualCapabilities.can_copy());
+  EXPECT_EQ(expectedCapabilities.can_delete(), actualCapabilities.can_delete());
+  EXPECT_EQ(expectedCapabilities.can_download(),
+            actualCapabilities.can_download());
+  EXPECT_EQ(expectedCapabilities.can_edit(), actualCapabilities.can_edit());
+  EXPECT_EQ(expectedCapabilities.can_list_children(),
+            actualCapabilities.can_list_children());
+  EXPECT_EQ(expectedCapabilities.can_move_item_into_team_drive(),
+            actualCapabilities.can_move_item_into_team_drive());
+  EXPECT_EQ(expectedCapabilities.can_move_team_drive_item(),
+            actualCapabilities.can_move_team_drive_item());
+  EXPECT_EQ(expectedCapabilities.can_read_revisions(),
+            actualCapabilities.can_read_revisions());
+  EXPECT_EQ(expectedCapabilities.can_read_team_drive(),
+            actualCapabilities.can_read_team_drive());
+  EXPECT_EQ(expectedCapabilities.can_remove_children(),
+            actualCapabilities.can_remove_children());
+  EXPECT_EQ(expectedCapabilities.can_rename(), actualCapabilities.can_rename());
+  EXPECT_EQ(expectedCapabilities.can_share(), actualCapabilities.can_share());
+  EXPECT_EQ(expectedCapabilities.can_trash(), actualCapabilities.can_trash());
+  EXPECT_EQ(expectedCapabilities.can_untrash(),
+            actualCapabilities.can_untrash());
+}
+
 class FakeDriveServiceTest : public testing::Test {
  protected:
   // Returns the resource entry that matches |resource_id|.
@@ -2312,6 +2370,62 @@ TEST_F(FakeDriveServiceTest, SetLastModifiedTime_Offline) {
   EXPECT_FALSE(entry);
 }
 
+TEST_F(FakeDriveServiceTest, SetFileCapabilities_ExistingFile) {
+  ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
+
+  const std::string kResourceId = "2_file_resource_id";
+  const google_apis::FileResourceCapabilities& kCapabilities =
+      CreateMixedCapabilities();
+
+  DriveApiErrorCode error = DRIVE_OTHER_ERROR;
+  std::unique_ptr<FileResource> entry;
+  fake_service_.SetFileCapabilities(
+      kResourceId, kCapabilities,
+      test_util::CreateCopyResultCallback(&error, &entry));
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(HTTP_SUCCESS, error);
+  ASSERT_TRUE(entry);
+  ExpectCapabilitiesEqual(kCapabilities, entry->capabilities());
+}
+
+TEST_F(FakeDriveServiceTest, SetFileCapabilities_NonexistingFile) {
+  ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
+
+  const std::string kResourceId = "nonexisting_resource_id";
+  const google_apis::FileResourceCapabilities& kCapabilities =
+      CreateMixedCapabilities();
+
+  DriveApiErrorCode error = DRIVE_OTHER_ERROR;
+  std::unique_ptr<FileResource> entry;
+  fake_service_.SetFileCapabilities(
+      kResourceId, kCapabilities,
+      test_util::CreateCopyResultCallback(&error, &entry));
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(HTTP_NOT_FOUND, error);
+  EXPECT_FALSE(entry);
+}
+
+TEST_F(FakeDriveServiceTest, SetFileCapabilities_Offline) {
+  ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
+  fake_service_.set_offline(true);
+
+  const std::string kResourceId = "2_file_resource_id";
+  const google_apis::FileResourceCapabilities& kCapabilities =
+      CreateMixedCapabilities();
+
+  DriveApiErrorCode error = DRIVE_OTHER_ERROR;
+  std::unique_ptr<FileResource> entry;
+  fake_service_.SetFileCapabilities(
+      kResourceId, kCapabilities,
+      test_util::CreateCopyResultCallback(&error, &entry));
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(DRIVE_NO_CONNECTION, error);
+  EXPECT_FALSE(entry);
+}
+
 }  // namespace
 
 }  // namespace drive

ui/file_manager/integration_tests/file_manager/background.js

@@ -175,7 +175,7 @@ var NESTED_ENTRY_SET = [
 ];
 
 /**
- * Expeceted list of preset entries in fake test volumes. This should be in sync
+ * Expected list of preset entries in fake test volumes. This should be in sync
  * with FakeTestVolume::PrepareTestEntries in the test harness.
  *
  * @type {Array<TestEntryInfo>}