Rename WebKit namespace to blink (part 3)

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/fileapi/file_system_dispatcher.h"
 #include "content/child/fileapi/webfilewriter_impl.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 "url/gurl.h"
 #include "webkit/child/worker_task_runner.h"
 #include "webkit/common/fileapi/directory_entry.h"
 #include "webkit/common/fileapi/file_system_util.h"
 #include "webkit/glue/webkit_glue.h"
 
-using WebKit::WebFileInfo;
-using WebKit::WebFileSystemCallbacks;
-using WebKit::WebFileSystemEntry;
-using WebKit::WebString;
-using WebKit::WebURL;
-using WebKit::WebVector;
+using blink::WebFileInfo;
+using blink::WebFileSystemCallbacks;
+using blink::WebFileSystemEntry;
+using blink::WebString;
+using blink::WebURL;
+using blink::WebVector;
 using webkit_glue::WorkerTaskRunner;
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<base::ThreadLocalPointer<WebFileSystemImpl> >::Leaky
     g_webfilesystem_tls = LAZY_INSTANCE_INITIALIZER;
 
 class WaitableCallbackResults {
@@ skipping 114 matching lines @@
     int thread_id, int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const fileapi::FileSystemInfo& info,
     const base::FilePath& file_path, bool is_directory) {
   base::FilePath normalized_path(
       fileapi::VirtualPath::GetNormalizedFilePath(file_path));
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       &WebFileSystemCallbacks::didResolveURL,
       MakeTuple(UTF8ToUTF16(info.name), info.root_url,
-                static_cast<WebKit::WebFileSystemType>(info.mount_type),
+                static_cast<blink::WebFileSystemType>(info.mount_type),
                 normalized_path.AsUTF16Unsafe(), is_directory));
 }
 
 void StatusCallbackAdapter(int thread_id, int callbacks_id,
                            WaitableCallbackResults* waitable_results,
                            base::PlatformFileError error) {
   if (error == base::PLATFORM_FILE_OK) {
     CallbackFileSystemCallbacks(
         thread_id, callbacks_id, waitable_results,
         &WebFileSystemCallbacks::didSucceed, MakeTuple());
@@ skipping 28 matching lines @@
   }
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       &WebFileSystemCallbacks::didReadDirectory,
       MakeTuple(file_system_entries, has_more));
 }
 
 void DidCreateFileWriter(
     int callbacks_id,
     const GURL& path,
-    WebKit::WebFileWriterClient* client,
+    blink::WebFileWriterClient* client,
     base::MessageLoopProxy* main_thread_loop,
     const base::PlatformFileInfo& file_info) {
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
 
   WebFileSystemCallbacks callbacks =
       filesystem->GetAndUnregisterCallbacks(callbacks_id);
 
   if (file_info.is_directory || file_info.size < 0) {
-    callbacks.didFail(WebKit::WebFileErrorInvalidState);
+    callbacks.didFail(blink::WebFileErrorInvalidState);
     return;
   }
   WebFileWriterImpl::Type type =
       callbacks.shouldBlockUntilCompletion() ?
           WebFileWriterImpl::TYPE_SYNC : WebFileWriterImpl::TYPE_ASYNC;
   callbacks.didCreateFileWriter(
       new WebFileWriterImpl(path, client, type, main_thread_loop),
       file_info.size);
 }
 
 void CreateFileWriterCallbackAdapter(
     int thread_id, int callbacks_id,
     WaitableCallbackResults* waitable_results,
     base::MessageLoopProxy* main_thread_loop,
     const GURL& path,
-    WebKit::WebFileWriterClient* client,
+    blink::WebFileWriterClient* client,
     const base::PlatformFileInfo& file_info) {
   DispatchResultsClosure(
       thread_id, callbacks_id, waitable_results,
       base::Bind(&DidCreateFileWriter, callbacks_id, path, client,
                  make_scoped_refptr(main_thread_loop), file_info));
 }
 
 void DidCreateSnapshotFile(
     int callbacks_id,
     base::MessageLoopProxy* main_thread_loop,
@@ skipping 62 matching lines @@
 
 WebFileSystemImpl::~WebFileSystemImpl() {
   g_webfilesystem_tls.Pointer()->Set(NULL);
 }
 
 void WebFileSystemImpl::OnWorkerRunLoopStopped() {
   delete this;
 }
 
 void WebFileSystemImpl::openFileSystem(
-    const WebKit::WebURL& storage_partition,
-    WebKit::WebFileSystemType type,
+    const blink::WebURL& storage_partition,
+    blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::OpenFileSystem,
       MakeTuple(GURL(storage_partition),
                 static_cast<fileapi::FileSystemType>(type),
                 base::Bind(&OpenFileSystemCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::resolveURL(
-    const WebKit::WebURL& filesystem_url,
+    const blink::WebURL& filesystem_url,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::ResolveURL,
       MakeTuple(GURL(filesystem_url),
                 base::Bind(&ResolveURLCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::deleteFileSystem(
-    const WebKit::WebURL& storage_partition,
-    WebKit::WebFileSystemType type,
+    const blink::WebURL& storage_partition,
+    blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::DeleteFileSystem,
       MakeTuple(GURL(storage_partition),
                 static_cast<fileapi::FileSystemType>(type),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::move(
-    const WebKit::WebURL& src_path,
-    const WebKit::WebURL& dest_path,
+    const blink::WebURL& src_path,
+    const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::Move,
       MakeTuple(GURL(src_path), GURL(dest_path),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::copy(
-    const WebKit::WebURL& src_path,
-    const WebKit::WebURL& dest_path,
+    const blink::WebURL& src_path,
+    const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::Copy,
       MakeTuple(GURL(src_path), GURL(dest_path),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::remove(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::Remove,
       MakeTuple(GURL(path), false /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::removeRecursively(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::Remove,
       MakeTuple(GURL(path), true /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::readMetadata(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::ReadMetadata,
       MakeTuple(GURL(path),
                 base::Bind(&ReadMetadataCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::createFile(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     bool exclusive,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::CreateFile,
       MakeTuple(GURL(path), exclusive,
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::createDirectory(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     bool exclusive,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::CreateDirectory,
       MakeTuple(GURL(path), exclusive, false /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::fileExists(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::Exists,
       MakeTuple(GURL(path), false /* directory */,
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::directoryExists(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::Exists,
       MakeTuple(GURL(path), true /* directory */,
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::readDirectory(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::ReadDirectory,
       MakeTuple(GURL(path),
                 base::Bind(&ReadDirectoryCallbackAdapater,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
 base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::createFileWriter(
     const WebURL& path,
-    WebKit::WebFileWriterClient* client,
+    blink::WebFileWriterClient* client,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::ReadMetadata,
       MakeTuple(GURL(path),
                 base::Bind(&CreateFileWriterCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results),
                            main_thread_loop_, GURL(path), client),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::createSnapshotFileAndReadMetadata(
-    const WebKit::WebURL& path,
+    const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::CreateSnapshotFile,
       MakeTuple(GURL(path),
                 base::Bind(&CreateSnapshotFileCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
@@ skipping 17 matching lines @@
     int callbacks_id) {
   DCHECK(CalledOnValidThread());
   CallbacksMap::iterator found = callbacks_.find(callbacks_id);
   DCHECK(found != callbacks_.end());
   WebFileSystemCallbacks callbacks = found->second;
   callbacks_.erase(found);
   return callbacks;
 }
 
 }  // namespace content