support utf16

Author: ryuhei shima

src/inspector/dom_storage_agent.cc

@@ -88,29 +88,29 @@ protocol::DispatchResponse DOMStorageAgent::getDOMStorageItems(
         "DOMStorage domain is not enabled");
   }
   bool is_local_storage = storageId->getIsLocalStorage();
-  std::optional<std::unordered_map<std::string, std::string>> storage_map =
+  std::optional<StorageMap> storage_map =
       is_local_storage
-          ? std::make_optional<std::unordered_map<std::string, std::string>>(
-                local_storage_map_)
-          : std::make_optional<std::unordered_map<std::string, std::string>>(
-                session_storage_map_);
+          ? std::make_optional<StorageMap>(local_storage_map_)
+          : std::make_optional<StorageMap>(session_storage_map_);
   if (storage_map->empty()) {
     auto web_storage_obj = getWebStorage(is_local_storage);
     if (web_storage_obj) {
-      std::unordered_map<std::string, std::string> all_items =
-          web_storage_obj.value()->GetAll();
+      StorageMap all_items = web_storage_obj.value()->GetAll();
       storage_map =
-          std::make_optional<std::unordered_map<std::string, std::string>>(
-              std::move(all_items));
+          std::make_optional<StorageMap>(std::move(all_items));
     }
   }
 
   auto result =
       std::make_unique<protocol::Array<protocol::Array<protocol::String>>>();
   for (const auto& pair : *storage_map) {
     auto item = std::make_unique<protocol::Array<protocol::String>>();
-    item->push_back(pair.first);
-    item->push_back(pair.second);
+    item->push_back(
+      protocol::StringUtil::fromUTF16(reinterpret_cast<const uint16_t*>(pair.first.data()),
+                                        pair.first.size())); 
+    item->push_back(
+      protocol::StringUtil::fromUTF16(reinterpret_cast<const uint16_t*>(pair.second.data()),
+                                        pair.second.size()));
     result->push_back(std::move(item));
   }
   *items = std::move(result);
@@ -237,7 +237,7 @@ void DOMStorageAgent::registerStorage(Local<Context> context,
            .ToLocal(&storage_map_obj)) {
     return;
   }
-  std::unordered_map<std::string, std::string>& storage_map =
+  StorageMap& storage_map =
       is_local_storage ? local_storage_map_ : session_storage_map_;
   Local<Array> property_names;
   if (!storage_map_obj->GetOwnPropertyNames(context).ToLocal(&property_names)) {
@@ -253,10 +253,13 @@ void DOMStorageAgent::registerStorage(Local<Context> context,
     if (!storage_map_obj->Get(context, key_value).ToLocal(&value_value)) {
       return;
     }
-    node::Utf8Value key_utf8(isolate, key_value);
-    node::Utf8Value value_utf8(isolate, value_value);
-    storage_map[*key_utf8] = *value_utf8;
-  }
+    node::TwoByteValue key_utf16(isolate, key_value);
+    node::TwoByteValue value_utf16(isolate, value_value);
+    storage_map[std::u16string(
+        reinterpret_cast<const char16_t*>(*key_utf16), key_utf16.length())] =
+        std::u16string(reinterpret_cast<const char16_t*>(*value_utf16),
+                       value_utf16.length());
+      }
 }
 
 std::optional<node::webstorage::Storage*> DOMStorageAgent::getWebStorage(

src/inspector/dom_storage_agent.h

@@ -52,11 +52,12 @@ class DOMStorageAgent : public protocol::DOMStorage::Backend,
   DOMStorageAgent& operator=(const DOMStorageAgent&) = delete;
 
  private:
+  typedef std::unordered_map<std::u16string, std::u16string> StorageMap;
   std::optional<node::webstorage::Storage*> getWebStorage(
       bool is_local_storage);
   std::unique_ptr<protocol::DOMStorage::Frontend> frontend_;
-  std::unordered_map<std::string, std::string> local_storage_map_ = {};
-  std::unordered_map<std::string, std::string> session_storage_map_ = {};
+  StorageMap local_storage_map_ = {};
+  StorageMap session_storage_map_ = {};
   bool enabled_ = false;
   Environment* env_;
 };

src/node_webstorage.cc

@@ -281,7 +281,7 @@ MaybeLocal<Array> Storage::Enumerate() {
   return Array::New(env()->isolate(), values.data(), values.size());
 }
 
-std::unordered_map<std::string, std::string> Storage::GetAll() {
+std::unordered_map<std::u16string, std::u16string> Storage::GetAll() {
   if (!Open().IsJust()) {
     return {};
   }
@@ -291,7 +291,7 @@ std::unordered_map<std::string, std::string> Storage::GetAll() {
   sqlite3_stmt* s = nullptr;
   int r = sqlite3_prepare_v2(db_.get(), sql.data(), sql.size(), &s, nullptr);
   auto stmt = stmt_unique_ptr(s);
-  std::unordered_map<std::string, std::string> result;
+  std::unordered_map<std::u16string, std::u16string> result;
   while ((r = sqlite3_step(stmt.get())) == SQLITE_ROW) {
     CHECK(sqlite3_column_type(stmt.get(), 0) == SQLITE_BLOB);
     CHECK(sqlite3_column_type(stmt.get(), 1) == SQLITE_BLOB);
@@ -301,20 +301,9 @@ std::unordered_map<std::string, std::string> Storage::GetAll() {
         reinterpret_cast<const char16_t*>(sqlite3_column_blob(stmt.get(), 0)));
     auto value_uint16(
         reinterpret_cast<const char16_t*>(sqlite3_column_blob(stmt.get(), 1)));
-    size_t key_utf8_size =
-        simdutf::utf8_length_from_utf16(key_uint16, key_size);
-    std::string key;
-    key.resize(key_utf8_size);
-    size_t written =
-        simdutf::convert_utf16_to_utf8(key_uint16, key_size, key.data());
-    key.resize(written);
-    size_t value_utf8_size =
-        simdutf::utf8_length_from_utf16(value_uint16, value_size);
-    std::string value;
-    value.resize(value_utf8_size);
-    written =
-        simdutf::convert_utf16_to_utf8(value_uint16, value_size, value.data());
-    value.resize(written);
+
+    std::u16string key(key_uint16, key_size);
+    std::u16string value(value_uint16, value_size);
 
     result.emplace(std::move(key), std::move(value));
   }

src/node_webstorage.h

@@ -41,7 +41,7 @@ class Storage : public BaseObject {
   v8::MaybeLocal<v8::Value> LoadKey(const int index);
   v8::Maybe<void> Remove(v8::Local<v8::Name> key);
   v8::Maybe<void> Store(v8::Local<v8::Name> key, v8::Local<v8::Value> value);
-  std::unordered_map<std::string, std::string> GetAll();
+  std::unordered_map<std::u16string, std::u16string> GetAll();
 
   SET_MEMORY_INFO_NAME(Storage)
   SET_SELF_SIZE(Storage)