src: move ToNamespacedPath call of webstorage

lib/internal/webstorage.js

@@ -6,7 +6,6 @@ const { ERR_INVALID_ARG_VALUE } = require('internal/errors').codes;
 const { getOptionValue } = require('internal/options');
 const { emitExperimentalWarning } = require('internal/util');
 const { kConstructorKey, Storage } = internalBinding('webstorage');
-const { resolve, toNamespacedPath } = require('path');
 const { getValidatedPath } = require('internal/fs/utils');
 const kInMemoryPath = ':memory:';
 
@@ -25,16 +24,15 @@ ObjectDefineProperties(module.exports, {
     enumerable: true,
     get() {
       if (lazyLocalStorage === undefined) {
-        let location = getOptionValue('--localstorage-file');
+        const location = getOptionValue('--localstorage-file');
 
         if (location === '') {
           throw new ERR_INVALID_ARG_VALUE('--localstorage-file',
                                           location,
                                           'is an invalid localStorage location');
         }
 
-        location = toNamespacedPath(resolve(getValidatedPath(location)));
-        lazyLocalStorage = new Storage(kConstructorKey, location);
+        lazyLocalStorage = new Storage(kConstructorKey, getValidatedPath(location));
       }
 
       return lazyLocalStorage;

src/node_webstorage.cc

@@ -6,6 +6,7 @@
 #include "node.h"
 #include "node_errors.h"
 #include "node_mem-inl.h"
+#include "path.h"
 #include "sqlite3.h"
 #include "util-inl.h"
 
@@ -76,13 +77,14 @@ static void ThrowQuotaExceededException(Local<Context> context) {
   isolate->ThrowException(exception);
 }
 
-Storage::Storage(Environment* env, Local<Object> object, Local<String> location)
+Storage::Storage(Environment* env,
+                 Local<Object> object,
+                 std::string_view location)
     : BaseObject(env, object) {
   MakeWeak();
-  Utf8Value utf8_location(env->isolate(), location);
   symbols_.Reset(env->isolate(), Map::New(env->isolate()));
   db_ = nullptr;
-  location_ = utf8_location.ToString();
+  location_ = std::string(location);
 }
 
 Storage::~Storage() {
@@ -209,7 +211,15 @@ void Storage::New(const FunctionCallbackInfo<Value>& args) {
 
   CHECK(args.IsConstructCall());
   CHECK(args[1]->IsString());
-  new Storage(env, args.This(), args[1].As<String>());
+
+  BufferValue location(env->isolate(), args[1]);
+  CHECK_NOT_NULL(*location);
+  // Only call namespaced path if the location is not "in memory".
+  if (location.ToStringView() != kInMemoryPath) {
+    ToNamespacedPath(env, &location);
+  }
+
+  new Storage(env, args.This(), location.ToStringView());
 }
 
 void Storage::Clear() {

src/node_webstorage.h

@@ -23,11 +23,13 @@ struct stmt_deleter {
 };
 using stmt_unique_ptr = std::unique_ptr<sqlite3_stmt, stmt_deleter>;
 
+static constexpr std::string_view kInMemoryPath = ":memory:";
+
 class Storage : public BaseObject {
  public:
   Storage(Environment* env,
           v8::Local<v8::Object> object,
-          v8::Local<v8::String> location);
+          std::string_view location);
   void MemoryInfo(MemoryTracker* tracker) const override;
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);