chore: remove native_mate (Part 11) (#20719)

* refactor: convert Menu and globalShortcut to gin

* refactor: convert api::Cookies to gin

* refactor: convert View and WebContentsView to gin

* refactor: convert WebContents related classes to gin

* refactor: convert powerMonitor to gin

* refactor: prepare for header change

* refactor: remove last uses of mate::EventEmitter

* refactor: remove mate::EventEmitter

* refactor: move trackable_object to gin_helper

* fix: custom converter should not use Handle

* fix: no more need to check if icon is empty

It was a bug that the Handle<NativeImage> can be non-empty when the
image file does not exist. The bug was caused by the converter code
writing out the image even when the convertion fails.

The bug was work-arounded by adding an additional check, but since the
original bug had been fixed, the additional check is no longer needed.

* fix: should always set frameId even when callback is null

* fix: do not mix gin/mate handles for NativeImage

shell/common/gin_converters/accelerator_converter.cc

@@ -0,0 +1,23 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "shell/common/gin_converters/accelerator_converter.h"
+
+#include <string>
+
+#include "shell/browser/ui/accelerator_util.h"
+
+namespace gin {
+
+// static
+bool Converter<ui::Accelerator>::FromV8(v8::Isolate* isolate,
+                                        v8::Local<v8::Value> val,
+                                        ui::Accelerator* out) {
+  std::string keycode;
+  if (!ConvertFromV8(isolate, val, &keycode))
+    return false;
+  return accelerator_util::StringToAccelerator(keycode, out);
+}
+
+}  // namespace gin

shell/common/gin_converters/accelerator_converter.h

@@ -0,0 +1,25 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef SHELL_COMMON_GIN_CONVERTERS_ACCELERATOR_CONVERTER_H_
+#define SHELL_COMMON_GIN_CONVERTERS_ACCELERATOR_CONVERTER_H_
+
+#include "gin/converter.h"
+
+namespace ui {
+class Accelerator;
+}
+
+namespace gin {
+
+template <>
+struct Converter<ui::Accelerator> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     ui::Accelerator* out);
+};
+
+}  // namespace gin
+
+#endif  // SHELL_COMMON_GIN_CONVERTERS_ACCELERATOR_CONVERTER_H_

shell/common/gin_converters/blink_converter_gin_adapter.h

@@ -12,6 +12,15 @@
 
 namespace gin {
 
+template <>
+struct Converter<blink::WebKeyboardEvent> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     blink::WebKeyboardEvent* out) {
+    return mate::ConvertFromV8(isolate, val, out);
+  }
+};
+
 template <>
 struct Converter<blink::CloneableMessage> {
   static bool FromV8(v8::Isolate* isolate,
@@ -25,6 +34,46 @@ struct Converter<blink::CloneableMessage> {
   }
 };
 
+template <>
+struct Converter<blink::WebDeviceEmulationParams> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     blink::WebDeviceEmulationParams* out) {
+    return mate::ConvertFromV8(isolate, val, out);
+  }
+};
+
+template <>
+struct Converter<blink::WebContextMenuData::MediaType> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const blink::WebContextMenuData::MediaType& in) {
+    return mate::ConvertToV8(isolate, in);
+  }
+};
+
+template <>
+struct Converter<blink::WebContextMenuData::InputFieldType> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const blink::WebContextMenuData::InputFieldType& in) {
+    return mate::ConvertToV8(isolate, in);
+  }
+};
+
+template <>
+struct Converter<network::mojom::ReferrerPolicy> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const network::mojom::ReferrerPolicy& in) {
+    return mate::ConvertToV8(isolate, in);
+  }
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     network::mojom::ReferrerPolicy* out) {
+    return mate::ConvertFromV8(isolate, val, out);
+  }
+};
+
 }  // namespace gin
 
 #endif  // SHELL_COMMON_GIN_CONVERTERS_BLINK_CONVERTER_GIN_ADAPTER_H_

shell/common/gin_converters/content_converter.cc

@@ -0,0 +1,309 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "shell/common/gin_converters/content_converter.h"
+
+#include <string>
+#include <vector>
+
+#include "content/public/browser/native_web_keyboard_event.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/context_menu_params.h"
+#include "shell/browser/api/atom_api_web_contents.h"
+#include "shell/browser/web_contents_permission_helper.h"
+#include "shell/common/gin_converters/blink_converter_gin_adapter.h"
+#include "shell/common/gin_converters/callback_converter.h"
+#include "shell/common/gin_converters/gurl_converter.h"
+#include "shell/common/gin_helper/dictionary.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
+#include "ui/events/keycodes/keyboard_code_conversion.h"
+
+namespace {
+
+void ExecuteCommand(content::WebContents* web_contents,
+                    int action,
+                    const content::CustomContextMenuContext& context) {
+  web_contents->ExecuteCustomContextMenuCommand(action, context);
+}
+
+// Forward declaration for nested recursive call.
+v8::Local<v8::Value> MenuToV8(v8::Isolate* isolate,
+                              content::WebContents* web_contents,
+                              const content::CustomContextMenuContext& context,
+                              const std::vector<content::MenuItem>& menu);
+
+v8::Local<v8::Value> MenuItemToV8(
+    v8::Isolate* isolate,
+    content::WebContents* web_contents,
+    const content::CustomContextMenuContext& context,
+    const content::MenuItem& item) {
+  gin_helper::Dictionary v8_item = gin::Dictionary::CreateEmpty(isolate);
+  switch (item.type) {
+    case content::MenuItem::CHECKABLE_OPTION:
+    case content::MenuItem::GROUP:
+      v8_item.Set("checked", item.checked);
+      FALLTHROUGH;
+    case content::MenuItem::OPTION:
+    case content::MenuItem::SUBMENU:
+      v8_item.Set("label", item.label);
+      v8_item.Set("enabled", item.enabled);
+      FALLTHROUGH;
+    default:
+      v8_item.Set("type", item.type);
+  }
+  if (item.type == content::MenuItem::SUBMENU)
+    v8_item.Set("submenu",
+                MenuToV8(isolate, web_contents, context, item.submenu));
+  else if (item.action > 0)
+    v8_item.Set("click", base::BindRepeating(ExecuteCommand, web_contents,
+                                             item.action, context));
+  return v8_item.GetHandle();
+}
+
+v8::Local<v8::Value> MenuToV8(v8::Isolate* isolate,
+                              content::WebContents* web_contents,
+                              const content::CustomContextMenuContext& context,
+                              const std::vector<content::MenuItem>& menu) {
+  std::vector<v8::Local<v8::Value>> v8_menu;
+  v8_menu.reserve(menu.size());
+  for (const auto& menu_item : menu)
+    v8_menu.push_back(MenuItemToV8(isolate, web_contents, context, menu_item));
+  return gin::ConvertToV8(isolate, v8_menu);
+}
+
+}  // namespace
+
+namespace gin {
+
+template <>
+struct Converter<ui::MenuSourceType> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const ui::MenuSourceType& in) {
+    switch (in) {
+      case ui::MENU_SOURCE_MOUSE:
+        return StringToV8(isolate, "mouse");
+      case ui::MENU_SOURCE_KEYBOARD:
+        return StringToV8(isolate, "keyboard");
+      case ui::MENU_SOURCE_TOUCH:
+        return StringToV8(isolate, "touch");
+      case ui::MENU_SOURCE_TOUCH_EDIT_MENU:
+        return StringToV8(isolate, "touchMenu");
+      default:
+        return StringToV8(isolate, "none");
+    }
+  }
+};
+
+// static
+v8::Local<v8::Value> Converter<content::MenuItem::Type>::ToV8(
+    v8::Isolate* isolate,
+    const content::MenuItem::Type& val) {
+  switch (val) {
+    case content::MenuItem::CHECKABLE_OPTION:
+      return StringToV8(isolate, "checkbox");
+    case content::MenuItem::GROUP:
+      return StringToV8(isolate, "radio");
+    case content::MenuItem::SEPARATOR:
+      return StringToV8(isolate, "separator");
+    case content::MenuItem::SUBMENU:
+      return StringToV8(isolate, "submenu");
+    case content::MenuItem::OPTION:
+    default:
+      return StringToV8(isolate, "normal");
+  }
+}
+
+// static
+v8::Local<v8::Value> Converter<ContextMenuParamsWithWebContents>::ToV8(
+    v8::Isolate* isolate,
+    const ContextMenuParamsWithWebContents& val) {
+  const auto& params = val.first;
+  gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+  dict.Set("x", params.x);
+  dict.Set("y", params.y);
+  dict.Set("linkURL", params.link_url);
+  dict.Set("linkText", params.link_text);
+  dict.Set("pageURL", params.page_url);
+  dict.Set("frameURL", params.frame_url);
+  dict.Set("srcURL", params.src_url);
+  dict.Set("mediaType", params.media_type);
+  dict.Set("mediaFlags", mate::MediaFlagsToV8(isolate, params.media_flags));
+  bool has_image_contents =
+      (params.media_type == blink::WebContextMenuData::kMediaTypeImage) &&
+      params.has_image_contents;
+  dict.Set("hasImageContents", has_image_contents);
+  dict.Set("isEditable", params.is_editable);
+  dict.Set("editFlags", mate::EditFlagsToV8(isolate, params.edit_flags));
+  dict.Set("selectionText", params.selection_text);
+  dict.Set("titleText", params.title_text);
+  dict.Set("misspelledWord", params.misspelled_word);
+  dict.Set("frameCharset", params.frame_charset);
+  dict.Set("inputFieldType", params.input_field_type);
+  dict.Set("menuSourceType", params.source_type);
+
+  if (params.custom_context.is_pepper_menu)
+    dict.Set("menu", MenuToV8(isolate, val.second, params.custom_context,
+                              params.custom_items));
+  return gin::ConvertToV8(isolate, dict);
+}
+
+// static
+bool Converter<blink::mojom::PermissionStatus>::FromV8(
+    v8::Isolate* isolate,
+    v8::Local<v8::Value> val,
+    blink::mojom::PermissionStatus* out) {
+  bool result;
+  if (!ConvertFromV8(isolate, val, &result))
+    return false;
+
+  if (result)
+    *out = blink::mojom::PermissionStatus::GRANTED;
+  else
+    *out = blink::mojom::PermissionStatus::DENIED;
+
+  return true;
+}
+
+// static
+v8::Local<v8::Value> Converter<content::PermissionType>::ToV8(
+    v8::Isolate* isolate,
+    const content::PermissionType& val) {
+  using PermissionType = electron::WebContentsPermissionHelper::PermissionType;
+  switch (val) {
+    case content::PermissionType::MIDI_SYSEX:
+      return StringToV8(isolate, "midiSysex");
+    case content::PermissionType::NOTIFICATIONS:
+      return StringToV8(isolate, "notifications");
+    case content::PermissionType::GEOLOCATION:
+      return StringToV8(isolate, "geolocation");
+    case content::PermissionType::AUDIO_CAPTURE:
+    case content::PermissionType::VIDEO_CAPTURE:
+      return StringToV8(isolate, "media");
+    case content::PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+      return StringToV8(isolate, "mediaKeySystem");
+    case content::PermissionType::MIDI:
+      return StringToV8(isolate, "midi");
+    default:
+      break;
+  }
+
+  if (val == static_cast<content::PermissionType>(PermissionType::POINTER_LOCK))
+    return StringToV8(isolate, "pointerLock");
+  else if (val ==
+           static_cast<content::PermissionType>(PermissionType::FULLSCREEN))
+    return StringToV8(isolate, "fullscreen");
+  else if (val ==
+           static_cast<content::PermissionType>(PermissionType::OPEN_EXTERNAL))
+    return StringToV8(isolate, "openExternal");
+
+  return StringToV8(isolate, "unknown");
+}
+
+// static
+bool Converter<content::StopFindAction>::FromV8(v8::Isolate* isolate,
+                                                v8::Local<v8::Value> val,
+                                                content::StopFindAction* out) {
+  std::string action;
+  if (!ConvertFromV8(isolate, val, &action))
+    return false;
+
+  if (action == "clearSelection")
+    *out = content::STOP_FIND_ACTION_CLEAR_SELECTION;
+  else if (action == "keepSelection")
+    *out = content::STOP_FIND_ACTION_KEEP_SELECTION;
+  else if (action == "activateSelection")
+    *out = content::STOP_FIND_ACTION_ACTIVATE_SELECTION;
+  else
+    return false;
+
+  return true;
+}
+
+// static
+v8::Local<v8::Value> Converter<content::WebContents*>::ToV8(
+    v8::Isolate* isolate,
+    content::WebContents* val) {
+  if (!val)
+    return v8::Null(isolate);
+  return electron::api::WebContents::FromOrCreate(isolate, val).ToV8();
+}
+
+// static
+bool Converter<content::WebContents*>::FromV8(v8::Isolate* isolate,
+                                              v8::Local<v8::Value> val,
+                                              content::WebContents** out) {
+  electron::api::WebContents* web_contents = nullptr;
+  if (!gin::ConvertFromV8(isolate, val, &web_contents) || !web_contents)
+    return false;
+
+  *out = web_contents->web_contents();
+  return true;
+}
+
+// static
+v8::Local<v8::Value> Converter<content::Referrer>::ToV8(
+    v8::Isolate* isolate,
+    const content::Referrer& val) {
+  gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+  dict.Set("url", ConvertToV8(isolate, val.url));
+  dict.Set("policy", ConvertToV8(isolate, val.policy));
+  return gin::ConvertToV8(isolate, dict);
+}
+
+// static
+bool Converter<content::Referrer>::FromV8(v8::Isolate* isolate,
+                                          v8::Local<v8::Value> val,
+                                          content::Referrer* out) {
+  gin_helper::Dictionary dict;
+  if (!ConvertFromV8(isolate, val, &dict))
+    return false;
+
+  if (!dict.Get("url", &out->url))
+    return false;
+
+  if (!dict.Get("policy", &out->policy))
+    return false;
+
+  return true;
+}
+
+// static
+bool Converter<content::NativeWebKeyboardEvent>::FromV8(
+    v8::Isolate* isolate,
+    v8::Local<v8::Value> val,
+    content::NativeWebKeyboardEvent* out) {
+  gin_helper::Dictionary dict;
+  if (!ConvertFromV8(isolate, val, &dict))
+    return false;
+  if (!ConvertFromV8(isolate, val, static_cast<blink::WebKeyboardEvent*>(out)))
+    return false;
+  dict.Get("skipInBrowser", &out->skip_in_browser);
+  return true;
+}
+
+// static
+v8::Local<v8::Value> Converter<content::NativeWebKeyboardEvent>::ToV8(
+    v8::Isolate* isolate,
+    const content::NativeWebKeyboardEvent& in) {
+  gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+
+  if (in.GetType() == blink::WebInputEvent::Type::kRawKeyDown)
+    dict.Set("type", "keyDown");
+  else if (in.GetType() == blink::WebInputEvent::Type::kKeyUp)
+    dict.Set("type", "keyUp");
+  dict.Set("key", ui::KeycodeConverter::DomKeyToKeyString(in.dom_key));
+  dict.Set("code", ui::KeycodeConverter::DomCodeToCodeString(
+                       static_cast<ui::DomCode>(in.dom_code)));
+
+  using Modifiers = blink::WebInputEvent::Modifiers;
+  dict.Set("isAutoRepeat", (in.GetModifiers() & Modifiers::kIsAutoRepeat) != 0);
+  dict.Set("shift", (in.GetModifiers() & Modifiers::kShiftKey) != 0);
+  dict.Set("control", (in.GetModifiers() & Modifiers::kControlKey) != 0);
+  dict.Set("alt", (in.GetModifiers() & Modifiers::kAltKey) != 0);
+  dict.Set("meta", (in.GetModifiers() & Modifiers::kMetaKey) != 0);
+
+  return dict.GetHandle();
+}
+
+}  // namespace gin

shell/common/gin_converters/content_converter.h

@@ -0,0 +1,89 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef SHELL_COMMON_GIN_CONVERTERS_CONTENT_CONVERTER_H_
+#define SHELL_COMMON_GIN_CONVERTERS_CONTENT_CONVERTER_H_
+
+#include <utility>
+
+#include "content/public/browser/permission_type.h"
+#include "content/public/common/menu_item.h"
+#include "content/public/common/referrer.h"
+#include "content/public/common/stop_find_action.h"
+#include "gin/converter.h"
+#include "third_party/blink/public/mojom/permissions/permission_status.mojom.h"
+
+namespace content {
+struct ContextMenuParams;
+struct NativeWebKeyboardEvent;
+class WebContents;
+}  // namespace content
+
+using ContextMenuParamsWithWebContents =
+    std::pair<content::ContextMenuParams, content::WebContents*>;
+
+namespace gin {
+
+template <>
+struct Converter<content::MenuItem::Type> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const content::MenuItem::Type& val);
+};
+
+template <>
+struct Converter<ContextMenuParamsWithWebContents> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const ContextMenuParamsWithWebContents& val);
+};
+
+template <>
+struct Converter<blink::mojom::PermissionStatus> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     blink::mojom::PermissionStatus* out);
+};
+
+template <>
+struct Converter<content::PermissionType> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const content::PermissionType& val);
+};
+
+template <>
+struct Converter<content::StopFindAction> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     content::StopFindAction* out);
+};
+
+template <>
+struct Converter<content::WebContents*> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   content::WebContents* val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     content::WebContents** out);
+};
+
+template <>
+struct Converter<content::Referrer> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const content::Referrer& val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     content::Referrer* out);
+};
+
+template <>
+struct Converter<content::NativeWebKeyboardEvent> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     content::NativeWebKeyboardEvent* out);
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const content::NativeWebKeyboardEvent& in);
+};
+
+}  // namespace gin
+
+#endif  // SHELL_COMMON_GIN_CONVERTERS_CONTENT_CONVERTER_H_

shell/common/gin_converters/image_converter.cc

@@ -27,9 +27,8 @@ bool Converter<gfx::Image>::FromV8(v8::Isolate* isolate,
   if (val->IsNull())
     return true;
 
-  // TODO(deermichel): remove mate:: after dropping mate
-  mate::Handle<electron::api::NativeImage> native_image;
-  if (!mate::ConvertFromV8(isolate, val, &native_image))
+  gin::Handle<electron::api::NativeImage> native_image;
+  if (!gin::ConvertFromV8(isolate, val, &native_image))
     return false;
 
   *out = native_image->image();
@@ -38,7 +37,8 @@ bool Converter<gfx::Image>::FromV8(v8::Isolate* isolate,
 
 v8::Local<v8::Value> Converter<gfx::Image>::ToV8(v8::Isolate* isolate,
                                                  const gfx::Image& val) {
-  return ConvertToV8(isolate, electron::api::NativeImage::Create(isolate, val));
+  return gin::ConvertToV8(isolate,
+                          electron::api::NativeImage::Create(isolate, val));
 }
 
 }  // namespace gin

shell/common/gin_converters/net_converter.cc

@@ -285,6 +285,58 @@ v8::Local<v8::Value> Converter<network::ResourceRequestBody>::ToV8(
   return arr;
 }
 
+// static
+v8::Local<v8::Value>
+Converter<scoped_refptr<network::ResourceRequestBody>>::ToV8(
+    v8::Isolate* isolate,
+    const scoped_refptr<network::ResourceRequestBody>& val) {
+  if (!val)
+    return v8::Null(isolate);
+  return ConvertToV8(isolate, *val);
+}
+
+// static
+bool Converter<scoped_refptr<network::ResourceRequestBody>>::FromV8(
+    v8::Isolate* isolate,
+    v8::Local<v8::Value> val,
+    scoped_refptr<network::ResourceRequestBody>* out) {
+  auto list = std::make_unique<base::ListValue>();
+  if (!ConvertFromV8(isolate, val, list.get()))
+    return false;
+  *out = new network::ResourceRequestBody();
+  for (size_t i = 0; i < list->GetSize(); ++i) {
+    base::DictionaryValue* dict = nullptr;
+    std::string type;
+    if (!list->GetDictionary(i, &dict))
+      return false;
+    dict->GetString("type", &type);
+    if (type == "rawData") {
+      base::Value* bytes = nullptr;
+      dict->GetBinary("bytes", &bytes);
+      (*out)->AppendBytes(
+          reinterpret_cast<const char*>(bytes->GetBlob().data()),
+          base::checked_cast<int>(bytes->GetBlob().size()));
+    } else if (type == "file") {
+      std::string file;
+      int offset = 0, length = -1;
+      double modification_time = 0.0;
+      dict->GetStringWithoutPathExpansion("filePath", &file);
+      dict->GetInteger("offset", &offset);
+      dict->GetInteger("file", &length);
+      dict->GetDouble("modificationTime", &modification_time);
+      (*out)->AppendFileRange(base::FilePath::FromUTF8Unsafe(file),
+                              static_cast<uint64_t>(offset),
+                              static_cast<uint64_t>(length),
+                              base::Time::FromDoubleT(modification_time));
+    } else if (type == "blob") {
+      std::string uuid;
+      dict->GetString("blobUUID", &uuid);
+      (*out)->AppendBlob(uuid);
+    }
+  }
+  return true;
+}
+
 // static
 v8::Local<v8::Value> Converter<network::ResourceRequest>::ToV8(
     v8::Isolate* isolate,

shell/common/gin_converters/net_converter.h

@@ -75,6 +75,16 @@ struct Converter<network::ResourceRequestBody> {
                                    const network::ResourceRequestBody& val);
 };
 
+template <>
+struct Converter<scoped_refptr<network::ResourceRequestBody>> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const scoped_refptr<network::ResourceRequestBody>& val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     scoped_refptr<network::ResourceRequestBody>* out);
+};
+
 template <>
 struct Converter<network::ResourceRequest> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,

shell/common/gin_converters/std_converter.h

@@ -39,6 +39,13 @@ struct Converter<unsigned long> {  // NOLINT(runtime/int)
 };
 #endif
 
+template <>
+struct Converter<std::nullptr_t> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate, std::nullptr_t val) {
+    return v8::Null(isolate);
+  }
+};
+
 template <>
 struct Converter<const char*> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate, const char* val) {