Fully qualify all references to fileapi::FileSystemType

content/public/test/test_file_system_backend.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 "content/public/test/test_file_system_backend.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/sequenced_task_runner.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/file_observers.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_quota_util.h"
 #include "webkit/browser/fileapi/local_file_util.h"
 #include "webkit/browser/fileapi/native_file_util.h"
 #include "webkit/browser/fileapi/quota/quota_reservation.h"
 #include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using fileapi::FileSystemContext;
 using fileapi::FileSystemOperation;
 using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemType;
 using fileapi::FileSystemURL;
 
 namespace content {
 
 namespace {
 
 class TestFileUtil : public fileapi::LocalFileUtil {
  public:
   explicit TestFileUtil(const base::FilePath& base_path)
       : base_path_(base_path) {}
@@ skipping 24 matching lines @@
         task_runner_(task_runner) {
     update_observers_ = update_observers_.AddObserver(this, task_runner_.get());
   }
   virtual ~QuotaUtil() {}
 
   // FileSystemQuotaUtil overrides.
   virtual base::File::Error DeleteOriginDataOnFileTaskRunner(
       FileSystemContext* context,
       quota::QuotaManagerProxy* proxy,
       const GURL& origin_url,
-      FileSystemType type) OVERRIDE {
+      fileapi::FileSystemType type) OVERRIDE {
     NOTREACHED();
     return base::File::FILE_OK;
   }
 
   virtual scoped_refptr<fileapi::QuotaReservation>
-      CreateQuotaReservationOnFileTaskRunner(
-          const GURL& origin_url,
-          FileSystemType type) OVERRIDE {
+  CreateQuotaReservationOnFileTaskRunner(
+      const GURL& origin_url,
+      fileapi::FileSystemType type) OVERRIDE {
     NOTREACHED();
     return scoped_refptr<fileapi::QuotaReservation>();
   }
 
   virtual void GetOriginsForTypeOnFileTaskRunner(
-      FileSystemType type,
+      fileapi::FileSystemType type,
       std::set<GURL>* origins) OVERRIDE {
     NOTREACHED();
   }
 
   virtual void GetOriginsForHostOnFileTaskRunner(
-      FileSystemType type,
+      fileapi::FileSystemType type,
       const std::string& host,
       std::set<GURL>* origins) OVERRIDE {
     NOTREACHED();
   }
 
   virtual int64 GetOriginUsageOnFileTaskRunner(
       FileSystemContext* context,
       const GURL& origin_url,
-      FileSystemType type) OVERRIDE {
+      fileapi::FileSystemType type) OVERRIDE {
     return usage_;
   }
 
   virtual void AddFileUpdateObserver(
-      FileSystemType type,
+      fileapi::FileSystemType type,
       FileUpdateObserver* observer,
       base::SequencedTaskRunner* task_runner) OVERRIDE {
     NOTIMPLEMENTED();
   }
 
   virtual void AddFileChangeObserver(
-      FileSystemType type,
+      fileapi::FileSystemType type,
       fileapi::FileChangeObserver* observer,
       base::SequencedTaskRunner* task_runner) OVERRIDE {
     change_observers_ = change_observers_.AddObserver(observer, task_runner);
   }
 
   virtual void AddFileAccessObserver(
-      FileSystemType type,
+      fileapi::FileSystemType type,
       fileapi::FileAccessObserver* observer,
       base::SequencedTaskRunner* task_runner) OVERRIDE {
     NOTIMPLEMENTED();
   }
 
   virtual const fileapi::UpdateObserverList* GetUpdateObservers(
-      FileSystemType type) const OVERRIDE {
+      fileapi::FileSystemType type) const OVERRIDE {
     return &update_observers_;
   }
 
   virtual const fileapi::ChangeObserverList* GetChangeObservers(
-      FileSystemType type) const OVERRIDE {
+      fileapi::FileSystemType type) const OVERRIDE {
     return &change_observers_;
   }
 
   virtual const fileapi::AccessObserverList* GetAccessObservers(
-      FileSystemType type) const OVERRIDE {
+      fileapi::FileSystemType type) const OVERRIDE {
     return NULL;
   }
 
   // FileUpdateObserver overrides.
   virtual void OnStartUpdate(const FileSystemURL& url) OVERRIDE {}
   virtual void OnUpdate(const FileSystemURL& url, int64 delta) OVERRIDE {
     usage_ += delta;
   }
   virtual void OnEndUpdate(const FileSystemURL& url) OVERRIDE {}
 
@@ skipping 14 matching lines @@
     : base_path_(base_path),
       file_util_(
           new fileapi::AsyncFileUtilAdapter(new TestFileUtil(base_path))),
       quota_util_(new QuotaUtil(task_runner)),
       require_copy_or_move_validator_(false) {
 }
 
 TestFileSystemBackend::~TestFileSystemBackend() {
 }
 
-bool TestFileSystemBackend::CanHandleType(FileSystemType type) const {
+bool TestFileSystemBackend::CanHandleType(fileapi::FileSystemType type) const {
   return (type == fileapi::kFileSystemTypeTest);
 }
 
 void TestFileSystemBackend::Initialize(FileSystemContext* context) {
 }
 
 void TestFileSystemBackend::ResolveURL(const FileSystemURL& url,
                                        fileapi::OpenFileSystemMode mode,
                                        const OpenFileSystemCallback& callback) {
   callback.Run(GetFileSystemRootURI(url.origin(), url.type()),
                GetFileSystemName(url.origin(), url.type()),
                base::File::FILE_OK);
 }
 
 fileapi::AsyncFileUtil* TestFileSystemBackend::GetAsyncFileUtil(
-    FileSystemType type) {
+    fileapi::FileSystemType type) {
   return file_util_.get();
 }
 
 fileapi::CopyOrMoveFileValidatorFactory*
 TestFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
-    FileSystemType type, base::File::Error* error_code) {
+    fileapi::FileSystemType type,
+    base::File::Error* error_code) {
   DCHECK(error_code);
   *error_code = base::File::FILE_OK;
   if (require_copy_or_move_validator_) {
     if (!copy_or_move_file_validator_factory_)
       *error_code = base::File::FILE_ERROR_SECURITY;
     return copy_or_move_file_validator_factory_.get();
   }
   return NULL;
 }
 
@@ skipping 39 matching lines @@
   return scoped_ptr<fileapi::FileStreamWriter>(
       new fileapi::SandboxFileStreamWriter(context, url, offset,
                                            *GetUpdateObservers(url.type())));
 }
 
 fileapi::FileSystemQuotaUtil* TestFileSystemBackend::GetQuotaUtil() {
   return quota_util_.get();
 }
 
 const fileapi::UpdateObserverList* TestFileSystemBackend::GetUpdateObservers(
-    FileSystemType type) const {
+    fileapi::FileSystemType type) const {
   return quota_util_->GetUpdateObservers(type);
 }
 
 void TestFileSystemBackend::AddFileChangeObserver(
     fileapi::FileChangeObserver* observer) {
   quota_util_->AddFileChangeObserver(
       fileapi::kFileSystemTypeTest, observer, quota_util_->task_runner());
 }
 
 }  // namespace content