Move storage-related files from webkit/ to new top-level directory storage/

content/browser/fileapi/recursive_operation_delegate_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/recursive_operation_delegate.h"
+#include "storage/browser/fileapi/recursive_operation_delegate.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "content/public/test/sandbox_file_system_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/browser/fileapi/file_system_file_util.h"
-#include "webkit/browser/fileapi/file_system_operation.h"
-#include "webkit/browser/fileapi/file_system_operation_runner.h"
+#include "storage/browser/fileapi/file_system_file_util.h"
+#include "storage/browser/fileapi/file_system_operation.h"
+#include "storage/browser/fileapi/file_system_operation_runner.h"
 
-using fileapi::FileSystemContext;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
+using storage::FileSystemContext;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
 
 namespace content {
 namespace {
 
-class LoggingRecursiveOperation : public fileapi::RecursiveOperationDelegate {
+class LoggingRecursiveOperation : public storage::RecursiveOperationDelegate {
  public:
   struct LogEntry {
     enum Type {
       PROCESS_FILE,
       PROCESS_DIRECTORY,
       POST_PROCESS_DIRECTORY
     };
     Type type;
     FileSystemURL url;
   };
 
   LoggingRecursiveOperation(FileSystemContext* file_system_context,
                             const FileSystemURL& root,
                             const StatusCallback& callback)
-      : fileapi::RecursiveOperationDelegate(file_system_context),
+      : storage::RecursiveOperationDelegate(file_system_context),
         root_(root),
         callback_(callback),
-        weak_factory_(this) {
-  }
+        weak_factory_(this) {}
   virtual ~LoggingRecursiveOperation() {}
 
   const std::vector<LogEntry>& log_entries() const { return log_entries_; }
 
   // RecursiveOperationDelegate overrides.
   virtual void Run() OVERRIDE {
     NOTREACHED();
   }
 
   virtual void RunRecursively() OVERRIDE {
@@ skipping 51 matching lines @@
 };
 
 void ReportStatus(base::File::Error* out_error,
                   base::File::Error error) {
   DCHECK(out_error);
   *out_error = error;
 }
 
 // To test the Cancel() during operation, calls Cancel() of |operation|
 // after |counter| times message posting.
-void CallCancelLater(fileapi::RecursiveOperationDelegate* operation,
+void CallCancelLater(storage::RecursiveOperationDelegate* operation,
                      int counter) {
   if (counter > 0) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(&CallCancelLater, base::Unretained(operation), counter - 1));
     return;
   }
 
   operation->Cancel();
 }
@@ skipping 12 matching lines @@
   }
 
   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);
   }
 
-  fileapi::FileSystemFileUtil* file_util() {
+  storage::FileSystemFileUtil* file_util() {
     return sandbox_file_system_.file_util();
   }
 
   FileSystemURL URLForPath(const std::string& path) const {
     return sandbox_file_system_.CreateURLFromUTF8(path);
   }
 
   FileSystemURL CreateFile(const std::string& path) {
     FileSystemURL url = URLForPath(path);
     bool created = false;
@@ skipping 112 matching lines @@
           base::Bind(&ReportStatus, &error)));
   operation->RunRecursively();
 
   // Invoke Cancel(), after 5 times message posting.
   CallCancelLater(operation.get(), 5);
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(base::File::FILE_ERROR_ABORT, error);
 }
 
 }  // namespace content