Cleanup FileSystemOperation for preparing for adding FSO-factory method

webkit/fileapi/file_system_mount_point_provider_unittest.cc

 // Copyright (c) 2012 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 <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 205 matching lines @@
 class FileSystemMountPointProviderTest : public testing::Test {
  public:
   FileSystemMountPointProviderTest()
       : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     root_path_callback_status_ = false;
     root_path_.clear();
-    file_system_name_.clear();
     special_storage_policy_ = new quota::MockSpecialStoragePolicy;
   }
 
  protected:
   void SetupNewContext(const FileSystemOptions& options) {
     file_system_context_ = new FileSystemContext(
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
         special_storage_policy_,
         NULL,
         data_dir_.path(),
         options);
 #if defined(OS_CHROMEOS)
     fileapi::ExternalFileSystemMountPointProvider* ext_provider =
         file_system_context_->external_provider();
     ext_provider->AddMountPoint(FilePath("/tmp/testing"));
 #endif
   }
 
   FileSystemMountPointProvider* provider(FileSystemType type) {
     DCHECK(file_system_context_);
     return file_system_context_->GetMountPointProvider(type);
   }
 
-  void OnGetRootPath(bool success,
-                     const FilePath& root_path,
-                     const std::string& name) {
-    root_path_callback_status_ = success;
-    root_path_ = root_path;
-    file_system_name_ = name;
-  }
-
   bool GetRootPath(const GURL& origin_url,
                    fileapi::FileSystemType type,
                    bool create,
                    FilePath* root_path) {
-    provider(type)->ValidateFileSystemRootAndGetURL(
-        origin_url, type, create,
-        base::Bind(&FileSystemMountPointProviderTest::OnGetRootPath,
-                   weak_factory_.GetWeakPtr()));
-    MessageLoop::current()->RunAllPending();
+    root_path_ = provider(type)->GetFileSystemRootPathOnFileThread(
+        origin_url, type, FilePath(), create);
     if (root_path)
       *root_path = root_path_;
-    return root_path_callback_status_;
+    return !root_path_.empty();
   }
 
   FilePath data_path() { return data_dir_.path(); }
   FilePath file_system_path() {
     return data_dir_.path().Append(
         SandboxMountPointProvider::kNewFileSystemDirectory);
   }
   FilePath external_file_system_path() {
     return FilePath::FromUTF8Unsafe(fileapi::kExternalDir);
   }
   FilePath external_file_path_root() {
     return FilePath::FromUTF8Unsafe("/tmp");
   }
 
  private:
   ScopedTempDir data_dir_;
   base::WeakPtrFactory<FileSystemMountPointProviderTest> weak_factory_;
 
   bool root_path_callback_status_;
   FilePath root_path_;
-  std::string file_system_name_;
 
   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
   scoped_refptr<FileSystemContext> file_system_context_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemMountPointProviderTest);
 };
 
 TEST_F(FileSystemMountPointProviderTest, GetRootPathCreateAndExamine) {
   std::vector<FilePath> returned_root_path(
       ARRAYSIZE_UNSAFE(kRootPathTestCases));
@@ skipping 147 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kIsRestrictedNameTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "IsRestrictedName #" << i << " "
                  << kIsRestrictedNameTestCases[i].name);
     FilePath name(kIsRestrictedNameTestCases[i].name);
     EXPECT_EQ(kIsRestrictedNameTestCases[i].expected_dangerous,
               provider(kFileSystemTypeTemporary)->IsRestrictedFileName(name));
   }
 }
 
 }  // namespace fileapi