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

content/child/fileapi/webfilesystem_impl.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/child/fileapi/webfilesystem_impl.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_local.h"
 #include "content/child/child_thread.h"
 #include "content/child/file_info_util.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/fileapi/webfilewriter_impl.h"
 #include "content/child/worker_task_runner.h"
 #include "content/common/fileapi/file_system_messages.h"
 #include "third_party/WebKit/public/platform/WebFileInfo.h"
 #include "third_party/WebKit/public/platform/WebFileSystemCallbacks.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 #include "url/gurl.h"
-#include "webkit/common/fileapi/directory_entry.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/common/fileapi/directory_entry.h"
+#include "storage/common/fileapi/file_system_util.h"
 
 using blink::WebFileInfo;
 using blink::WebFileSystemCallbacks;
 using blink::WebFileSystemEntry;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebVector;
 
 namespace content {
 
@@ skipping 95 matching lines @@
   callbacks->didSucceed();
 }
 
 void DidReadMetadata(const base::File::Info& file_info,
                      WebFileSystemCallbacks* callbacks) {
   WebFileInfo web_file_info;
   FileInfoToWebFileInfo(file_info, &web_file_info);
   callbacks->didReadMetadata(web_file_info);
 }
 
-void DidReadDirectory(const std::vector<fileapi::DirectoryEntry>& entries,
-                      bool has_more, WebFileSystemCallbacks* callbacks) {
+void DidReadDirectory(const std::vector<storage::DirectoryEntry>& entries,
+                      bool has_more,
+                      WebFileSystemCallbacks* callbacks) {
   WebVector<WebFileSystemEntry> file_system_entries(entries.size());
   for (size_t i = 0; i < entries.size(); ++i) {
     file_system_entries[i].name =
         base::FilePath(entries[i].name).AsUTF16Unsafe();
     file_system_entries[i].isDirectory = entries[i].is_directory;
   }
   callbacks->didReadDirectory(file_system_entries, has_more);
 }
 
 void DidOpenFileSystem(const base::string16& name, const GURL& root,
                        WebFileSystemCallbacks* callbacks) {
   callbacks->didOpenFileSystem(name, root);
 }
 
-void DidResolveURL(
-    const base::string16& name,
-    const GURL& root_url,
-    fileapi::FileSystemType mount_type,
-    const base::string16& file_path,
-    bool is_directory,
-    WebFileSystemCallbacks* callbacks) {
+void DidResolveURL(const base::string16& name,
+                   const GURL& root_url,
+                   storage::FileSystemType mount_type,
+                   const base::string16& file_path,
+                   bool is_directory,
+                   WebFileSystemCallbacks* callbacks) {
   callbacks->didResolveURL(
       name,
       root_url,
       static_cast<blink::WebFileSystemType>(mount_type),
       file_path,
       is_directory);
 }
 
 void DidFail(base::File::Error error, WebFileSystemCallbacks* callbacks) {
-  callbacks->didFail(fileapi::FileErrorToWebFileError(error));
+  callbacks->didFail(storage::FileErrorToWebFileError(error));
 }
 
 // Run WebFileSystemCallbacks's |method| with |params|.
 void RunCallbacks(
     int callbacks_id,
     const base::Callback<void(WebFileSystemCallbacks*)>& callback,
     CallbacksUnregisterMode callbacks_unregister_mode) {
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
@@ skipping 43 matching lines @@
 void OpenFileSystemCallbackAdapter(
     int thread_id, int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const std::string& name, const GURL& root) {
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       base::Bind(&DidOpenFileSystem, base::UTF8ToUTF16(name), root),
       UNREGISTER_CALLBACKS);
 }
 
-void ResolveURLCallbackAdapter(
-    int thread_id, int callbacks_id,
-    WaitableCallbackResults* waitable_results,
-    const fileapi::FileSystemInfo& info,
-    const base::FilePath& file_path, bool is_directory) {
+void ResolveURLCallbackAdapter(int thread_id,
+                               int callbacks_id,
+                               WaitableCallbackResults* waitable_results,
+                               const storage::FileSystemInfo& info,
+                               const base::FilePath& file_path,
+                               bool is_directory) {
   base::FilePath normalized_path(
-      fileapi::VirtualPath::GetNormalizedFilePath(file_path));
+      storage::VirtualPath::GetNormalizedFilePath(file_path));
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       base::Bind(&DidResolveURL, base::UTF8ToUTF16(info.name), info.root_url,
                  info.mount_type,
                  normalized_path.AsUTF16Unsafe(), is_directory),
       UNREGISTER_CALLBACKS);
 }
 
 void StatusCallbackAdapter(int thread_id, int callbacks_id,
                            WaitableCallbackResults* waitable_results,
@@ skipping 14 matching lines @@
 void ReadMetadataCallbackAdapter(int thread_id, int callbacks_id,
                                  WaitableCallbackResults* waitable_results,
                                  const base::File::Info& file_info) {
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       base::Bind(&DidReadMetadata, file_info),
       UNREGISTER_CALLBACKS);
 }
 
 void ReadDirectoryCallbackAdapter(
-    int thread_id, int callbacks_id, WaitableCallbackResults* waitable_results,
-    const std::vector<fileapi::DirectoryEntry>& entries,
+    int thread_id,
+    int callbacks_id,
+    WaitableCallbackResults* waitable_results,
+    const std::vector<storage::DirectoryEntry>& entries,
     bool has_more) {
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       base::Bind(&DidReadDirectory, entries, has_more),
       has_more ? DO_NOT_UNREGISTER_CALLBACKS : UNREGISTER_CALLBACKS);
 }
 
 void DidCreateFileWriter(
     int callbacks_id,
     const GURL& path,
@@ skipping 111 matching lines @@
     const blink::WebURL& storage_partition,
     blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::OpenFileSystem,
       MakeTuple(GURL(storage_partition),
-                static_cast<fileapi::FileSystemType>(type),
+                static_cast<storage::FileSystemType>(type),
                 base::Bind(&OpenFileSystemCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results),
+                           CurrentWorkerId(),
+                           callbacks_id,
+                           waitable_results),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           CurrentWorkerId(),
+                           callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::resolveURL(
     const blink::WebURL& filesystem_url,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
@@ skipping 11 matching lines @@
     const blink::WebURL& storage_partition,
     blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::DeleteFileSystem,
       MakeTuple(GURL(storage_partition),
-                static_cast<fileapi::FileSystemType>(type),
+                static_cast<storage::FileSystemType>(type),
                 base::Bind(&StatusCallbackAdapter,
-                           CurrentWorkerId(), callbacks_id, waitable_results)),
+                           CurrentWorkerId(),
+                           callbacks_id,
+                           waitable_results)),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::move(
     const blink::WebURL& src_path,
     const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
@@ skipping 223 matching lines @@
 WaitableCallbackResults* WebFileSystemImpl::MaybeCreateWaitableResults(
     const WebFileSystemCallbacks& callbacks, int callbacks_id) {
   if (!callbacks.shouldBlockUntilCompletion())
     return NULL;
   WaitableCallbackResults* results = new WaitableCallbackResults();
   waitable_results_[callbacks_id] = results;
   return results;
 }
 
 }  // namespace content