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

content/child/indexed_db/indexed_db_callbacks_impl.cc

 // Copyright 2016 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/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 "content/child/indexed_db/webidbcursor_impl.h"
 #include "content/child/indexed_db/webidbdatabase_impl.h"
 #include "content/common/indexed_db/indexed_db_constants.h"
+#include "third_party/WebKit/public/platform/FilePathConversion.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBCallbacks.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBValue.h"
 
 using blink::WebBlobInfo;
 using blink::WebIDBCallbacks;
 using blink::WebIDBDatabase;
 using blink::WebIDBMetadata;
 using blink::WebIDBValue;
 using blink::WebString;
 using blink::WebVector;
 using indexed_db::mojom::DatabaseAssociatedPtrInfo;
 
 namespace content {
 
 namespace {
 
 void ConvertIndexMetadata(const content::IndexedDBIndexMetadata& metadata,
                           WebIDBMetadata::Index* output) {
   output->id = metadata.id;
-  output->name = metadata.name;
+  output->name = WebString::fromUTF16(metadata.name);
   output->keyPath = WebIDBKeyPathBuilder::Build(metadata.key_path);
   output->unique = metadata.unique;
   output->multiEntry = metadata.multi_entry;
 }
 
 void ConvertObjectStoreMetadata(
     const content::IndexedDBObjectStoreMetadata& metadata,
     WebIDBMetadata::ObjectStore* output) {
   output->id = metadata.id;
-  output->name = metadata.name;
+  output->name = WebString::fromUTF16(metadata.name);
   output->keyPath = WebIDBKeyPathBuilder::Build(metadata.key_path);
   output->autoIncrement = metadata.auto_increment;
   output->maxIndexId = metadata.max_index_id;
   output->indexes = WebVector<WebIDBMetadata::Index>(metadata.indexes.size());
   size_t i = 0;
   for (const auto& iter : metadata.indexes)
     ConvertIndexMetadata(iter.second, &output->indexes[i++]);
 }
 
 void ConvertDatabaseMetadata(const content::IndexedDBDatabaseMetadata& metadata,
                              WebIDBMetadata* output) {
   output->id = metadata.id;
-  output->name = metadata.name;
+  output->name = WebString::fromUTF16(metadata.name);
   output->version = metadata.version;
   output->maxObjectStoreId = metadata.max_object_store_id;
   output->objectStores =
       WebVector<WebIDBMetadata::ObjectStore>(metadata.object_stores.size());
   size_t i = 0;
   for (const auto& iter : metadata.object_stores)
     ConvertObjectStoreMetadata(iter.second, &output->objectStores[i++]);
 }
 
 void ConvertValue(const indexed_db::mojom::ValuePtr& value,
                   WebIDBValue* web_value) {
   if (value->bits.empty())
     return;
 
   blink::WebVector<WebBlobInfo> local_blob_info(
       value->blob_or_file_info.size());
   for (size_t i = 0; i < value->blob_or_file_info.size(); ++i) {
     const auto& info = value->blob_or_file_info[i];
     if (info->file) {
-      local_blob_info[i] = WebBlobInfo(
-          WebString::fromUTF8(info->uuid), info->file->path.AsUTF16Unsafe(),
-          info->file->name, info->mime_type,
-          info->file->last_modified.ToDoubleT(), info->size);
+      local_blob_info[i] =
+          WebBlobInfo(WebString::fromUTF8(info->uuid),
+                      blink::FilePathToWebString(info->file->path),
+                      WebString::fromUTF16(info->file->name),
+                      WebString::fromUTF16(info->mime_type),
+                      info->file->last_modified.ToDoubleT(), info->size);
     } else {
-      local_blob_info[i] = WebBlobInfo(WebString::fromUTF8(info->uuid),
-                                       info->mime_type, info->size);
+      local_blob_info[i] =
+          WebBlobInfo(WebString::fromUTF8(info->uuid),
+                      WebString::fromUTF16(info->mime_type), info->size);
     }
   }
 
   web_value->data.assign(&*value->bits.begin(), value->bits.size());
   web_value->webBlobInfo.swap(local_blob_info);
 }
 
 void ConvertReturnValue(const indexed_db::mojom::ReturnValuePtr& value,
                         WebIDBValue* web_value) {
   ConvertValue(value->value, web_value);
@@ skipping 141 matching lines @@
 }
 
 IndexedDBCallbacksImpl::InternalState::~InternalState() {
   IndexedDBDispatcher::ThreadSpecificInstance()->UnregisterMojoOwnedCallbacks(
       this);
 }
 
 void IndexedDBCallbacksImpl::InternalState::Error(
     int32_t code,
     const base::string16& message) {
-  callbacks_->onError(blink::WebIDBDatabaseError(code, message));
+  callbacks_->onError(
+      blink::WebIDBDatabaseError(code, WebString::fromUTF16(message)));
   callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::SuccessStringList(
     const std::vector<base::string16>& value) {
-  callbacks_->onSuccess(WebVector<WebString>(value));
+  WebVector<WebString> web_value(value.size());
+  std::transform(
+      value.begin(), value.end(), web_value.begin(),
+      [](const base::string16& s) { return WebString::fromUTF16(s); });
+  callbacks_->onSuccess(web_value);
   callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::Blocked(int64_t existing_version) {
   callbacks_->onBlocked(existing_version);
   // Not resetting |callbacks_|.
 }
 
 void IndexedDBCallbacksImpl::InternalState::UpgradeNeeded(
     DatabaseAssociatedPtrInfo database_info,
@@ skipping 94 matching lines @@
   callbacks_->onSuccess(value);
   callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::Success() {
   callbacks_->onSuccess();
   callbacks_.reset();
 }
 
 }  // namespace content