Parameterize FileManagerBrowserTransferTest.

chrome/browser/chromeos/extensions/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 29 matching lines @@
 enum EntryType {
   FILE,
   DIRECTORY,
 };
 
 enum SharedOption {
   NONE,
   SHARED,
 };
 
+enum TestSettings {

[hashimoto, 2013/06/03 08:15:34]

nit: "-Settings" sounds like a name of a struct rather than an enum. (At least,
no enum named in this manner found in chromium code. http://goo.gl/PGUho)
How about using other terms? (e.g. "Type", "Option", "Flag", "Mode")

BTW, do we need to configure the test fixture in this level?
How about setting up "Downloads" only when IN_GUEST and both "drive" and
"Downloads" when NOT_IN_GUEST?
IIUC there is no bad side effect caused by always setting up both volumes.

[hirono, 2013/06/03 09:58:11]

Yes, we can remove volume options.
I fixed.

+  IN_GUEST_MODE = 0x1,
+  USE_LOCAL_VOLUME = 0x2,
+  USE_DRIVE_VOLUME = 0x4
+};
+
+// This global operator is used from Google Test.

[hashimoto, 2013/06/03 08:15:34]

IIUC this operator is used to generate names of instantiated test cases, right?
If so, please clarify it and make the result string more similar to other test
case names. (e.g. ',' and ' ' are not used for names of other tests.)

[hirono, 2013/06/03 09:58:11]

This operator is not used for the naming of tests.
Parameterized tests are just numbered, and when it failed, the parameters are
output as error messages.
This operation is used to format the error messages.
http://goo.gl/GdEZ6

+std::ostream& operator<<(std::ostream& os, const TestSettings& option) {
+  std::vector<std::string> labels;
+  if (option & IN_GUEST_MODE)
+    labels.push_back("IN_GUEST_MODE");
+  if (option & USE_LOCAL_VOLUME)
+    labels.push_back("USE_LOCAL_VOLUME");
+  if (option & USE_DRIVE_VOLUME)
+    labels.push_back("USE_DRIVE_VOLUME");
+  if (labels.empty())
+    labels.push_back("NO_OPTION");
+  for (size_t i = 0; i < labels.size(); i++) {
+    os << labels[i];
+    if (i != labels.size() - 1)
+      os << ", ";
+  }
+  return os;
+}
+
 struct TestEntryInfo {
   EntryType type;
   const char* source_file_name;  // Source file name to be used as a prototype.
   const char* target_name;  // Target file or directory name.
   const char* mime_type;
   SharedOption shared_option;
   const char* last_modified_time_as_string;
 };
 
 TestEntryInfo kTestEntrySetCommon[] = {
@@ skipping 168 matching lines @@
         time,
         google_apis::test_util::CreateCopyResultCallback(&error,
                                                          &resource_entry));
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_TRUE(error == google_apis::HTTP_SUCCESS);
     ASSERT_TRUE(resource_entry);
     CheckForUpdates();
   }
 
   virtual std::string GetName() const OVERRIDE {
-    return "Drive";
+    return kDriveVolume;
   }
 
   // Creates a test file with the given spec.
   // Serves |test_file_name| file. Pass an empty string for an empty file.
   void CreateFile(const std::string& source_file_name,
                   const std::string& target_file_name,
                   const std::string& mime_type,
                   bool shared_with_me,
                   const std::string& modification_time) {
     google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
@@ skipping 56 matching lines @@
         NULL);
     return integration_service_;
   }
 
  private:
   base::ScopedTempDir test_cache_root_;
   google_apis::FakeDriveService* fake_drive_service_;
   drive::DriveIntegrationService* integration_service_;
 };
 
-// The base test class. Used by FileManagerBrowserLocalTest,
-// FileManagerBrowserDriveTest, and FileManagerBrowserTransferTest.
-// The boolean parameter, retrieved by GetParam(), is true if testing in the
-// guest mode. See SetUpCommandLine() below for details.
-class FileManagerBrowserTestBase : public ExtensionApiTest,
-                                   public ::testing::WithParamInterface<bool> {
+// The base test class. Used by FileManagerBrowserSimpleTest,
+// FileManagerBrowserComplexTest.

[hashimoto, 2013/06/03 08:15:34]

nit: Do we need to list all subclasses here? This comment can easily gets
obsolete and hard to maintain. Also, it's easy to find subclasses by simple
grep.

[hirono, 2013/06/03 09:58:11]

Done.

+class FileManagerBrowserTestBase : public ExtensionApiTest {
  protected:
+  explicit FileManagerBrowserTestBase(TestSettings test_settings) :
+      test_settings_(test_settings),
+      local_volume_(test_settings & USE_LOCAL_VOLUME ?
+                    new LocalTestVolume(kDownloadsVolume) : NULL),
+      drive_volume_(test_settings & USE_DRIVE_VOLUME ?
+                    new DriveTestVolume() : NULL) {}
+
+  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
+
+  virtual void SetUpOnMainThread() OVERRIDE;
+
   // Adds an incognito and guest-mode flags for tests in the guest mode.
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
 
   // Loads our testing extension and sends it a string identifying the current
   // test.
   void StartTest(const std::string& test_name);
 
   // Creates test files and directories.
-  void CreateTestEntries(TestVolume* volume, const TestEntryInfo* entries,
+  void CreateTestEntries(TestVolume* volume,
+                         const TestEntryInfo* entries,
                          size_t num_entries);
 
-  // Runs the file display test on the passed |volume|, shared by subclasses.
-  void DoTestFileDisplay(TestVolume* volume);
+  // Replace '?' with the volume name.

[hashimoto, 2013/06/03 08:15:34]

This comment seems partly wrong because this function only checks the last
character of the given string.

Also, this mechanism ('?' in test parameter string gets replaced with the main
volume name) seems a little bit complicated. (if someone saw test_cases.js and
grepped "transferFromDriveToDownloads" they can find the corresponding code in
this file, but for "keyboardDeleteDrive", they cannot.)
Can we go without this function? (i.e. Instantiate "keyboardDeleteDrive"
directly, instead of using "keyboardDelete?")

[hirono, 2013/06/03 09:58:11]

Done.

+  std::string FormatTestName(const std::string& test_name);
+
+  // Returns test volume that is used mainly.
+  TestVolume* GetMainVolume();
+
+ private:
+  TestSettings test_settings_;
+  const scoped_ptr<LocalTestVolume> local_volume_;
+  const scoped_ptr<DriveTestVolume> drive_volume_;
 };
 
+void FileManagerBrowserTestBase::SetUpInProcessBrowserTestFixture() {
+  ExtensionApiTest::SetUpInProcessBrowserTestFixture();
+  extensions::ComponentLoader::EnableBackgroundExtensionsForTesting();
+  if (drive_volume_) {

[hashimoto, 2013/06/03 08:15:34]

nit: No need to have '{'

[hirono, 2013/06/03 09:58:11]

Done.

+    ASSERT_TRUE(drive_volume_->SetUp());
+  }
+}
+
+void FileManagerBrowserTestBase::SetUpOnMainThread() {
+  ExtensionApiTest::SetUpOnMainThread();
+  if (local_volume_) {
+    ASSERT_TRUE(local_volume_->Mount(browser()->profile()));
+    CreateTestEntries(local_volume_.get(),
+                      kTestEntrySetCommon,
+                      arraysize(kTestEntrySetCommon));
+  }
+  if (drive_volume_) {
+    CreateTestEntries(drive_volume_.get(),
+                      kTestEntrySetCommon,
+                      arraysize(kTestEntrySetCommon));
+    // For testing Drive, create more entries with Drive specific attributes.
+    // TODO(haruki): Add a case for an entry cached by DriveCache.
+    CreateTestEntries(drive_volume_.get(),
+                      kTestEntrySetDriveOnly,
+                      arraysize(kTestEntrySetDriveOnly));
+    drive_test_util::WaitUntilDriveMountPointIsAdded(browser()->profile());
+  }
+}
+
 void FileManagerBrowserTestBase::SetUpCommandLine(CommandLine* command_line) {
-  bool in_guest_mode = GetParam();
-  if (in_guest_mode) {
+  if (test_settings_ & IN_GUEST_MODE) {
     command_line->AppendSwitch(chromeos::switches::kGuestSession);
     command_line->AppendSwitchNative(chromeos::switches::kLoginUser, "");
     command_line->AppendSwitch(switches::kIncognito);
   }
   ExtensionApiTest::SetUpCommandLine(command_line);
 }
 
 void FileManagerBrowserTestBase::StartTest(const std::string& test_name) {
   base::FilePath path = test_data_dir_.AppendASCII("file_manager_browsertest");
   const extensions::Extension* extension = LoadExtensionAsComponent(path);
   ASSERT_TRUE(extension);
 
-  bool in_guest_mode = GetParam();
+  bool in_guest_mode = test_settings_ & IN_GUEST_MODE;
   ExtensionTestMessageListener listener(
       in_guest_mode ? "which test guest" : "which test non-guest", true);
   ASSERT_TRUE(listener.WaitUntilSatisfied());
   listener.Reply(test_name);
 }
 
 void FileManagerBrowserTestBase::CreateTestEntries(
     TestVolume* volume, const TestEntryInfo* entries, size_t num_entries) {
   for (size_t i = 0; i < num_entries; ++i) {
     volume->CreateEntry(entries[i]);
   }
 }
 
-void FileManagerBrowserTestBase::DoTestFileDisplay(TestVolume* volume) {
+std::string FileManagerBrowserTestBase::FormatTestName(
+    const std::string& test_name) {
+  std::string result = test_name;
+  if (result.at(result.size() - 1) == '?') {
+    result.erase(result.size() - 1);
+    result.append(GetMainVolume()->GetName());
+  }
+  return result;
+}
+
+TestVolume* FileManagerBrowserTestBase::GetMainVolume() {
+  if (local_volume_)

[hashimoto, 2013/06/03 08:15:34]

"return NULL" cannot happen, right?
Seems this function can be "return drive_volume_ ? drive_volume_.get() :
local_volume_.get();".

[hirono, 2013/06/03 09:58:11]

This function is no longer needed.
I just remove it.

+    return local_volume_.get();
+  else if (drive_volume_)
+    return drive_volume_.get();
+  else
+    return NULL;
+}
+
+// A test class test that needs specific operations.
+class FileManagerBrowserComplexTest :
+      public FileManagerBrowserTestBase,
+      public ::testing::WithParamInterface<TestSettings> {
+ public:
+  FileManagerBrowserComplexTest() :
+      FileManagerBrowserTestBase(GetParam()) {}
+};
+
+IN_PROC_BROWSER_TEST_P(FileManagerBrowserComplexTest,
+                       DoTestFileDisplay) {

[hashimoto, 2013/06/03 08:15:34]

nit: "Do" and "Test" are redundant. (All code in this file is of course for
doing tests.) I think "FileDisplay" is enough.

[hirono, 2013/06/03 09:58:11]

Done.

   ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("fileDisplay" + volume->GetName()));
+  ASSERT_NO_FATAL_FAILURE(StartTest(FormatTestName("fileDisplay?")));
 
   ExtensionTestMessageListener listener("initial check done", true);
   ASSERT_TRUE(listener.WaitUntilSatisfied());
   const TestEntryInfo entry = {
     FILE,
     "music.ogg",  // Prototype file name.
     "newly added file.ogg",  // Target file name.
     "audio/ogg",
     NONE,
     "4 Sep 1998 00:00:00"
   };
-  volume->CreateEntry(entry);
+  GetMainVolume()->CreateEntry(entry);
   listener.Reply("file added");
 
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
-// A class to test local volumes.
-class FileManagerBrowserLocalTest : public FileManagerBrowserTestBase {
+INSTANTIATE_TEST_CASE_P(
+    AllSettings,
+    FileManagerBrowserComplexTest,
+    ::testing::Values(USE_LOCAL_VOLUME,
+                      USE_LOCAL_VOLUME | IN_GUEST_MODE,
+                      USE_DRIVE_VOLUME));
+
+// A test class that just executes JavaScript unit test.
+class FileManagerBrowserSimpleTest :
+      public FileManagerBrowserTestBase,
+      public ::testing::WithParamInterface<std::tr1::tuple<TestSettings,
+                                                           const char*> > {
  public:
-  FileManagerBrowserLocalTest() : volume_("Downloads") {}
-
- protected:
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
-    FileManagerBrowserTestBase::SetUpInProcessBrowserTestFixture();
-    extensions::ComponentLoader::EnableBackgroundExtensionsForTesting();
-  }
-
-  virtual void SetUpOnMainThread() OVERRIDE {
-    FileManagerBrowserTestBase::SetUpOnMainThread();
-    ASSERT_TRUE(volume_.Mount(browser()->profile()));
-    CreateTestEntries(&volume_, kTestEntrySetCommon,
-                      arraysize(kTestEntrySetCommon));
-  }
-
-  LocalTestVolume volume_;
+  FileManagerBrowserSimpleTest() :
+      FileManagerBrowserTestBase(std::tr1::get<0>(GetParam())) {}
 };
 
-INSTANTIATE_TEST_CASE_P(InGuestMode,
-                        FileManagerBrowserLocalTest,
-                        ::testing::Values(true));
-
-INSTANTIATE_TEST_CASE_P(InNonGuestMode,
-                        FileManagerBrowserLocalTest,
-                        ::testing::Values(false));
-
-// A class to test Drive's volumes
-class FileManagerBrowserDriveTest : public FileManagerBrowserTestBase {
- protected:
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
-    FileManagerBrowserTestBase::SetUpInProcessBrowserTestFixture();
-    extensions::ComponentLoader::EnableBackgroundExtensionsForTesting();
-    ASSERT_TRUE(volume_.SetUp());
-  }
-
-  virtual void SetUpOnMainThread() OVERRIDE {
-    FileManagerBrowserTestBase::SetUpOnMainThread();
-    CreateTestEntries(&volume_, kTestEntrySetCommon,
-                      arraysize(kTestEntrySetCommon));
-    // For testing Drive, create more entries with Drive specific attributes.
-    // TODO(haruki): Add a case for an entry cached by DriveCache.
-    CreateTestEntries(&volume_, kTestEntrySetDriveOnly,
-                      arraysize(kTestEntrySetDriveOnly));
-    drive_test_util::WaitUntilDriveMountPointIsAdded(browser()->profile());
-  }
-
-  DriveTestVolume volume_;
-};
-
-// Don't test Drive in the guest mode as it's not supported.
-INSTANTIATE_TEST_CASE_P(InNonGuestMode,
-                        FileManagerBrowserDriveTest,
-                        ::testing::Values(false));
-
-// A class to test both local and Drive's volumes.
-class FileManagerBrowserTransferTest : public FileManagerBrowserTestBase {
- public:
-  FileManagerBrowserTransferTest() : local_volume_("Downloads") {}
-
- protected:
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
-    FileManagerBrowserTestBase::SetUpInProcessBrowserTestFixture();
-    extensions::ComponentLoader::EnableBackgroundExtensionsForTesting();
-    ASSERT_TRUE(drive_volume_.SetUp());
-  }
-
-  virtual void SetUpOnMainThread() OVERRIDE {
-    FileManagerBrowserTestBase::SetUpOnMainThread();
-    ASSERT_TRUE(local_volume_.Mount(browser()->profile()));
-    CreateTestEntries(&local_volume_, kTestEntrySetCommon,
-                      arraysize(kTestEntrySetCommon));
-    CreateTestEntries(&drive_volume_, kTestEntrySetCommon,
-                      arraysize(kTestEntrySetCommon));
-    CreateTestEntries(&drive_volume_, kTestEntrySetDriveOnly,
-                      arraysize(kTestEntrySetDriveOnly));
-    drive_test_util::WaitUntilDriveMountPointIsAdded(browser()->profile());
-  }
-
-  LocalTestVolume local_volume_;
-  DriveTestVolume drive_volume_;
-};
-
-// FileManagerBrowserTransferTest depends on Drive and Drive is not supported in
-// the guest mode.
-INSTANTIATE_TEST_CASE_P(InNonGuestMode,
-                        FileManagerBrowserTransferTest,
-                        ::testing::Values(false));
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserLocalTest, TestFileDisplay) {
-  DoTestFileDisplay(&volume_);
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserLocalTest, TestGalleryOpen) {
+IN_PROC_BROWSER_TEST_P(FileManagerBrowserSimpleTest,
+                       ExecuteJavaScriptTest) {

[hashimoto, 2013/06/03 08:15:34]

nit: "ExecuteJavaScriptTest" might be appropriate for a method name, but sounds
a little bit verbose for a test case. How about "SimpleTest" or maybe just
"Test"?

[hirono, 2013/06/03 09:58:11]

Done.

   ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("galleryOpenDownloads"));
+  ASSERT_NO_FATAL_FAILURE(
+      StartTest(FormatTestName(std::tr1::get<1>(GetParam()))));
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserLocalTest, TestKeyboardDelete) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("keyboardDeleteDownloads"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
+INSTANTIATE_TEST_CASE_P(
+    OpenSpecialTypes,

[hashimoto, 2013/06/03 08:15:34]

Why OpenSpecialTypes and KeyboardOperation are listed separately?

[hirono, 2013/06/03 09:58:11]

Parameterized tests are not named, just numbered.
So I would like to separate them to some groups because the name of each group
can be readable and they can be filtered by the gtest_filter option.

+    FileManagerBrowserSimpleTest,
+    ::testing::Combine(
+         ::testing::Values(

[hashimoto, 2013/06/03 08:15:34]

nit: "USE_LOCAL_VOLUME" can be in this line? The same goes for others.

[hirono, 2013/06/03 09:58:11]

Done.

+              USE_LOCAL_VOLUME,
+              USE_LOCAL_VOLUME | IN_GUEST_MODE,
+              USE_DRIVE_VOLUME),
+         ::testing::Values("videoOpen?", "audioOpen?")));
 
-// Disabled temporarily since fails on Linux Chromium OS ASAN Tests (2).
-// TODO(mtomasz): crbug.com/243611.
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, DISABLED_TestGalleryOpen) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("galleryOpenDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
+INSTANTIATE_TEST_CASE_P(
+    GalleryOpen,
+    FileManagerBrowserSimpleTest,
+    ::testing::Combine(
+         ::testing::Values(
+              USE_LOCAL_VOLUME,
+              USE_LOCAL_VOLUME | IN_GUEST_MODE
+              // Disabled temporarily since fails on Linux Chromium OS ASAN
+              // Tests (2).  TODO(mtomasz): crbug.com/243611.
+              // USE_DRIVE_VOLUME
+         ),
+         ::testing::Values("galleryOpen?")));
 
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserLocalTest, TestAudioOpen) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("galleryOpenDownloads"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();}
+INSTANTIATE_TEST_CASE_P(
+    KeyboardOperation,
+    FileManagerBrowserSimpleTest,
+    ::testing::Combine(
+         ::testing::Values(
+              USE_LOCAL_VOLUME,
+              USE_LOCAL_VOLUME | IN_GUEST_MODE,
+              USE_DRIVE_VOLUME),
+         ::testing::Values("keyboardDelete?", "keyboardCopy?")));
 
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, TestAudioOpen) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("galleryOpenDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
+INSTANTIATE_TEST_CASE_P(
+    DriveSpecific,
+    FileManagerBrowserSimpleTest,
+    ::testing::Combine(
+         ::testing::Values(USE_DRIVE_VOLUME),
+         ::testing::Values(
+              "openSidebarRecent",
+              "openSidebarOffline",
+              "openSidebarSharedWithMe",
+              "autocomplete")));
 
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserLocalTest, TestVideoOpen) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("galleryOpenDownloads"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, TestVideoOpen) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("galleryOpenDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, TestKeyboardCopy) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("keyboardCopyDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, TestKeyboardDelete) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("keyboardDeleteDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, TestOpenRecent) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("openSidebarRecent"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, TestOpenOffline) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("openSidebarOffline"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, TestOpenSharedWithMe) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("openSidebarSharedWithMe"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserDriveTest, TestAutocomplete) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("autocomplete"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserTransferTest,
-                       TransferFromDriveToDownloads) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("transferFromDriveToDownloads"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserTransferTest,
-                       TransferFromDownloadsToDrive) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("transferFromDownloadsToDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserTransferTest,
-                       TransferFromSharedToDownloads) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("transferFromSharedToDownloads"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserTransferTest,
-                       TransferFromSharedToDrive) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("transferFromSharedToDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserTransferTest,
-                       TransferFromRecentToDownloads) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("transferFromRecentToDownloads"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserTransferTest,
-                       TransferFromRecentToDrive) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("transferFromRecentToDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserTransferTest,
-                       TransferFromOfflineToDownloads) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("transferFromOfflineToDownloads"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
-IN_PROC_BROWSER_TEST_P(FileManagerBrowserTransferTest,
-                       TransferFromOfflineToDrive) {
-  ResultCatcher catcher;
-  ASSERT_NO_FATAL_FAILURE(StartTest("transferFromOfflineToDrive"));
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
+INSTANTIATE_TEST_CASE_P(
+    Transfer,
+    FileManagerBrowserSimpleTest,
+    ::testing::Combine(
+         ::testing::Values((TestSettings)(USE_LOCAL_VOLUME | USE_DRIVE_VOLUME)),

[hashimoto, 2013/06/03 08:15:34]

Please don't use C-style cast.
Also, since the type of the expression |USE_LOCAL_VOLUME | USE_DRIVE_VOLUME| is
int, not TestSettings, you should change the argument type instead of casting
here.

[hirono, 2013/06/03 09:58:11]

This bit operation is no longer used.

+         ::testing::Values(
+              "transferFromDriveToDownloads",
+              "transferFromDownloadsToDrive",
+              "transferFromSharedToDownloads",
+              "transferFromSharedToDrive",
+              "transferFromRecentToDownloads",
+              "transferFromRecentToDrive",
+              "transferFromOfflineToDownloads",
+              "transferFromOfflineToDrive")));
 
 }  // namespace