Cleanup FileSystemOperation for preparing for adding FSO-factory method

chrome/browser/browsing_data_file_system_helper_unittest.cc

 // Copyright (c) 2011 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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
+#include "base/platform_file.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browsing_data_file_system_helper.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/test/test_browser_thread.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 
@@ skipping 50 matching lines @@
     MessageLoop::current()->Run();
   }
 
   // Unblocks the current MessageLoop. Should be called in response to some sort
   // of async activity in a callback method.
   void Notify() {
     MessageLoop::current()->Quit();
   }
 
   // Callback that should be executed in response to
-  // fileapi::SandboxMountPointProvider::ValidateFileSystemRootAndGetURL
-  void CallbackFindFileSystemPath(bool success,
-                                  const FilePath& path,
-                                  const std::string& name) {
-    found_file_system_ = success;
+  // fileapi::SandboxMountPointProvider::ValidateFileSystemRoot
+  void ValidateFileSystemCallback(base::PlatformFileError error) {
+    validate_file_system_result_ = error;
     Notify();
   }
 
   // Calls fileapi::SandboxMountPointProvider::ValidateFileSystemRootAndGetURL
   // to verify the existence of a file system for a specified type and origin,
   // blocks until a response is available, then returns the result
   // synchronously to it's caller.
   bool FileSystemContainsOriginAndType(const GURL& origin,
                                        fileapi::FileSystemType type) {
-    sandbox_->ValidateFileSystemRootAndGetURL(
+    sandbox_->ValidateFileSystemRoot(
         origin, type, false,
         base::Bind(
-            &BrowsingDataFileSystemHelperTest::CallbackFindFileSystemPath,
+            &BrowsingDataFileSystemHelperTest::ValidateFileSystemCallback,
             base::Unretained(this)));
     BlockUntilNotified();
-    return found_file_system_;
+    return validate_file_system_result_ == base::PLATFORM_FILE_OK;
   }
 
   // Callback that should be executed in response to StartFetching(), and stores
   // found file systems locally so that they are available via GetFileSystems().
   void CallbackStartFetching(
       const std::list<BrowsingDataFileSystemHelper::FileSystemInfo>&
           file_system_info_list) {
     file_system_info_list_.reset(
         new std::list<BrowsingDataFileSystemHelper::FileSystemInfo>(
             file_system_info_list));
@@ skipping 33 matching lines @@
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin2, kPersistent));
     EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin2, kTemporary));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3, kPersistent));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3, kTemporary));
   }
 
   // Uses the fileapi methods to create a filesystem of a given type for a
   // specified origin.
   void CreateDirectoryForOriginAndType(const GURL& origin,
                                        fileapi::FileSystemType type) {
-    FilePath target = sandbox_->ValidateFileSystemRootAndGetPathOnFileThread(
+    FilePath target = sandbox_->GetFileSystemRootPathOnFileThread(
         origin, type, FilePath(), true);
     EXPECT_TRUE(file_util::DirectoryExists(target));
   }
 
   // Returns a list of the FileSystemInfo objects gathered in the most recent
   // call to StartFetching().
   FileSystemInfoList* GetFileSystems() {
     return file_system_info_list_.get();
   }
 
 
   // Temporary storage to pass information back from callbacks.
-  bool found_file_system_;
+  base::PlatformFileError validate_file_system_result_;
   ScopedFileSystemInfoList file_system_info_list_;
 
   scoped_refptr<BrowsingDataFileSystemHelper> helper_;
   scoped_refptr<CannedBrowsingDataFileSystemHelper> canned_helper_;
 
  private:
   // message_loop_, as well as all the threads associated with it must be
   // defined before profile_ to prevent explosions. The threads also must be
   // defined in the order they're listed here. Oh how I love C++.
   MessageLoopForUI message_loop_;
@@ skipping 101 matching lines @@
 
   info++;
   EXPECT_EQ(kOrigin2, info->origin);
   EXPECT_FALSE(info->has_persistent);
   EXPECT_TRUE(info->has_temporary);
   EXPECT_EQ(0, info->usage_persistent);
   EXPECT_EQ(100, info->usage_temporary);
 }
 
 }  // namespace