Fully qualify all references to fileapi::FileSystemType

content/browser/fileapi/file_system_context_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 "webkit/browser/fileapi/file_system_context.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/quota/mock_quota_manager.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "content/public/test/test_file_system_options.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 
 #define FPL(x) FILE_PATH_LITERAL(x)
 
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
 #define DRIVE FPL("C:")
 #else
 #define DRIVE
 #endif
 
 using fileapi::ExternalMountPoints;
 using fileapi::FileSystemBackend;
 using fileapi::FileSystemContext;
 using fileapi::FileSystemMountOption;
-using fileapi::FileSystemType;
 using fileapi::FileSystemURL;
 using fileapi::IsolatedContext;
 
 namespace content {
 
 namespace {
 
 const char kTestOrigin[] = "http://chromium.org/";
 
 GURL CreateRawFileSystemURL(const std::string& type_str,
@@ skipping 33 matching lines @@
         mock_quota_manager_->proxy(),
         ScopedVector<FileSystemBackend>(),
         std::vector<fileapi::URLRequestAutoMountHandler>(),
         data_dir_.path(),
         CreateAllowFileAccessOptions());
   }
 
   // Verifies a *valid* filesystem url has expected values.
   void ExpectFileSystemURLMatches(const FileSystemURL& url,
                                   const GURL& expect_origin,
-                                  FileSystemType expect_mount_type,
-                                  FileSystemType expect_type,
+                                  fileapi::FileSystemType expect_mount_type,
+                                  fileapi::FileSystemType expect_type,
                                   const base::FilePath& expect_path,
                                   const base::FilePath& expect_virtual_path,
                                   const std::string& expect_filesystem_id) {
     EXPECT_TRUE(url.is_valid());
 
     EXPECT_EQ(expect_origin, url.origin());
     EXPECT_EQ(expect_mount_type, url.mount_type());
     EXPECT_EQ(expect_type, url.type());
     EXPECT_EQ(expect_path, url.path());
     EXPECT_EQ(expect_virtual_path, url.virtual_path());
@@ skipping 139 matching lines @@
   const GURL kTestOrigin = GURL("http://chromium.org/");
   const base::FilePath kVirtualPathNoRoot = base::FilePath(FPL("root/file"));
 
   struct TestCase {
     // Test case values.
     std::string root;
     std::string type_str;
 
     // Expected test results.
     bool expect_is_valid;
-    FileSystemType expect_mount_type;
-    FileSystemType expect_type;
+    fileapi::FileSystemType expect_mount_type;
+    fileapi::FileSystemType expect_type;
     const base::FilePath::CharType* expect_path;
     std::string expect_filesystem_id;
   };
 
   const TestCase kTestCases[] = {
       // Following should not be handled by the url crackers:
       {
         "pers_mount", "persistent", true /* is_valid */,
         fileapi::kFileSystemTypePersistent, fileapi::kFileSystemTypePersistent,
         FPL("pers_mount/root/file"),
@@ skipping 120 matching lines @@
   EXPECT_TRUE(context->CanServeURLRequest(cracked_url));
 
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
       kExternalMountName);
   IsolatedContext::GetInstance()->RevokeFileSystem(isolated_fs_id);
 }
 
 }  // namespace
 
 }  // namespace content