drive: Some cleanup for file_manager_browsertest.cc

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 77 matching lines @@
   // Creates a file with the given |name|, |length|, and |modification_time|.
   virtual void CreateTestFile(const std::string& name,
                               int64 length,
                               const std::string& modification_time) = 0;
 
   // Creates an empty directory with the given |name| and |modification_time|.
   virtual void CreateTestDirectory(
       const std::string& name,
       const std::string& modification_time) = 0;
 
+  // Returns the path of the root directory.
+  virtual base::FilePath GetRootPath() = 0;
+
+  // Returns true if |file_path| exists.
+  virtual bool PathExists(const base::FilePath& file_path) = 0;
+
+  // Waits until a file with the given size is present at |path|. Returns
+  // true on success.
+  virtual bool WaitUntilFilePresentWithSize(const base::FilePath& file_path,
+                                            int64 file_size) = 0;
+
+  // Waits until a file is not present at |path|. Returns true on success.
+  virtual bool WaitUntilFileNotPresent(const base::FilePath& file_path)
+      = 0;
+
   // Runs the file display test, shared by sub classes.
   void DoTestFileDisplay();
 };
 
 void FileManagerBrowserTestBase::StartFileManager(
     const std::string& directory_path) {
   std::string file_manager_url =
       (std::string("chrome-extension://") +
        kFileManagerExtensionId +
        "/main.html#" +
@@ skipping 34 matching lines @@
   StartTest("file display");
 
   ExtensionTestMessageListener listener("initial check done", true);
   ASSERT_TRUE(listener.WaitUntilSatisfied());
   CreateTestFile("newly added file.mp3", 2000, "4 Sep 1998 00:00:00");
   listener.Reply("file added");
 
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
+// Monitors changes to a single file until the supplied condition callback
+// returns true. Usage:
+//   TestFilePathWatcher watcher(path_to_file, MyConditionCallback);
+//   watcher.StartAndWaitUntilReady();
+//   ... trigger filesystem modification ...
+//   watcher.RunMessageLoopUntilConditionSatisfied();
+class TestFilePathWatcher {
+ public:
+  typedef base::Callback<bool(const base::FilePath& file_path)>
+      ConditionCallback;
+
+  // Stores the supplied |path| and |condition| for later use (no side effects).
+  TestFilePathWatcher(const base::FilePath& path,
+                      const ConditionCallback& condition);
+
+  // Waits (running a message pump) until the callback returns true or
+  // FilePathWatcher reports an error. Return true on success.
+  bool RunMessageLoopUntilConditionSatisfied();
+
+ private:
+  // Starts the FilePathWatcher to watch the target file. Also check if the
+  // condition is already met.
+  void StartWatching();
+
+  // FilePathWatcher callback (on the FILE thread). Posts Done() to the UI
+  // thread when the condition is satisfied or there is an error.
+  void FilePathWatcherCallback(const base::FilePath& path, bool error);
+
+  const base::FilePath path_;
+  ConditionCallback condition_;
+  scoped_ptr<base::FilePathWatcher> watcher_;
+  base::RunLoop run_loop_;
+  base::Closure quit_closure_;
+  bool failed_;
+};
+
+TestFilePathWatcher::TestFilePathWatcher(const base::FilePath& path,
+                                         const ConditionCallback& condition)
+    : path_(path),
+      condition_(condition),
+      quit_closure_(run_loop_.QuitClosure()),
+      failed_(false) {
+}
+
+void TestFilePathWatcher::StartWatching() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+
+  watcher_.reset(new base::FilePathWatcher);
+  bool ok = watcher_->Watch(
+      path_, false /*recursive*/,
+      base::Bind(&TestFilePathWatcher::FilePathWatcherCallback,
+                 base::Unretained(this)));
+  DCHECK(ok);
+
+  // If the condition was already met before FilePathWatcher was launched,
+  // FilePathWatcher won't be able to detect a change, so check the condition
+  // here.
+  if (condition_.Run(path_)) {
+    watcher_.reset();
+    content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                     FROM_HERE,
+                                     quit_closure_);
+    return;
+  }
+}
+
+void TestFilePathWatcher::FilePathWatcherCallback(const base::FilePath& path,
+                                                  bool failed) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_EQ(path_.value(), path.value());
+
+  if (failed || condition_.Run(path)) {
+    failed_ = failed;
+    watcher_.reset();
+    content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                     FROM_HERE,
+                                     quit_closure_);
+  }
+}
+
+bool TestFilePathWatcher::RunMessageLoopUntilConditionSatisfied() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&TestFilePathWatcher::StartWatching,
+                 base::Unretained(this)));
+
+  // Wait until the condition is met.
+  run_loop_.Run();
+  return !failed_;
+}
+
+// Returns true if a file with the given size is present at |path|.
+bool FilePresentWithSize(const int64 file_size,
+                         const base::FilePath& path) {
+  int64 copy_size = 0;
+  // If the file doesn't exist yet this will fail and we'll keep waiting.
+  if (!file_util::GetFileSize(path, &copy_size))
+    return false;
+  return (copy_size == file_size);
+}
+
+// Returns true if a file is not present at |path|.
+bool FileNotPresent(const base::FilePath& path) {
+  return !file_util::PathExists(path);
+};
+
 // The boolean parameter, retrieved by GetParam(), is true if testing in the
 // guest mode. See SetUpCommandLine() below for details.
 class FileManagerBrowserLocalTest : public FileManagerBrowserTestBase,
                                     public ::testing::WithParamInterface<bool> {
  public:
   virtual void SetUp() OVERRIDE {
     extensions::ComponentLoader::EnableBackgroundExtensionsForTesting();
 
     ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
     downloads_path_ = tmp_dir_.path().Append("Downloads");
@@ skipping 14 matching lines @@
   }
 
  protected:
   // FileManagerBrowserTestBase overrides.
   virtual void CreateTestFile(const std::string& name,
                               int64 length,
                               const std::string& modification_time) OVERRIDE;
   virtual void CreateTestDirectory(
       const std::string& name,
       const std::string& modification_time) OVERRIDE;
+  virtual base::FilePath GetRootPath() OVERRIDE;
+  virtual bool PathExists(const base::FilePath& file_path) OVERRIDE;
+  virtual bool WaitUntilFilePresentWithSize(const base::FilePath& file_path,
+                                            int64 file_size) OVERRIDE;
+  virtual bool WaitUntilFileNotPresent(const base::FilePath& file_path)
+      OVERRIDE;
 
   // Add a mount point to the fake Downloads directory. Should be called
   // before StartFileManager().
   void AddMountPointToFakeDownloads();
 
   // Path to the fake Downloads directory used in the test.
   base::FilePath downloads_path_;
 
  private:
   base::ScopedTempDir tmp_dir_;
@@ skipping 30 matching lines @@
 void FileManagerBrowserLocalTest::CreateTestDirectory(
     const std::string& name,
     const std::string& modification_time) {
   base::FilePath path = downloads_path_.AppendASCII(name);
   ASSERT_TRUE(file_util::CreateDirectory(path));
   base::Time time;
   ASSERT_TRUE(base::Time::FromString(modification_time.c_str(), &time));
   ASSERT_TRUE(file_util::SetLastModifiedTime(path, time));
 }
 
+base::FilePath FileManagerBrowserLocalTest::GetRootPath() {
+  return downloads_path_;
+}
+
+bool FileManagerBrowserLocalTest::PathExists(const base::FilePath& file_path) {
+  return file_util::PathExists(file_path);
+}
+
+bool FileManagerBrowserLocalTest::WaitUntilFilePresentWithSize(
+    const base::FilePath& file_path,
+    int64 file_size) {
+  TestFilePathWatcher watcher(file_path, base::Bind(FilePresentWithSize,
+                                                    file_size));
+  return watcher.RunMessageLoopUntilConditionSatisfied();
+}
+
+bool FileManagerBrowserLocalTest::WaitUntilFileNotPresent(
+    const base::FilePath& file_path) {
+  TestFilePathWatcher watcher(file_path, base::Bind(FileNotPresent));
+  return watcher.RunMessageLoopUntilConditionSatisfied();
+}
+
 void FileManagerBrowserLocalTest::AddMountPointToFakeDownloads() {
   // Install our fake Downloads mount point first.
   fileapi::ExternalMountPoints* mount_points =
       content::BrowserContext::GetMountPoints(profile());
   ASSERT_TRUE(mount_points->RevokeFileSystem("Downloads"));
   ASSERT_TRUE(mount_points->RegisterFileSystem(
       "Downloads", fileapi::kFileSystemTypeNativeLocal, downloads_path_));
 }
 
 class FileManagerBrowserDriveTest : public FileManagerBrowserTestBase {
@@ skipping 16 matching lines @@
   }
 
  protected:
   // FileManagerBrowserTestBase overrides.
   virtual void CreateTestFile(const std::string& name,
                               int64 length,
                               const std::string& modification_time) OVERRIDE;
   virtual void CreateTestDirectory(
       const std::string& name,
       const std::string& modification_time) OVERRIDE;
+  virtual base::FilePath GetRootPath() OVERRIDE;
+  virtual bool PathExists(const base::FilePath& file_path) OVERRIDE;
+  virtual bool WaitUntilFilePresentWithSize(const base::FilePath& file_path,
+                                            int64 file_size) OVERRIDE;
+  virtual bool WaitUntilFileNotPresent(const base::FilePath& file_path)
+      OVERRIDE;
 
   // Notifies DriveFileSystem that the contents in FakeDriveService are
   // changed, hence the new contents should be fetched.
   void CheckForUpdates();
 
   // DriveSystemService factory function for this test.
   drive::DriveSystemService* CreateDriveSystemService(Profile* profile);
 
   base::ScopedTempDir test_cache_root_;
   google_apis::FakeDriveService* fake_drive_service_;
@@ skipping 52 matching lines @@
       time,
       google_apis::test_util::CreateCopyResultCallback(&error,
                                                        &resource_entry));
   MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(google_apis::HTTP_SUCCESS, error);
   ASSERT_TRUE(resource_entry);
 
   CheckForUpdates();
 }
 
+base::FilePath FileManagerBrowserDriveTest::GetRootPath() {
+  return base::FilePath(drive::util::kDriveMyDriveRootPath);
+}
+
+bool FileManagerBrowserDriveTest::PathExists(const base::FilePath& file_path) {
+  // TODO(satorux): Implement this. crbug.com/224534
+  return true;
+}
+
+bool FileManagerBrowserDriveTest::WaitUntilFilePresentWithSize(
+    const base::FilePath& file_path,
+    int64 file_size) {
+  // TODO(satorux): Implement this. crbug.com/224534
+  return true;
+}
+
+bool FileManagerBrowserDriveTest::WaitUntilFileNotPresent(
+    const base::FilePath& file_path) {
+  // TODO(satorux): Implement this. crbug.com/224534
+  return true;
+}
+
 void FileManagerBrowserDriveTest::CheckForUpdates() {
   if (system_service_ && system_service_->file_system()) {
     system_service_->file_system()->CheckForUpdates();
   }
 }
 
 drive::DriveSystemService*
 FileManagerBrowserDriveTest::CreateDriveSystemService(Profile* profile) {
   fake_drive_service_ = new google_apis::FakeDriveService;
   fake_drive_service_->LoadResourceListForWapi(
       "chromeos/gdata/empty_feed.json");
   fake_drive_service_->LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json");
   fake_drive_service_->LoadAppListForDriveApi("chromeos/drive/applist.json");
 
   // Create test files and directories inside the fake drive service.
   CreateTestFilesAndDirectories();
 
   system_service_ = new drive::DriveSystemService(profile,
                                                   fake_drive_service_,
                                                   test_cache_root_.path(),
                                                   NULL);
 
   return system_service_;
 }
 
-// Monitors changes to a single file until the supplied condition callback
-// returns true. Usage:
-//   TestFilePathWatcher watcher(path_to_file, MyConditionCallback);
-//   watcher.StartAndWaitUntilReady();
-//   ... trigger filesystem modification ...
-//   watcher.RunMessageLoopUntilConditionSatisfied();
-class TestFilePathWatcher {
- public:
-  typedef base::Callback<bool(const base::FilePath& file_path)>
-      ConditionCallback;
-
-  // Stores the supplied |path| and |condition| for later use (no side effects).
-  TestFilePathWatcher(const base::FilePath& path,
-                      const ConditionCallback& condition);
-
-  // Waits (running a message pump) until the callback returns true or
-  // FilePathWatcher reports an error. Return true on success.
-  bool RunMessageLoopUntilConditionSatisfied();
-
- private:
-  // Starts the FilePathWatcher to watch the target file. Also check if the
-  // condition is already met.
-  void StartWatching();
-
-  // FilePathWatcher callback (on the FILE thread). Posts Done() to the UI
-  // thread when the condition is satisfied or there is an error.
-  void FilePathWatcherCallback(const base::FilePath& path, bool error);
-
-  const base::FilePath path_;
-  ConditionCallback condition_;
-  scoped_ptr<base::FilePathWatcher> watcher_;
-  base::RunLoop run_loop_;
-  base::Closure quit_closure_;
-  bool failed_;
-};
-
-TestFilePathWatcher::TestFilePathWatcher(const base::FilePath& path,
-                                         const ConditionCallback& condition)
-    : path_(path),
-      condition_(condition),
-      quit_closure_(run_loop_.QuitClosure()),
-      failed_(false) {
-}
-
-void TestFilePathWatcher::StartWatching() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-
-  watcher_.reset(new base::FilePathWatcher);
-  bool ok = watcher_->Watch(
-      path_, false /*recursive*/,
-      base::Bind(&TestFilePathWatcher::FilePathWatcherCallback,
-                 base::Unretained(this)));
-  DCHECK(ok);
-
-  // If the condition was already met before FilePathWatcher was launched,
-  // FilePathWatcher won't be able to detect a change, so check the condition
-  // here.
-  if (condition_.Run(path_)) {
-    watcher_.reset();
-    content::BrowserThread::PostTask(content::BrowserThread::UI,
-                                     FROM_HERE,
-                                     quit_closure_);
-    return;
-  }
-}
-
-void TestFilePathWatcher::FilePathWatcherCallback(const base::FilePath& path,
-                                                  bool failed) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  DCHECK_EQ(path_.value(), path.value());
-
-  if (failed || condition_.Run(path)) {
-    failed_ = failed;
-    watcher_.reset();
-    content::BrowserThread::PostTask(content::BrowserThread::UI,
-                                     FROM_HERE,
-                                     quit_closure_);
-  }
-}
-
-bool TestFilePathWatcher::RunMessageLoopUntilConditionSatisfied() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&TestFilePathWatcher::StartWatching,
-                 base::Unretained(this)));
-
-  // Wait until the condition is met.
-  run_loop_.Run();
-  return !failed_;
-}
-
-// Returns true if a file with the given size is present at |path|.
-bool FilePresentWithSize(const int64 file_size,
-                         const base::FilePath& path) {
-  int64 copy_size = 0;
-  // If the file doesn't exist yet this will fail and we'll keep waiting.
-  if (!file_util::GetFileSize(path, &copy_size))
-    return false;
-  return (copy_size == file_size);
-}
-
-// Returns true if a file is not present at |path|.
-bool FileNotPresent(const base::FilePath& path) {
-  return !file_util::PathExists(path);
-};
-
 IN_PROC_BROWSER_TEST_P(FileManagerBrowserLocalTest, TestFileDisplay) {
   AddMountPointToFakeDownloads();
   StartFileManager("/Downloads");
 
   DoTestFileDisplay();
 }
 
 IN_PROC_BROWSER_TEST_P(FileManagerBrowserLocalTest, TestKeyboardCopy) {
   AddMountPointToFakeDownloads();
   StartFileManager("/Downloads");
 
   base::FilePath copy_path =
-      downloads_path_.AppendASCII(kKeyboardTestFileCopyName);
-  ASSERT_FALSE(file_util::PathExists(copy_path));
+      GetRootPath().AppendASCII(kKeyboardTestFileCopyName);
+  ASSERT_FALSE(PathExists(copy_path));
 
   ResultCatcher catcher;
   StartTest("keyboard copy");
 
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 
-  TestFilePathWatcher watcher(
-      copy_path,
-      base::Bind(FilePresentWithSize, kKeyboardTestFileSize));
-  ASSERT_TRUE(watcher.RunMessageLoopUntilConditionSatisfied());
+  ASSERT_TRUE(WaitUntilFilePresentWithSize(copy_path, kKeyboardTestFileSize));
 
   // Check that it was a copy, not a move.
   base::FilePath source_path =
-      downloads_path_.AppendASCII(kKeyboardTestFileName);
-  ASSERT_TRUE(file_util::PathExists(source_path));
+      GetRootPath().AppendASCII(kKeyboardTestFileName);
+  ASSERT_TRUE(PathExists(source_path));
 }
 
 IN_PROC_BROWSER_TEST_P(FileManagerBrowserLocalTest, TestKeyboardDelete) {
   AddMountPointToFakeDownloads();
   StartFileManager("/Downloads");
 
   base::FilePath delete_path =
-      downloads_path_.AppendASCII(kKeyboardTestFileName);
-  ASSERT_TRUE(file_util::PathExists(delete_path));
+      GetRootPath().AppendASCII(kKeyboardTestFileName);
+  ASSERT_TRUE(PathExists(delete_path));
 
   ResultCatcher catcher;
   StartTest("keyboard delete");
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 
-  TestFilePathWatcher watcher(delete_path,
-                              base::Bind(FileNotPresent));
-  ASSERT_TRUE(watcher.RunMessageLoopUntilConditionSatisfied());
+  ASSERT_TRUE(WaitUntilFileNotPresent(delete_path));
 }
 
 IN_PROC_BROWSER_TEST_F(FileManagerBrowserDriveTest, TestFileDisplay) {
   StartFileManager("/drive/root");
 
   DoTestFileDisplay();
 }
 
 }  // namespace