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

content/child/indexed_db/webidbdatabase_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/indexed_db/webidbdatabase_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "content/child/indexed_db/indexed_db_callbacks_impl.h"
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
 #include "content/child/indexed_db/indexed_db_key_builders.h"
 #include "mojo/public/cpp/bindings/strong_associated_binding.h"
+#include "third_party/WebKit/public/platform/FilePathConversion.h"
 #include "third_party/WebKit/public/platform/WebBlobInfo.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBKeyPath.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h"
 
 using blink::WebBlobInfo;
 using blink::WebIDBCallbacks;
@@ skipping 144 matching lines @@
 }
 
 void WebIDBDatabaseImpl::createObjectStore(long long transaction_id,
                                            long long object_store_id,
                                            const WebString& name,
                                            const WebIDBKeyPath& key_path,
                                            bool auto_increment) {
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::CreateObjectStore, base::Unretained(helper_),
-                 transaction_id, object_store_id, base::string16(name),
+                 transaction_id, object_store_id, name.utf16(),
                  IndexedDBKeyPathBuilder::Build(key_path), auto_increment));
 }
 
 void WebIDBDatabaseImpl::deleteObjectStore(long long transaction_id,
                                            long long object_store_id) {
   io_runner_->PostTask(FROM_HERE, base::Bind(&IOThreadHelper::DeleteObjectStore,
                                              base::Unretained(helper_),
                                              transaction_id, object_store_id));
 }
 
 void WebIDBDatabaseImpl::renameObjectStore(long long transaction_id,
                                            long long object_store_id,
                                            const blink::WebString& new_name) {
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::RenameObjectStore, base::Unretained(helper_),
-                 transaction_id, object_store_id, base::string16(new_name)));
+                 transaction_id, object_store_id, new_name.utf16()));
 }
 
 void WebIDBDatabaseImpl::createTransaction(
     long long transaction_id,
     const WebVector<long long>& object_store_ids,
     blink::WebIDBTransactionMode mode) {
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::CreateTransaction, base::Unretained(helper_),
                  transaction_id, std::vector<int64_t>(object_store_ids.begin(),
@@ skipping 101 matching lines @@
   IndexedDBDispatcher::ThreadSpecificInstance()->ResetCursorPrefetchCaches(
       transaction_id, nullptr);
 
   auto mojo_value = indexed_db::mojom::Value::New();
   mojo_value->bits.assign(value.data(), value.data() + value.size());
   mojo_value->blob_or_file_info.reserve(web_blob_info.size());
   for (const WebBlobInfo& info : web_blob_info) {
     auto blob_info = indexed_db::mojom::BlobInfo::New();
     if (info.isFile()) {
       blob_info->file = indexed_db::mojom::FileInfo::New();
-      blob_info->file->path =
-          base::FilePath::FromUTF8Unsafe(info.filePath().utf8());
-      blob_info->file->name = info.fileName();
+      blob_info->file->path = blink::WebStringToFilePath(info.filePath());
+      blob_info->file->name = info.fileName().utf16();
       blob_info->file->last_modified =
           base::Time::FromDoubleT(info.lastModified());
     }
     blob_info->size = info.size();
     blob_info->uuid = info.uuid().latin1();
     DCHECK(blob_info->uuid.size());
-    blob_info->mime_type = info.type();
+    blob_info->mime_type = info.type().utf16();
     mojo_value->blob_or_file_info.push_back(std::move(blob_info));
   }
 
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
       base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::Put, base::Unretained(helper_),
                  transaction_id, object_store_id, base::Passed(&mojo_value),
                  key, put_mode, base::Passed(&callbacks_impl),
@@ skipping 98 matching lines @@
 void WebIDBDatabaseImpl::createIndex(long long transaction_id,
                                      long long object_store_id,
                                      long long index_id,
                                      const WebString& name,
                                      const WebIDBKeyPath& key_path,
                                      bool unique,
                                      bool multi_entry) {
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::CreateIndex, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_id,
-                 base::string16(name), IndexedDBKeyPathBuilder::Build(key_path),
-                 unique, multi_entry));
+                 transaction_id, object_store_id, index_id, name.utf16(),
+                 IndexedDBKeyPathBuilder::Build(key_path), unique,
+                 multi_entry));
 }
 
 void WebIDBDatabaseImpl::deleteIndex(long long transaction_id,
                                      long long object_store_id,
                                      long long index_id) {
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::DeleteIndex, base::Unretained(helper_),
                  transaction_id, object_store_id, index_id));
 }
 
 void WebIDBDatabaseImpl::renameIndex(long long transaction_id,
                                      long long object_store_id,
                                      long long index_id,
                                      const WebString& new_name) {
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::RenameIndex, base::Unretained(helper_),
-                 transaction_id, object_store_id, index_id, new_name));
+                 transaction_id, object_store_id, index_id, new_name.utf16()));
 }
 
 void WebIDBDatabaseImpl::abort(long long transaction_id) {
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::Abort, base::Unretained(helper_),
                             transaction_id));
 }
 
 void WebIDBDatabaseImpl::commit(long long transaction_id) {
   io_runner_->PostTask(
@@ skipping 210 matching lines @@
     std::unique_ptr<IndexedDBCallbacksImpl> callbacks) {
   CallbacksAssociatedPtrInfo ptr_info;
   indexed_db::mojom::CallbacksAssociatedRequest request;
   database_.associated_group()->CreateAssociatedInterface(
       mojo::AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
   mojo::MakeStrongAssociatedBinding(std::move(callbacks), std::move(request));
   return ptr_info;
 }
 
 }  // namespace content