Change fileapi namespace to content for files that are moved under content/

content/browser/fileapi/file_system_operation_impl_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_operation_impl.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/test/sandbox_file_system_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/async_file_test_helper.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/mock_file_change_observer.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
 #include "webkit/browser/quota/mock_quota_manager.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
+using fileapi::AsyncFileTestHelper;
+using fileapi::FileSystemOperation;
+using fileapi::FileSystemOperationContext;
+using fileapi::FileSystemOperationRunner;
+using fileapi::FileSystemURL;
 using quota::QuotaManager;
 using quota::QuotaManagerProxy;
 using webkit_blob::ShareableFileReference;
 
-namespace fileapi {
+namespace content {
 
 namespace {
 
 const int kFileOperationStatusNotSet = 1;
 
 void AssertFileErrorEq(const tracked_objects::Location& from_here,
                        base::PlatformFileError expected,
                        base::PlatformFileError actual) {
   ASSERT_EQ(expected, actual) << from_here.ToString();
 }
 
 }  // namespace
 
 // Test class for FileSystemOperationImpl.
 class FileSystemOperationImplTest
     : public testing::Test {
  public:
   FileSystemOperationImplTest()
       : status_(kFileOperationStatusNotSet),
         weak_factory_(this) {}
 
  protected:
   virtual void SetUp() OVERRIDE {
     EXPECT_TRUE(base_.CreateUniqueTempDir());
-    change_observers_ = MockFileChangeObserver::CreateList(&change_observer_);
+    change_observers_ = fileapi::MockFileChangeObserver::CreateList(
+        &change_observer_);
 
     base::FilePath base_dir = base_.path().AppendASCII("filesystem");
     quota_manager_ =
         new quota::MockQuotaManager(false /* is_incognito */,
                                     base_dir,
                                     base::MessageLoopProxy::current().get(),
                                     base::MessageLoopProxy::current().get(),
                                     NULL /* special storage policy */);
     quota_manager_proxy_ = new quota::MockQuotaManagerProxy(
         quota_manager(), base::MessageLoopProxy::current().get());
     sandbox_file_system_.SetUp(base_dir, quota_manager_proxy_.get());
     sandbox_file_system_.AddFileChangeObserver(&change_observer_);
   }
 
   virtual void TearDown() OVERRIDE {
     // Let the client go away before dropping a ref of the quota manager proxy.
     quota_manager_proxy()->SimulateQuotaManagerDestroyed();
     quota_manager_ = NULL;
     quota_manager_proxy_ = NULL;
     sandbox_file_system_.TearDown();
   }
 
   FileSystemOperationRunner* operation_runner() {
     return sandbox_file_system_.operation_runner();
   }
 
   int status() const { return status_; }
   const base::PlatformFileInfo& info() const { return info_; }
   const base::FilePath& path() const { return path_; }
-  const std::vector<DirectoryEntry>& entries() const {
+  const std::vector<fileapi::DirectoryEntry>& entries() const {
     return entries_;
   }
 
   const ShareableFileReference* shareable_file_ref() const {
     return shareable_file_ref_.get();
   }
 
   quota::MockQuotaManager* quota_manager() {
     return static_cast<quota::MockQuotaManager*>(quota_manager_.get());
   }
 
   quota::MockQuotaManagerProxy* quota_manager_proxy() {
     return static_cast<quota::MockQuotaManagerProxy*>(
         quota_manager_proxy_.get());
   }
 
-  FileSystemFileUtil* file_util() {
+  fileapi::FileSystemFileUtil* file_util() {
     return sandbox_file_system_.file_util();
   }
 
-  MockFileChangeObserver* change_observer() {
+  fileapi::MockFileChangeObserver* change_observer() {
     return &change_observer_;
   }
 
   scoped_ptr<FileSystemOperationContext> NewContext() {
     FileSystemOperationContext* context =
         sandbox_file_system_.NewOperationContext();
     // Grant enough quota for all test cases.
     context->set_allowed_bytes_growth(1000000);
     return make_scoped_ptr(context);
   }
@@ skipping 63 matching lines @@
     return base::Bind(&FileSystemOperationImplTest::DidCreateSnapshotFile,
                       weak_factory_.GetWeakPtr());
   }
 
   void DidFinish(base::PlatformFileError status) {
     status_ = status;
   }
 
   void DidReadDirectory(
       base::PlatformFileError status,
-      const std::vector<DirectoryEntry>& entries,
+      const std::vector<fileapi::DirectoryEntry>& entries,
       bool /* has_more */) {
     entries_ = entries;
     status_ = status;
   }
 
   void DidGetMetadata(base::PlatformFileError status,
                       const base::PlatformFileInfo& info) {
     info_ = info;
     status_ = status;
   }
@@ skipping 71 matching lines @@
 
   // Common temp base for nondestructive uses.
   base::ScopedTempDir base_;
 
   SandboxFileSystemTestHelper sandbox_file_system_;
 
   // For post-operation status.
   int status_;
   base::PlatformFileInfo info_;
   base::FilePath path_;
-  std::vector<DirectoryEntry> entries_;
+  std::vector<fileapi::DirectoryEntry> entries_;
   scoped_refptr<ShareableFileReference> shareable_file_ref_;
 
-  MockFileChangeObserver change_observer_;
-  ChangeObserverList change_observers_;
+  fileapi::MockFileChangeObserver change_observer_;
+  fileapi::ChangeObserverList change_observers_;
 
   base::WeakPtrFactory<FileSystemOperationImplTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperationImplTest);
 };
 
 TEST_F(FileSystemOperationImplTest, TestMoveFailureSrcDoesntExist) {
   change_observer()->ResetCount();
   operation_runner()->Move(URLForPath("a"), URLForPath("b"),
                            FileSystemOperation::OPTION_NONE,
@@ skipping 972 matching lines @@
       base::Bind(&AssertFileErrorEq, FROM_HERE, base::PLATFORM_FILE_OK));
   base::RunLoop().RunUntilIdle();
 
   expected_usage += grandchild_file_size + grandchild_path_cost;
   usage = GetUsage();
   EXPECT_EQ(2 * child_file_size + 3 * grandchild_file_size,
             GetDataSizeOnDisk());
   EXPECT_EQ(expected_usage, usage);
 }
 
-}  // namespace fileapi
+}  // namespace content