fix test

Author: islandryu

src/inspector/dom_storage_agent.cc

@@ -44,16 +44,14 @@ void DOMStorageAgent::Wire(protocol::UberDispatcher* dispatcher) {
   frontend_ =
       std::make_unique<protocol::DOMStorage::Frontend>(dispatcher->channel());
   protocol::DOMStorage::Dispatcher::wire(dispatcher, this);
-  addEventNotifier("domStorageItemAdded",
-                   (EventNotifier)(&DOMStorageAgent::domStorageItemAdded));
+  addEventNotifier("domStorageItemAdded", &DOMStorageAgent::domStorageItemAdded);
   addEventNotifier("domStorageItemRemoved",
-                   (EventNotifier)(&DOMStorageAgent::domStorageItemRemoved));
+                   &DOMStorageAgent::domStorageItemRemoved);
   addEventNotifier("domStorageItemUpdated",
-                   (EventNotifier)(&DOMStorageAgent::domStorageItemUpdated));
+                   &DOMStorageAgent::domStorageItemUpdated);
   addEventNotifier("domStorageItemsCleared",
-                   (EventNotifier)(&DOMStorageAgent::domStorageItemsCleared));
-  addEventNotifier("registerStorage",
-                   (EventNotifier)(&DOMStorageAgent::registerStorage));
+                   &DOMStorageAgent::domStorageItemsCleared);
+  addEventNotifier("registerStorage", &DOMStorageAgent::registerStorage);
 }
 
 protocol::DispatchResponse DOMStorageAgent::enable() {
@@ -231,6 +229,20 @@ void DOMStorageAgent::registerStorage(Local<Context> context,
   }
 }
 
+void DOMStorageAgent::emitNotification(Local<Context> context,
+                                       const EventKey& event,
+                                       Local<Object> params) {
+  auto it = event_notifier_map_.find(event);
+  if (it != event_notifier_map_.end()) {
+    (this->*(it->second))(context, params);
+  }
+}
+
+void DOMStorageAgent::addEventNotifier(const EventKey& event,
+                                       EventNotifier notifier) {
+  event_notifier_map_[event] = notifier;
+}
+
 bool DOMStorageAgent::canEmit(const std::string& domain) {
   return domain == "DOMStorage";
 }

src/inspector/dom_storage_agent.h

@@ -2,22 +2,29 @@
 #define SRC_INSPECTOR_DOM_STORAGE_AGENT_H_
 
 #include <string>
+#include <unordered_map>
 #include "env.h"
 #include "node/inspector/protocol/DOMStorage.h"
-#include "notification_emitter.h"
 #include "v8.h"
 
 namespace node {
 namespace inspector {
 
-class DOMStorageAgent : public protocol::DOMStorage::Backend,
-                        public NotificationEmitter {
+class DOMStorageAgent : public protocol::DOMStorage::Backend {
  public:
+  using EventKey = std::string;
+  using EventNotifier =
+      void (DOMStorageAgent::*)(v8::Local<v8::Context> context,
+                                v8::Local<v8::Object> params);
   explicit DOMStorageAgent(Environment* env);
   ~DOMStorageAgent() override;
 
   void Wire(protocol::UberDispatcher* dispatcher);
 
+  void emitNotification(v8::Local<v8::Context> context,
+                        const EventKey& event,
+                        v8::Local<v8::Object> params);
+
   protocol::DispatchResponse enable() override;
   protocol::DispatchResponse disable() override;
   protocol::DispatchResponse getDOMStorageItems(
@@ -44,16 +51,18 @@ class DOMStorageAgent : public protocol::DOMStorage::Backend,
                               v8::Local<v8::Object> params);
   void registerStorage(v8::Local<v8::Context> context,
                        v8::Local<v8::Object> params);
-  bool canEmit(const std::string& domain) override;
+  bool canEmit(const std::string& domain);
 
   DOMStorageAgent(const DOMStorageAgent&) = delete;
   DOMStorageAgent& operator=(const DOMStorageAgent&) = delete;
 
  private:
+  void addEventNotifier(const EventKey& event, EventNotifier notifier);
   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_ = {};
+  std::unordered_map<EventKey, EventNotifier> event_notifier_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);
+    // (this->*(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,32 @@
 
 #include <string>
 #include <unordered_map>
-#include "node/inspector/protocol/Protocol.h"
 #include "v8.h"
 
 namespace node {
 namespace inspector {
 
 class NotificationEmitter {
  public:
+  using EventKey = std::string;
   using EventNotifier = void (NotificationEmitter::*)(
       v8::Local<v8::Context> 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