Use explicit WebString <-> string16 conversion methods in storage API files

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 <stddef.h>
 #include <tuple>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/child/child_thread_impl.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/common/fileapi/file_system_messages.h"
 #include "storage/common/fileapi/directory_entry.h"
 #include "storage/common/fileapi/file_system_util.h"
+#include "third_party/WebKit/public/platform/FilePathConversion.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"
 
 using blink::WebFileInfo;
 using blink::WebFileSystemCallbacks;
 using blink::WebFileSystemEntry;
 using blink::WebString;
@@ skipping 100 matching lines @@
   FileInfoToWebFileInfo(file_info, &web_file_info);
   callbacks->didReadMetadata(web_file_info);
 }
 
 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();
+        blink::FilePathToWebString(base::FilePath(entries[i].name));
     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,
+void DidOpenFileSystem(const std::string& name,
+                       const GURL& root,
                        WebFileSystemCallbacks* callbacks) {
-  callbacks->didOpenFileSystem(name, root);
+  callbacks->didOpenFileSystem(blink::WebString::fromUTF8(name), root);
 }
 
-void DidResolveURL(const base::string16& name,
+void DidResolveURL(const std::string& name,
                    const GURL& root_url,
                    storage::FileSystemType mount_type,
-                   const base::string16& file_path,
+                   const base::FilePath& file_path,
                    bool is_directory,
                    WebFileSystemCallbacks* callbacks) {
-  callbacks->didResolveURL(
-      name,
-      root_url,
-      static_cast<blink::WebFileSystemType>(mount_type),
-      file_path,
-      is_directory);
+  callbacks->didResolveURL(blink::WebString::fromUTF8(name), root_url,
+                           static_cast<blink::WebFileSystemType>(mount_type),
+                           blink::FilePathToWebString(file_path), is_directory);
 }
 
 void DidFail(base::File::Error error, WebFileSystemCallbacks* callbacks) {
   callbacks->didFail(storage::FileErrorToWebFileError(error));
 }
 
 // Run WebFileSystemCallbacks's |method| with |params|.
 void RunCallbacks(
     int callbacks_id,
     const base::Callback<void(WebFileSystemCallbacks*)>& callback,
@@ skipping 45 matching lines @@
 // Callback adapters. Callbacks must be called on the original calling thread,
 // so these callback adapters relay back the results to the calling thread
 // if necessary.
 
 void OpenFileSystemCallbackAdapter(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const std::string& name,
     const GURL& root) {
-  CallbackFileSystemCallbacks(
-      task_runner, callbacks_id, waitable_results,
-      base::Bind(&DidOpenFileSystem, base::UTF8ToUTF16(name), root),
-      UNREGISTER_CALLBACKS);
+  CallbackFileSystemCallbacks(task_runner, callbacks_id, waitable_results,
+                              base::Bind(&DidOpenFileSystem, name, root),
+                              UNREGISTER_CALLBACKS);
 }
 
 void ResolveURLCallbackAdapter(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const storage::FileSystemInfo& info,
     const base::FilePath& file_path,
     bool is_directory) {
   base::FilePath normalized_path(
       storage::VirtualPath::GetNormalizedFilePath(file_path));
   CallbackFileSystemCallbacks(
       task_runner, callbacks_id, waitable_results,
-      base::Bind(&DidResolveURL, base::UTF8ToUTF16(info.name), info.root_url,
-                 info.mount_type, normalized_path.AsUTF16Unsafe(),
-                 is_directory),
+      base::Bind(&DidResolveURL, info.name, info.root_url, info.mount_type,
+                 normalized_path, is_directory),
       UNREGISTER_CALLBACKS);
 }
 
 void StatusCallbackAdapter(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     int callbacks_id,
     WaitableCallbackResults* waitable_results,
     base::File::Error error) {
   if (error == base::File::FILE_OK) {
     CallbackFileSystemCallbacks(task_runner, callbacks_id, waitable_results,
@@ skipping 76 matching lines @@
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
 
   WebFileSystemCallbacks callbacks = filesystem->GetCallbacks(callbacks_id);
   filesystem->UnregisterCallbacks(callbacks_id);
 
   WebFileInfo web_file_info;
   FileInfoToWebFileInfo(file_info, &web_file_info);
-  web_file_info.platformPath = platform_path.AsUTF16Unsafe();
+  web_file_info.platformPath = blink::FilePathToWebString(platform_path);
   callbacks.didCreateSnapshotFile(web_file_info);
 
   // TODO(michaeln,kinuko): Use ThreadSafeSender when Blob becomes
   // non-bridge model.
   main_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(&DidReceiveSnapshotFile, request_id));
 }
 
 void CreateSnapshotFileCallbackAdapter(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
@@ skipping 352 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