fix review

Author: ryuhei shima

src/inspector/dom_storage_agent.cc

@@ -1,6 +1,9 @@
 #include "dom_storage_agent.h"
+#include <optional>
 #include "env-inl.h"
 #include "inspector/inspector_object_utils.h"
+#include "util.h"
+#include "v8-exception.h"
 #include "v8-isolate.h"
 
 namespace node {
@@ -85,19 +88,19 @@ protocol::DispatchResponse DOMStorageAgent::getDOMStorageItems(
         "DOMStorage domain is not enabled");
   }
   bool is_local_storage = storageId->getIsLocalStorage();
-  std::unique_ptr<std::unordered_map<std::string, std::string>> storage_map =
+  std::optional<std::unordered_map<std::string, std::string>> storage_map =
       is_local_storage
-          ? std::make_unique<std::unordered_map<std::string, std::string>>(
+          ? std::make_optional<std::unordered_map<std::string, std::string>>(
                 local_storage_map_)
-          : std::make_unique<std::unordered_map<std::string, std::string>>(
+          : std::make_optional<std::unordered_map<std::string, std::string>>(
                 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();
       storage_map =
-          std::make_unique<std::unordered_map<std::string, std::string>>(
+          std::make_optional<std::unordered_map<std::string, std::string>>(
               std::move(all_items));
     }
   }
@@ -258,17 +261,18 @@ void DOMStorageAgent::registerStorage(Local<Context> context,
 
 std::optional<node::webstorage::Storage*> DOMStorageAgent::getWebStorage(
     bool is_local_storage) {
-  std::string var_name = is_local_storage ? "localStorage" : "sessionStorage";
   v8::Isolate* isolate = env_->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Object> global = env_->context()->Global();
   v8::Local<v8::Value> web_storage_val;
+  v8::TryCatch try_catch(isolate);
   if (!global
            ->Get(env_->context(),
-                 v8::String::NewFromUtf8(env_->isolate(), var_name.c_str())
-                     .ToLocalChecked())
+                 is_local_storage
+                     ? FIXED_ONE_BYTE_STRING(isolate, "localStorage")
+                     : FIXED_ONE_BYTE_STRING(isolate, "sessionStorage"))
            .ToLocal(&web_storage_val) ||
-      !web_storage_val->IsObject()) {
+      !web_storage_val->IsObject() || try_catch.HasCaught()) {
     return std::nullopt;
   } else {
     node::webstorage::Storage* storage;

src/node_webstorage.cc

@@ -9,6 +9,7 @@
 #include "node_errors.h"
 #include "node_mem-inl.h"
 #include "path.h"
+#include "simdutf.h"
 #include "sqlite3.h"
 #include "util-inl.h"
 
@@ -297,17 +298,23 @@ std::unordered_map<std::string, std::string> Storage::GetAll() {
     auto key_size = sqlite3_column_bytes(stmt.get(), 0) / sizeof(uint16_t);
     auto value_size = sqlite3_column_bytes(stmt.get(), 1) / sizeof(uint16_t);
     auto key_uint16(
-        reinterpret_cast<const uint16_t*>(sqlite3_column_blob(stmt.get(), 0)));
+        reinterpret_cast<const char16_t*>(sqlite3_column_blob(stmt.get(), 0)));
     auto value_uint16(
-        reinterpret_cast<const uint16_t*>(sqlite3_column_blob(stmt.get(), 1)));
+        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;
-    for (size_t i = 0; i < key_size; ++i) {
-      key.push_back(static_cast<char>(key_uint16[i]));
-    }
+    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;
-    for (size_t i = 0; i < value_size; ++i) {
-      value.push_back(static_cast<char>(value_uint16[i]));
-    }
+    value.resize(value_utf8_size);
+    written =
+        simdutf::convert_utf16_to_utf8(value_uint16, value_size, value.data());
+    value.resize(written);
 
     result.emplace(std::move(key), std::move(value));
   }