fix test

Author: islandryu

src/inspector/dom_storage_agent.cc

@@ -45,15 +45,25 @@ void DOMStorageAgent::Wire(protocol::UberDispatcher* dispatcher) {
       std::make_unique<protocol::DOMStorage::Frontend>(dispatcher->channel());
   protocol::DOMStorage::Dispatcher::wire(dispatcher, this);
   addEventNotifier("domStorageItemAdded",
-                   (EventNotifier)(&DOMStorageAgent::domStorageItemAdded));
+                   [this](v8::Local<v8::Context> ctx, v8::Local<v8::Object> p) {
+                     this->domStorageItemAdded(ctx, p);
+                   });
   addEventNotifier("domStorageItemRemoved",
-                   (EventNotifier)(&DOMStorageAgent::domStorageItemRemoved));
+                   [this](v8::Local<v8::Context> ctx, v8::Local<v8::Object> p) {
+                     this->domStorageItemRemoved(ctx, p);
+                   });
   addEventNotifier("domStorageItemUpdated",
-                   (EventNotifier)(&DOMStorageAgent::domStorageItemUpdated));
+                   [this](v8::Local<v8::Context> ctx, v8::Local<v8::Object> p) {
+                     this->domStorageItemUpdated(ctx, p);
+                   });
   addEventNotifier("domStorageItemsCleared",
-                   (EventNotifier)(&DOMStorageAgent::domStorageItemsCleared));
+                   [this](v8::Local<v8::Context> ctx, v8::Local<v8::Object> p) {
+                     this->domStorageItemsCleared(ctx, p);
+                   });
   addEventNotifier("registerStorage",
-                   (EventNotifier)(&DOMStorageAgent::registerStorage));
+                   [this](v8::Local<v8::Context> ctx, v8::Local<v8::Object> p) {
+                     this->registerStorage(ctx, p);
+                   });
 }
 
 protocol::DispatchResponse DOMStorageAgent::enable() {

src/inspector/dom_storage_agent.h

@@ -51,9 +51,9 @@ class DOMStorageAgent : public protocol::DOMStorage::Backend,
 
  private:
   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_;
-  bool enabled_;
+  std::unordered_map<std::string, std::string> local_storage_map_ = {};
+  std::unordered_map<std::string, std::string> session_storage_map_ = {};
+  bool enabled_ = false;
   Environment* env_;
 };
 

src/inspector/notification_emitter.cc

@@ -8,15 +8,15 @@ namespace inspector {
 NotificationEmitter::NotificationEmitter() {}
 
 void NotificationEmitter::emitNotification(v8::Local<v8::Context> context,
-                                           const std::string& event,
+                                           const EventKey& event,
                                            v8::Local<v8::Object> params) {
   auto it = event_notifier_map_.find(event);
-  if (it != event_notifier_map_.end()) {
-    (this->*(it->second))(context, params);
+  if (it != event_notifier_map_.end() && it->second) {
+    it->second(context, params);
   }
 }
 
-void NotificationEmitter::addEventNotifier(const protocol::String& event,
+void NotificationEmitter::addEventNotifier(const EventKey& event,
                                            EventNotifier notifier) {
   event_notifier_map_[event] = notifier;
 }

src/inspector/notification_emitter.h

@@ -3,32 +3,33 @@
 
 #include <string>
 #include <unordered_map>
-#include "node/inspector/protocol/Protocol.h"
 #include "v8.h"
 
 namespace node {
 namespace inspector {
 
 class NotificationEmitter {
  public:
-  using EventNotifier = void (NotificationEmitter::*)(
-      v8::Local<v8::Context> context, v8::Local<v8::Object>);
+  using EventKey = std::string;
+  using EventNotifier =
+      std::function<void(v8::Local<v8::Context>, v8::Local<v8::Object>)>;
+
   NotificationEmitter();
   virtual ~NotificationEmitter() = default;
 
   void emitNotification(v8::Local<v8::Context> context,
-                        const protocol::String& event,
+                        const EventKey& event,
                         v8::Local<v8::Object> params);
   virtual bool canEmit(const std::string& domain) = 0;
 
   NotificationEmitter(const NotificationEmitter&) = delete;
   NotificationEmitter& operator=(const NotificationEmitter&) = delete;
 
  protected:
-  void addEventNotifier(const protocol::String& event, EventNotifier notifier);
+  void addEventNotifier(const EventKey& event, EventNotifier notifier);
 
  private:
-  std::unordered_map<protocol::String, EventNotifier> event_notifier_map_;
+  std::unordered_map<EventKey, EventNotifier> event_notifier_map_ = {};
 };
 
 }  // namespace inspector