Fully qualify all references to fileapi::FileSystemType

content/browser/fileapi/obfuscated_file_util_unittest.cc

 // Copyright 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.
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 20 matching lines @@
 #include "webkit/browser/fileapi/sandbox_isolated_origin_database.h"
 #include "webkit/browser/fileapi/sandbox_origin_database.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/database/database_identifier.h"
 #include "webkit/common/quota/quota_types.h"
 
 using content::AsyncFileTestHelper;
 using fileapi::FileSystemContext;
 using fileapi::FileSystemOperation;
 using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemType;
 using fileapi::FileSystemURL;
 using fileapi::ObfuscatedFileUtil;
 using fileapi::SandboxDirectoryDatabase;
 using fileapi::SandboxIsolatedOriginDatabase;
 using fileapi::kFileSystemTypeTemporary;
 using fileapi::kFileSystemTypePersistent;
 
 namespace content {
 
 namespace {
@@ skipping 67 matching lines @@
       url.mount_type(),
       url.virtual_path().Append(base::FilePath::FromUTF8Unsafe(child)));
 }
 
 FileSystemURL FileSystemURLDirName(const FileSystemURL& url) {
   return FileSystemURL::CreateForTest(
       url.origin(), url.mount_type(),
       fileapi::VirtualPath::DirName(url.virtual_path()));
 }
 
-std::string GetTypeString(FileSystemType type) {
+std::string GetTypeString(fileapi::FileSystemType type) {
   return fileapi::SandboxFileSystemBackendDelegate::GetTypeString(type);
 }
 
-bool HasFileSystemType(
-    ObfuscatedFileUtil::AbstractOriginEnumerator* enumerator,
-    FileSystemType type) {
+bool HasFileSystemType(ObfuscatedFileUtil::AbstractOriginEnumerator* enumerator,
+                       fileapi::FileSystemType type) {
   return enumerator->HasTypeDirectory(GetTypeString(type));
 }
 
 }  // namespace
 
 // TODO(ericu): The vast majority of this and the other FSFU subclass tests
 // could theoretically be shared.  It would basically be a FSFU interface
 // compliance test, and only the subclass-specific bits that look into the
 // implementation would need to be written per-subclass.
 class ObfuscatedFileUtilTest : public testing::Test {
@@ skipping 2303 matching lines @@
                                    false /* exclusive */,
                                    true /* recursive */));
   ASSERT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY,
             ofu()->CreateDirectory(UnlimitedContext().get(),
                                    path_in_file_in_file,
                                    false /* exclusive */,
                                    true /* recursive */));
 }
 
 }  // namespace content