Add browser test for VOLUME_TYPE_MTP volumes on Files.app.

chrome/browser/chromeos/file_manager/file_manager_browsertest.cc

 // Copyright (c) 2013 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.
 
 // Browser test for basic Chrome OS file manager functionality:
 //  - The file list is updated when a file is added externally to the Downloads
 //    folder.
 //  - Selecting a file and copy-pasting it with the keyboard copies the file.
 //  - Selecting a file and pressing delete deletes it.
 
@@ skipping 191 matching lines @@
       &AddEntriesMessage::entries);
 }
 
 // Test volume.
 class TestVolume {
  protected:
   explicit TestVolume(const std::string& name) : name_(name) {}
   virtual ~TestVolume() {}
 
   bool CreateRootDirectory(const Profile* profile) {
-    return root_.Set(profile->GetPath().Append(name_));
+    const base::FilePath path = profile->GetPath().Append(name_);
+    return root_.path() == path || root_.Set(path);
   }
 
   const std::string& name() { return name_; }
   const base::FilePath root_path() { return root_.path(); }
 
  private:
   std::string name_;
   base::ScopedTempDir root_;
 };
 
@@ skipping 61 matching lines @@
   DownloadsTestVolume() : LocalTestVolume("Downloads") {}
   virtual ~DownloadsTestVolume() {}
 
   virtual bool Mount(Profile* profile) OVERRIDE {
     return CreateRootDirectory(profile) &&
            VolumeManager::Get(profile)
                ->RegisterDownloadsDirectoryForTesting(root_path());
   }
 };
 
-class FakeUsbTestVolume : public LocalTestVolume {
+// Test volume for mimicing a specified type of volumes by a local folder.
+class FakeTestVolume : public LocalTestVolume {
  public:
-  FakeUsbTestVolume() : LocalTestVolume("fake-usb") {}
-  virtual ~FakeUsbTestVolume() {}
+  FakeTestVolume(const std::string& name,
+                 VolumeType volume_type,
+                 chromeos::DeviceType device_type)
+      : LocalTestVolume(name),
+        volume_type_(volume_type),
+        device_type_(device_type) {}
+  virtual ~FakeTestVolume() {}
+
+  // Simple test entries used for testing, e.g., read-only volumes.
+  bool PrepareTestEntries(Profile* profile) {
+    if (!CreateRootDirectory(profile))
+      return false;
+    // Must be in sync with BASIC_FAKE_ENTRY_SET in the JS test code.
+    CreateEntry(
+        TestEntryInfo(FILE, "text.txt", "hello.txt", "text/plain", NONE,
+                      base::Time::Now()));
+    CreateEntry(
+        TestEntryInfo(DIRECTORY, std::string(), "A", std::string(), NONE,
+                      base::Time::Now()));
+    return true;
+  }
 
   virtual bool Mount(Profile* profile) OVERRIDE {
     if (!CreateRootDirectory(profile))
       return false;
     fileapi::ExternalMountPoints* const mount_points =
         fileapi::ExternalMountPoints::GetSystemInstance();
 
     // First revoke the existing mount point (if any).
     mount_points->RevokeFileSystem(name());
     const bool result =
         mount_points->RegisterFileSystem(name(),
                                          fileapi::kFileSystemTypeNativeLocal,
                                          fileapi::FileSystemMountOption(),
                                          root_path());
     if (!result)
       return false;
 
-    VolumeManager::Get(profile)
-        ->AddVolumeInfoForTesting(root_path(),
-                                  VOLUME_TYPE_REMOVABLE_DISK_PARTITION,
-                                  chromeos::DEVICE_TYPE_USB);
+    VolumeManager::Get(profile)->AddVolumeInfoForTesting(
+        root_path(), volume_type_, device_type_);
     return true;
   }
+
+ private:
+  const VolumeType volume_type_;
+  const chromeos::DeviceType device_type_;
 };
 
 // The drive volume class for test.
 // This class provides the operations for a test volume that simulates Google
 // drive.
 class DriveTestVolume : public TestVolume {
  public:
   DriveTestVolume() : TestVolume("drive"), integration_service_(NULL) {}
   virtual ~DriveTestVolume() {}
 
@@ skipping 201 matching lines @@
     return "file_manager_test_manifest.json";
   }
   virtual GuestMode GetGuestModeParam() const = 0;
   virtual const char* GetTestCaseNameParam() const = 0;
   virtual std::string OnMessage(const std::string& name,
                                 const base::Value* value);
 
   scoped_ptr<LocalTestVolume> local_volume_;
   linked_ptr<DriveTestVolume> drive_volume_;
   std::map<Profile*, linked_ptr<DriveTestVolume> > drive_volumes_;
-  scoped_ptr<LocalTestVolume> usb_volume_;
+  scoped_ptr<FakeTestVolume> usb_volume_;
+  scoped_ptr<FakeTestVolume> mtp_volume_;
 
  private:
   drive::DriveIntegrationService* CreateDriveIntegrationService(
       Profile* profile);
   DriveIntegrationServiceFactory::FactoryCallback
       create_drive_integration_service_;
   scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
       service_factory_for_test_;
 };
 
@@ skipping 131 matching lines @@
           if (usb_volume_)
             usb_volume_->CreateEntry(*message.entries[i]);
           break;
         default:
           NOTREACHED();
           break;
       }
     }
     return "onEntryAdded";
   } else if (name == "mountFakeUsb") {
-    usb_volume_.reset(new FakeUsbTestVolume());
+    usb_volume_.reset(new FakeTestVolume("fake-usb",
+                                         VOLUME_TYPE_REMOVABLE_DISK_PARTITION,
+                                         chromeos::DEVICE_TYPE_USB));
     usb_volume_->Mount(profile());
     return "true";
+  } else if (name == "mountFakeMtp") {
+    mtp_volume_.reset(new FakeTestVolume("fake-mtp",
+                                         VOLUME_TYPE_MTP,
+                                         chromeos::DEVICE_TYPE_UNKNOWN));
+    if (!mtp_volume_->PrepareTestEntries(profile()))
+      return "false";
+    mtp_volume_->Mount(profile());
+    return "true";
   }
   return "unknownMessage";
 }
 
 drive::DriveIntegrationService*
 FileManagerBrowserTestBase::CreateDriveIntegrationService(Profile* profile) {
   drive_volumes_[profile].reset(new DriveTestVolume());
   return drive_volumes_[profile]->CreateDriveIntegrationService(profile);
 }
 
@@ skipping 15 matching lines @@
 
 IN_PROC_BROWSER_TEST_P(FileManagerBrowserTest, Test) {
   StartTest();
 }
 
 INSTANTIATE_TEST_CASE_P(
     FileDisplay,
     FileManagerBrowserTest,
     ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "fileDisplayDownloads"),
                       TestParameter(IN_GUEST_MODE, "fileDisplayDownloads"),
-                      TestParameter(NOT_IN_GUEST_MODE, "fileDisplayDrive")));
+                      TestParameter(NOT_IN_GUEST_MODE, "fileDisplayDrive"),
+                      TestParameter(NOT_IN_GUEST_MODE, "fileDisplayMtp")));
 
 INSTANTIATE_TEST_CASE_P(
     OpenZipFiles,
     FileManagerBrowserTest,
     ::testing::Values(TestParameter(IN_GUEST_MODE, "zipOpenDownloads"),
                       TestParameter(NOT_IN_GUEST_MODE, "zipOpenDownloads"),
                       TestParameter(NOT_IN_GUEST_MODE, "zipOpenDrive")));
 
 INSTANTIATE_TEST_CASE_P(
     OpenVideoFiles,
@@ skipping 397 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, OpenSingleImageOnDrive) {
   AddScript("gallery/open_image_files.js");
   set_test_case_name("openSingleImageOnDrive");
   StartTest();
 }
 
 }  // namespace
 }  // namespace file_manager