diff --git a/filenames.gni b/filenames.gni
index 249064a7d216..da606270fef7 100644
--- a/filenames.gni
+++ b/filenames.gni
@@ -437,7 +437,6 @@ filenames = {
     "shell/common/api/event_emitter_caller.cc",
     "shell/common/api/event_emitter_caller.h",
     "shell/common/api/features.cc",
-    "shell/common/api/gin_utils.h",
     "shell/common/api/locker.cc",
     "shell/common/api/locker.h",
     "shell/common/api/object_life_monitor.cc",
@@ -475,7 +474,7 @@ filenames = {
     "shell/common/crash_reporter/linux/crash_dump_handler.h",
     "shell/common/crash_reporter/win/crash_service_main.cc",
     "shell/common/crash_reporter/win/crash_service_main.h",
-    "shell/common/gin_converters/callback_converter_gin_adapter.h",
+    "shell/common/gin_converters/callback_converter.h",
     "shell/common/gin_converters/file_dialog_converter.cc",
     "shell/common/gin_converters/file_dialog_converter.h",
     "shell/common/gin_converters/file_path_converter.h",
@@ -489,9 +488,13 @@ filenames = {
     "shell/common/gin_converters/net_converter.h",
     "shell/common/gin_converters/std_converter.h",
     "shell/common/gin_converters/value_converter_gin_adapter.h",
+    "shell/common/gin_helper/callback.cc",
+    "shell/common/gin_helper/callback.h",
     "shell/common/gin_helper/destroyable.cc",
     "shell/common/gin_helper/destroyable.h",
-    "shell/common/gin_util.h",
+    "shell/common/gin_helper/dictionary.h",
+    "shell/common/gin_helper/function_template.cc",
+    "shell/common/gin_helper/function_template.h",
     "shell/common/heap_snapshot.cc",
     "shell/common/heap_snapshot.h",
     "shell/common/key_weak_map.h",
@@ -509,8 +512,8 @@ filenames = {
     "shell/common/native_mate_converters/accelerator_converter.h",
     "shell/common/native_mate_converters/blink_converter.cc",
     "shell/common/native_mate_converters/blink_converter.h",
-    "shell/common/native_mate_converters/callback.cc",
-    "shell/common/native_mate_converters/callback.h",
+    "shell/common/native_mate_converters/callback_converter_deprecated.cc",
+    "shell/common/native_mate_converters/callback_converter_deprecated.h",
     "shell/common/native_mate_converters/content_converter.cc",
     "shell/common/native_mate_converters/content_converter.h",
     "shell/common/native_mate_converters/file_dialog_converter.h",
diff --git a/native_mate/native_mate/arguments.h b/native_mate/native_mate/arguments.h
index e6eb278481c6..d646049b2a34 100644
--- a/native_mate/native_mate/arguments.h
+++ b/native_mate/native_mate/arguments.h
@@ -12,6 +12,10 @@
 #include "base/optional.h"
 #include "native_mate/converter.h"
 
+// =============================== NOTICE ===============================
+// Do not add code here, native_mate is being removed. Any new code
+// should use gin instead.
+
 namespace mate {
 
 // Arguments is a wrapper around v8::FunctionCallbackInfo that integrates
diff --git a/native_mate/native_mate/function_template.h b/native_mate/native_mate/function_template.h
index ec3f4943f43c..1ee65f3a8342 100644
--- a/native_mate/native_mate/function_template.h
+++ b/native_mate/native_mate/function_template.h
@@ -13,6 +13,10 @@
 #include "native_mate/wrappable_base.h"
 #include "v8/include/v8.h"
 
+// =============================== NOTICE ===============================
+// Do not add code here, native_mate is being removed. Any new code
+// should use gin instead.
+
 namespace mate {
 
 enum CreateFunctionTemplateFlags {
diff --git a/shell/browser/api/atom_api_app.cc b/shell/browser/api/atom_api_app.cc
index a9661b3dc0cf..d9e898c4897b 100644
--- a/shell/browser/api/atom_api_app.cc
+++ b/shell/browser/api/atom_api_app.cc
@@ -42,7 +42,7 @@
 #include "shell/browser/relauncher.h"
 #include "shell/common/application_info.h"
 #include "shell/common/atom_command_line.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/native_mate_converters/gurl_converter.h"
 #include "shell/common/native_mate_converters/image_converter.h"
diff --git a/shell/browser/api/atom_api_app.h b/shell/browser/api/atom_api_app.h
index ae4ab5fc0e1f..1e0ce0a9498c 100644
--- a/shell/browser/api/atom_api_app.h
+++ b/shell/browser/api/atom_api_app.h
@@ -28,7 +28,7 @@
 #include "shell/browser/browser.h"
 #include "shell/browser/browser_observer.h"
 #include "shell/common/error_util.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/promise_util.h"
 
 #if defined(USE_NSS_CERTS)
diff --git a/shell/browser/api/atom_api_auto_updater.cc b/shell/browser/api/atom_api_auto_updater.cc
index 9a0a4ab21da2..c9a9b6e9133c 100644
--- a/shell/browser/api/atom_api_auto_updater.cc
+++ b/shell/browser/api/atom_api_auto_updater.cc
@@ -11,7 +11,7 @@
 #include "shell/browser/native_window.h"
 #include "shell/browser/window_list.h"
 #include "shell/common/api/event_emitter_caller.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/node_includes.h"
 
 namespace mate {
diff --git a/shell/browser/api/atom_api_browser_window.cc b/shell/browser/api/atom_api_browser_window.cc
index ca54a90928a5..12abb7320891 100644
--- a/shell/browser/api/atom_api_browser_window.cc
+++ b/shell/browser/api/atom_api_browser_window.cc
@@ -19,7 +19,7 @@
 #include "shell/browser/window_list.h"
 #include "shell/common/api/constructor.h"
 #include "shell/common/color_util.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/value_converter.h"
 #include "shell/common/node_includes.h"
 #include "shell/common/options_switches.h"
diff --git a/shell/browser/api/atom_api_content_tracing.cc b/shell/browser/api/atom_api_content_tracing.cc
index b2c3ffef2161..537228b5f347 100644
--- a/shell/browser/api/atom_api_content_tracing.cc
+++ b/shell/browser/api/atom_api_content_tracing.cc
@@ -12,7 +12,7 @@
 #include "base/threading/thread_restrictions.h"
 #include "content/public/browser/tracing_controller.h"
 #include "native_mate/dictionary.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/native_mate_converters/value_converter.h"
 #include "shell/common/node_includes.h"
diff --git a/shell/browser/api/atom_api_cookies.cc b/shell/browser/api/atom_api_cookies.cc
index f05d00e4486f..1108f479a3cd 100644
--- a/shell/browser/api/atom_api_cookies.cc
+++ b/shell/browser/api/atom_api_cookies.cc
@@ -20,7 +20,7 @@
 #include "net/cookies/cookie_util.h"
 #include "shell/browser/atom_browser_context.h"
 #include "shell/browser/cookie_change_notifier.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/gurl_converter.h"
 #include "shell/common/native_mate_converters/value_converter.h"
 
diff --git a/shell/browser/api/atom_api_debugger.cc b/shell/browser/api/atom_api_debugger.cc
index cd612329ee99..e50b6a342360 100644
--- a/shell/browser/api/atom_api_debugger.cc
+++ b/shell/browser/api/atom_api_debugger.cc
@@ -13,7 +13,7 @@
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/web_contents.h"
 #include "native_mate/dictionary.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/value_converter.h"
 #include "shell/common/node_includes.h"
 
diff --git a/shell/browser/api/atom_api_dialog.cc b/shell/browser/api/atom_api_dialog.cc
index ee8c668639d7..9575b0353921 100644
--- a/shell/browser/api/atom_api_dialog.cc
+++ b/shell/browser/api/atom_api_dialog.cc
@@ -6,15 +6,15 @@
 #include <utility>
 #include <vector>
 
-#include "gin/dictionary.h"
 #include "shell/browser/ui/certificate_trust.h"
 #include "shell/browser/ui/file_dialog.h"
 #include "shell/browser/ui/message_box.h"
-#include "shell/common/api/gin_utils.h"
+#include "shell/common/gin_converters/callback_converter.h"
 #include "shell/common/gin_converters/file_dialog_converter.h"
 #include "shell/common/gin_converters/message_box_converter.h"
 #include "shell/common/gin_converters/native_window_converter.h"
 #include "shell/common/gin_converters/net_converter.h"
+#include "shell/common/gin_helper/dictionary.h"
 #include "shell/common/node_includes.h"
 #include "shell/common/promise_util.h"
 
@@ -87,33 +87,17 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  gin::Dictionary dict(isolate, exports);
-  dict.Set("showMessageBoxSync",
-           gin::ConvertCallbackToV8Leaked(
-               isolate, base::BindRepeating(&ShowMessageBoxSync)));
-  dict.Set("showMessageBox",
-           gin::ConvertCallbackToV8Leaked(
-               isolate, base::BindRepeating(&ShowMessageBox)));
-  dict.Set("showErrorBox",
-           gin::ConvertCallbackToV8Leaked(
-               isolate, base::BindRepeating(&electron::ShowErrorBox)));
-  dict.Set("showOpenDialogSync",
-           gin::ConvertCallbackToV8Leaked(
-               isolate, base::BindRepeating(&ShowOpenDialogSync)));
-  dict.Set("showOpenDialog",
-           gin::ConvertCallbackToV8Leaked(
-               isolate, base::BindRepeating(&ShowOpenDialog)));
-  dict.Set("showSaveDialogSync",
-           gin::ConvertCallbackToV8Leaked(
-               isolate, base::BindRepeating(&ShowSaveDialogSync)));
-  dict.Set("showSaveDialog",
-           gin::ConvertCallbackToV8Leaked(
-               isolate, base::BindRepeating(&ShowSaveDialog)));
+  gin_helper::Dictionary dict(isolate, exports);
+  dict.SetMethod("showMessageBoxSync", &ShowMessageBoxSync);
+  dict.SetMethod("showMessageBox", &ShowMessageBox);
+  dict.SetMethod("showErrorBox", &electron::ShowErrorBox);
+  dict.SetMethod("showOpenDialogSync", &ShowOpenDialogSync);
+  dict.SetMethod("showOpenDialog", &ShowOpenDialog);
+  dict.SetMethod("showSaveDialogSync", &ShowSaveDialogSync);
+  dict.SetMethod("showSaveDialog", &ShowSaveDialog);
 #if defined(OS_MACOSX) || defined(OS_WIN)
-  dict.Set("showCertificateTrustDialog",
-           gin::ConvertCallbackToV8Leaked(
-               isolate,
-               base::BindRepeating(&certificate_trust::ShowCertificateTrust)));
+  dict.SetMethod("showCertificateTrustDialog",
+                 &certificate_trust::ShowCertificateTrust);
 #endif
 }
 
diff --git a/shell/browser/api/atom_api_download_item.cc b/shell/browser/api/atom_api_download_item.cc
index b16d97a848b8..825927e7d00e 100644
--- a/shell/browser/api/atom_api_download_item.cc
+++ b/shell/browser/api/atom_api_download_item.cc
@@ -11,7 +11,7 @@
 #include "native_mate/dictionary.h"
 #include "net/base/filename_util.h"
 #include "shell/browser/atom_browser_main_parts.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/file_dialog_converter.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/native_mate_converters/gurl_converter.h"
diff --git a/shell/browser/api/atom_api_global_shortcut.cc b/shell/browser/api/atom_api_global_shortcut.cc
index 5279e1ad1c4f..09e5f1c387ee 100644
--- a/shell/browser/api/atom_api_global_shortcut.cc
+++ b/shell/browser/api/atom_api_global_shortcut.cc
@@ -12,7 +12,7 @@
 #include "native_mate/dictionary.h"
 #include "shell/browser/api/atom_api_system_preferences.h"
 #include "shell/common/native_mate_converters/accelerator_converter.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/node_includes.h"
 
 #if defined(OS_MACOSX)
diff --git a/shell/browser/api/atom_api_in_app_purchase.cc b/shell/browser/api/atom_api_in_app_purchase.cc
index a90dc00252b7..dba2ff1c71f2 100644
--- a/shell/browser/api/atom_api_in_app_purchase.cc
+++ b/shell/browser/api/atom_api_in_app_purchase.cc
@@ -9,7 +9,7 @@
 #include <vector>
 
 #include "native_mate/dictionary.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/node_includes.h"
 
 namespace mate {
diff --git a/shell/browser/api/atom_api_menu.cc b/shell/browser/api/atom_api_menu.cc
index 436d045e683f..ed322a3df701 100644
--- a/shell/browser/api/atom_api_menu.cc
+++ b/shell/browser/api/atom_api_menu.cc
@@ -11,7 +11,7 @@
 #include "native_mate/object_template_builder.h"
 #include "shell/browser/native_window.h"
 #include "shell/common/native_mate_converters/accelerator_converter.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/image_converter.h"
 #include "shell/common/native_mate_converters/string16_converter.h"
 #include "shell/common/node_includes.h"
diff --git a/shell/browser/api/atom_api_net_log.cc b/shell/browser/api/atom_api_net_log.cc
index 77b10e22ff4d..a81bc3ed900e 100644
--- a/shell/browser/api/atom_api_net_log.cc
+++ b/shell/browser/api/atom_api_net_log.cc
@@ -16,7 +16,7 @@
 #include "native_mate/handle.h"
 #include "shell/browser/atom_browser_context.h"
 #include "shell/browser/net/system_network_context_manager.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/node_includes.h"
 
diff --git a/shell/browser/api/atom_api_power_monitor.cc b/shell/browser/api/atom_api_power_monitor.cc
index ea1835c12296..0ffeb9d235b1 100644
--- a/shell/browser/api/atom_api_power_monitor.cc
+++ b/shell/browser/api/atom_api_power_monitor.cc
@@ -8,7 +8,7 @@
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "native_mate/dictionary.h"
 #include "shell/browser/browser.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/node_includes.h"
 
 namespace mate {
diff --git a/shell/browser/api/atom_api_session.cc b/shell/browser/api/atom_api_session.cc
index d7748bcab878..55df63765352 100644
--- a/shell/browser/api/atom_api_session.cc
+++ b/shell/browser/api/atom_api_session.cc
@@ -53,7 +53,7 @@
 #include "shell/browser/media/media_device_id_salt.h"
 #include "shell/browser/net/cert_verifier_client.h"
 #include "shell/browser/session_preferences.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/content_converter.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/native_mate_converters/gurl_converter.h"
diff --git a/shell/browser/api/atom_api_system_preferences.cc b/shell/browser/api/atom_api_system_preferences.cc
index eb0344ec4a98..504b11676fc7 100644
--- a/shell/browser/api/atom_api_system_preferences.cc
+++ b/shell/browser/api/atom_api_system_preferences.cc
@@ -5,7 +5,7 @@
 #include "shell/browser/api/atom_api_system_preferences.h"
 
 #include "native_mate/dictionary.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/value_converter.h"
 #include "shell/common/node_includes.h"
 #include "ui/gfx/animation/animation.h"
diff --git a/shell/browser/api/atom_api_top_level_window.cc b/shell/browser/api/atom_api_top_level_window.cc
index 8226e32959de..3a5fe1ddf270 100644
--- a/shell/browser/api/atom_api_top_level_window.cc
+++ b/shell/browser/api/atom_api_top_level_window.cc
@@ -16,7 +16,7 @@
 #include "shell/browser/api/atom_api_view.h"
 #include "shell/browser/api/atom_api_web_contents.h"
 #include "shell/common/color_util.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/native_mate_converters/gfx_converter.h"
 #include "shell/common/native_mate_converters/image_converter.h"
diff --git a/shell/browser/api/atom_api_web_request_ns.cc b/shell/browser/api/atom_api_web_request_ns.cc
index c8553d8244ce..a2a06aa557bf 100644
--- a/shell/browser/api/atom_api_web_request_ns.cc
+++ b/shell/browser/api/atom_api_web_request_ns.cc
@@ -16,7 +16,7 @@
 #include "shell/browser/api/atom_api_session.h"
 #include "shell/browser/api/atom_api_web_contents.h"
 #include "shell/browser/atom_browser_context.h"
-#include "shell/common/gin_converters/callback_converter_gin_adapter.h"
+#include "shell/common/gin_converters/callback_converter.h"
 #include "shell/common/gin_converters/gurl_converter.h"
 #include "shell/common/gin_converters/net_converter.h"
 #include "shell/common/gin_converters/std_converter.h"
diff --git a/shell/browser/atom_download_manager_delegate.cc b/shell/browser/atom_download_manager_delegate.cc
index 7218d3294f24..40fa8e19ffec 100644
--- a/shell/browser/atom_download_manager_delegate.cc
+++ b/shell/browser/atom_download_manager_delegate.cc
@@ -23,7 +23,7 @@
 #include "shell/browser/native_window.h"
 #include "shell/browser/ui/file_dialog.h"
 #include "shell/browser/web_contents_preferences.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/options_switches.h"
 
 namespace electron {
diff --git a/shell/browser/net/node_stream_loader.cc b/shell/browser/net/node_stream_loader.cc
index 66b739bbc3c7..d1816fb16e11 100644
--- a/shell/browser/net/node_stream_loader.cc
+++ b/shell/browser/net/node_stream_loader.cc
@@ -8,7 +8,7 @@
 
 #include "mojo/public/cpp/system/string_data_source.h"
 #include "shell/common/api/event_emitter_caller.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 
 #include "shell/common/node_includes.h"
 
diff --git a/shell/common/api/atom_api_asar.cc b/shell/common/api/atom_api_asar.cc
index 84589d8c0817..da3548079df2 100644
--- a/shell/common/api/atom_api_asar.cc
+++ b/shell/common/api/atom_api_asar.cc
@@ -11,7 +11,7 @@
 #include "native_mate/object_template_builder.h"
 #include "native_mate/wrappable.h"
 #include "shell/common/asar/archive.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/node_includes.h"
 #include "third_party/electron_node/src/node_native_module_env.h"
diff --git a/shell/common/api/atom_api_crash_reporter.cc b/shell/common/api/atom_api_crash_reporter.cc
index e53104f11552..2b6019409b26 100644
--- a/shell/common/api/atom_api_crash_reporter.cc
+++ b/shell/common/api/atom_api_crash_reporter.cc
@@ -7,9 +7,9 @@
 
 #include "base/bind.h"
 #include "gin/data_object_builder.h"
-#include "gin/dictionary.h"
 #include "shell/common/crash_reporter/crash_reporter.h"
-#include "shell/common/gin_util.h"
+#include "shell/common/gin_converters/callback_converter.h"
+#include "shell/common/gin_helper/dictionary.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/native_mate_converters/map_converter.h"
 
@@ -41,23 +41,26 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
-  using gin_util::SetMethod;
   auto reporter = base::Unretained(CrashReporter::GetInstance());
-  SetMethod(exports, "start",
-            base::BindRepeating(&CrashReporter::Start, reporter));
-  SetMethod(exports, "addExtraParameter",
-            base::BindRepeating(&CrashReporter::AddExtraParameter, reporter));
-  SetMethod(
-      exports, "removeExtraParameter",
+  gin_helper::Dictionary dict(context->GetIsolate(), exports);
+  dict.SetMethod("start", base::BindRepeating(&CrashReporter::Start, reporter));
+  dict.SetMethod(
+      "addExtraParameter",
+      base::BindRepeating(&CrashReporter::AddExtraParameter, reporter));
+  dict.SetMethod(
+      "removeExtraParameter",
       base::BindRepeating(&CrashReporter::RemoveExtraParameter, reporter));
-  SetMethod(exports, "getParameters",
-            base::BindRepeating(&CrashReporter::GetParameters, reporter));
-  SetMethod(exports, "getUploadedReports",
-            base::BindRepeating(&CrashReporter::GetUploadedReports, reporter));
-  SetMethod(exports, "setUploadToServer",
-            base::BindRepeating(&CrashReporter::SetUploadToServer, reporter));
-  SetMethod(exports, "getUploadToServer",
-            base::BindRepeating(&CrashReporter::GetUploadToServer, reporter));
+  dict.SetMethod("getParameters",
+                 base::BindRepeating(&CrashReporter::GetParameters, reporter));
+  dict.SetMethod(
+      "getUploadedReports",
+      base::BindRepeating(&CrashReporter::GetUploadedReports, reporter));
+  dict.SetMethod(
+      "setUploadToServer",
+      base::BindRepeating(&CrashReporter::SetUploadToServer, reporter));
+  dict.SetMethod(
+      "getUploadToServer",
+      base::BindRepeating(&CrashReporter::GetUploadToServer, reporter));
 }
 
 }  // namespace
diff --git a/shell/common/api/atom_api_shell.cc b/shell/common/api/atom_api_shell.cc
index 2f2645f53a87..771341093b42 100644
--- a/shell/common/api/atom_api_shell.cc
+++ b/shell/common/api/atom_api_shell.cc
@@ -5,7 +5,7 @@
 #include <string>
 
 #include "native_mate/dictionary.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/file_path_converter.h"
 #include "shell/common/native_mate_converters/gurl_converter.h"
 #include "shell/common/native_mate_converters/string16_converter.h"
diff --git a/shell/common/api/gin_utils.h b/shell/common/api/gin_utils.h
deleted file mode 100644
index b3a3978ee8ee..000000000000
--- a/shell/common/api/gin_utils.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2019 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef SHELL_COMMON_API_GIN_UTILS_H_
-#define SHELL_COMMON_API_GIN_UTILS_H_
-
-#include "gin/function_template.h"
-
-namespace gin {
-
-// NOTE: V8 caches FunctionTemplates. Therefore it is user's responsibility
-// to ensure this function is called for one type only ONCE in the program's
-// whole lifetime, otherwise we would have memory leak.
-template <typename Sig>
-v8::Local<v8::Function> ConvertCallbackToV8Leaked(
-    v8::Isolate* isolate,
-    const base::RepeatingCallback<Sig>& callback) {
-  // LOG(WARNING) << "Leaky conversion from callback to V8 triggered.";
-  return gin::CreateFunctionTemplate(isolate, callback)
-      ->GetFunction(isolate->GetCurrentContext())
-      .ToLocalChecked();
-}
-
-}  // namespace gin
-
-#endif  // SHELL_COMMON_API_GIN_UTILS_H_
diff --git a/shell/common/deprecate_util.cc b/shell/common/deprecate_util.cc
index 70307fbf8d45..9edc511e0ac7 100644
--- a/shell/common/deprecate_util.cc
+++ b/shell/common/deprecate_util.cc
@@ -7,7 +7,7 @@
 #include "base/callback.h"
 #include "native_mate/converter.h"
 #include "native_mate/dictionary.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 
 namespace electron {
 
diff --git a/shell/common/gin_converters/callback_converter.h b/shell/common/gin_converters/callback_converter.h
new file mode 100644
index 000000000000..7ec4838dc913
--- /dev/null
+++ b/shell/common/gin_converters/callback_converter.h
@@ -0,0 +1,59 @@
+// Copyright (c) 2019 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_CALLBACK_CONVERTER_H_
+#define SHELL_COMMON_GIN_CONVERTERS_CALLBACK_CONVERTER_H_
+
+#include <utility>
+
+#include "base/callback_helpers.h"
+#include "shell/common/gin_helper/callback.h"
+
+namespace gin {
+
+template <typename Sig>
+struct Converter<base::RepeatingCallback<Sig>> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const base::RepeatingCallback<Sig>& val) {
+    // We don't use CreateFunctionTemplate here because it creates a new
+    // FunctionTemplate everytime, which is cached by V8 and causes leaks.
+    auto translater =
+        base::Bind(&gin_helper::NativeFunctionInvoker<Sig>::Go, val);
+    // To avoid memory leak, we ensure that the callback can only be called
+    // for once.
+    return gin_helper::CreateFunctionFromTranslater(isolate, translater, true);
+  }
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     base::RepeatingCallback<Sig>* out) {
+    if (!val->IsFunction())
+      return false;
+
+    *out = base::BindRepeating(&gin_helper::V8FunctionInvoker<Sig>::Go, isolate,
+                               gin_helper::SafeV8Function(isolate, val));
+    return true;
+  }
+};
+
+template <typename Sig>
+struct Converter<base::OnceCallback<Sig>> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   base::OnceCallback<Sig> in) {
+    return gin::ConvertToV8(isolate,
+                            base::AdaptCallbackForRepeating(std::move(in)));
+  }
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     base::OnceCallback<Sig>* out) {
+    if (!val->IsFunction())
+      return false;
+    *out = base::BindOnce(&gin_helper::V8FunctionInvoker<Sig>::Go, isolate,
+                          gin_helper::SafeV8Function(isolate, val));
+    return true;
+  }
+};
+
+}  // namespace gin
+
+#endif  // SHELL_COMMON_GIN_CONVERTERS_CALLBACK_CONVERTER_H_
diff --git a/shell/common/gin_converters/callback_converter_gin_adapter.h b/shell/common/gin_converters/callback_converter_gin_adapter.h
deleted file mode 100644
index e26ffdff9e55..000000000000
--- a/shell/common/gin_converters/callback_converter_gin_adapter.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2019 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_CALLBACK_CONVERTER_GIN_ADAPTER_H_
-#define SHELL_COMMON_GIN_CONVERTERS_CALLBACK_CONVERTER_GIN_ADAPTER_H_
-
-#include "gin/converter.h"
-#include "shell/common/native_mate_converters/once_callback.h"
-
-// TODO(zcbenz): Move the implementations from native_mate_converters to here.
-
-namespace gin {
-
-template <typename Sig>
-struct Converter<base::RepeatingCallback<Sig>> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const base::RepeatingCallback<Sig>& in) {
-    return mate::ConvertToV8(isolate, in);
-  }
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     base::RepeatingCallback<Sig>* out) {
-    return mate::ConvertFromV8(isolate, val, out);
-  }
-};
-
-template <typename Sig>
-struct Converter<base::OnceCallback<Sig>> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   base::OnceCallback<Sig> in) {
-    return mate::ConvertToV8(isolate, in);
-  }
-
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     base::OnceCallback<Sig>* out) {
-    return mate::ConvertFromV8(isolate, val, out);
-  }
-};
-
-}  // namespace gin
-
-#endif  // SHELL_COMMON_GIN_CONVERTERS_CALLBACK_CONVERTER_GIN_ADAPTER_H_
diff --git a/shell/common/native_mate_converters/callback.cc b/shell/common/gin_helper/callback.cc
similarity index 83%
rename from shell/common/native_mate_converters/callback.cc
rename to shell/common/gin_helper/callback.cc
index 92029f3fc6e1..756dff91a5b7 100644
--- a/shell/common/native_mate_converters/callback.cc
+++ b/shell/common/gin_helper/callback.cc
@@ -1,18 +1,13 @@
-// Copyright (c) 2015 GitHub, Inc. All rights reserved.
+// Copyright (c) 2019 GitHub, Inc. All rights reserved.
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/common/native_mate_converters/callback.h"
-#include "base/stl_util.h"
+#include "shell/common/gin_helper/callback.h"
+
 #include "content/public/browser/browser_thread.h"
+#include "gin/dictionary.h"
 
-#include "native_mate/dictionary.h"
-
-using content::BrowserThread;
-
-namespace mate {
-
-namespace internal {
+namespace gin_helper {
 
 namespace {
 
@@ -41,7 +36,7 @@ v8::Persistent<v8::FunctionTemplate> g_call_translater;
 
 void CallTranslater(v8::Local<v8::External> external,
                     v8::Local<v8::Object> state,
-                    mate::Arguments* args) {
+                    gin::Arguments* args) {
   // Whether the callback should only be called for once.
   v8::Isolate* isolate = args->isolate();
   auto context = isolate->GetCurrentContext();
@@ -52,7 +47,7 @@ void CallTranslater(v8::Local<v8::External> external,
   if (one_time) {
     auto called_symbol = mate::StringToSymbol(isolate, "called");
     if (state->Has(context, called_symbol).ToChecked()) {
-      args->ThrowError("callback can only be called for once");
+      args->ThrowTypeError("callback can only be called for once");
       return;
     } else {
       state->Set(context, called_symbol, v8::Boolean::New(isolate, true))
@@ -74,9 +69,10 @@ void CallTranslater(v8::Local<v8::External> external,
 struct DeleteOnUIThread {
   template <typename T>
   static void Destruct(const T* x) {
-    if (Locker::IsBrowserProcess() &&
-        !BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-      BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, x);
+    if (mate::Locker::IsBrowserProcess() &&
+        !content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
+      content::BrowserThread::DeleteSoon(content::BrowserThread::UI, FROM_HERE,
+                                         x);
     } else {
       delete x;
     }
@@ -124,21 +120,21 @@ v8::Local<v8::Value> CreateFunctionFromTranslater(v8::Isolate* isolate,
                                                   bool one_time) {
   // The FunctionTemplate is cached.
   if (g_call_translater.IsEmpty())
-    g_call_translater.Reset(isolate,
-                            mate::CreateFunctionTemplate(
-                                isolate, base::BindRepeating(&CallTranslater)));
+    g_call_translater.Reset(
+        isolate,
+        CreateFunctionTemplate(isolate, base::BindRepeating(&CallTranslater)));
 
   v8::Local<v8::FunctionTemplate> call_translater =
       v8::Local<v8::FunctionTemplate>::New(isolate, g_call_translater);
   auto* holder = new TranslaterHolder(isolate);
   holder->translater = translater;
-  Dictionary state = mate::Dictionary::CreateEmpty(isolate);
+  gin::Dictionary state = gin::Dictionary::CreateEmpty(isolate);
   if (one_time)
     state.Set("oneTime", true);
   auto context = isolate->GetCurrentContext();
   return BindFunctionWith(
       isolate, context, call_translater->GetFunction(context).ToLocalChecked(),
-      holder->handle.Get(isolate), state.GetHandle());
+      holder->handle.Get(isolate), gin::ConvertToV8(isolate, state));
 }
 
 // func.bind(func, arg1).
@@ -158,6 +154,4 @@ v8::Local<v8::Value> BindFunctionWith(v8::Isolate* isolate,
       .ToLocalChecked();
 }
 
-}  // namespace internal
-
-}  // namespace mate
+}  // namespace gin_helper
diff --git a/shell/common/gin_helper/callback.h b/shell/common/gin_helper/callback.h
new file mode 100644
index 000000000000..2c8a1ecba6de
--- /dev/null
+++ b/shell/common/gin_helper/callback.h
@@ -0,0 +1,163 @@
+// Copyright (c) 2019 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef SHELL_COMMON_GIN_HELPER_CALLBACK_H_
+#define SHELL_COMMON_GIN_HELPER_CALLBACK_H_
+
+#include <utility>
+#include <vector>
+
+#include "base/bind.h"
+#include "shell/common/api/locker.h"
+#include "shell/common/gin_helper/function_template.h"
+
+// Implements safe convertions between JS functions and base::Callback.
+
+namespace gin {
+
+// Make it possible to convert move-only types.
+template <typename T>
+v8::Local<v8::Value> ConvertToV8(v8::Isolate* isolate, T&& input) {
+  return Converter<typename std::remove_reference<T>::type>::ToV8(
+      isolate, std::move(input));
+}
+
+}  // namespace gin
+
+namespace gin_helper {
+
+template <typename T>
+class RefCountedGlobal;
+
+// Manages the V8 function with RAII.
+class SafeV8Function {
+ public:
+  SafeV8Function(v8::Isolate* isolate, v8::Local<v8::Value> value);
+  SafeV8Function(const SafeV8Function& other);
+  ~SafeV8Function();
+
+  bool IsAlive() const;
+  v8::Local<v8::Function> NewHandle(v8::Isolate* isolate) const;
+
+ private:
+  scoped_refptr<RefCountedGlobal<v8::Function>> v8_function_;
+};
+
+// Helper to invoke a V8 function with C++ parameters.
+template <typename Sig>
+struct V8FunctionInvoker {};
+
+template <typename... ArgTypes>
+struct V8FunctionInvoker<v8::Local<v8::Value>(ArgTypes...)> {
+  static v8::Local<v8::Value> Go(v8::Isolate* isolate,
+                                 const SafeV8Function& function,
+                                 ArgTypes... raw) {
+    mate::Locker locker(isolate);
+    v8::EscapableHandleScope handle_scope(isolate);
+    if (!function.IsAlive())
+      return v8::Null(isolate);
+    v8::MicrotasksScope script_scope(isolate,
+                                     v8::MicrotasksScope::kRunMicrotasks);
+    v8::Local<v8::Function> holder = function.NewHandle(isolate);
+    v8::Local<v8::Context> context = holder->CreationContext();
+    v8::Context::Scope context_scope(context);
+    std::vector<v8::Local<v8::Value>> args{
+        gin::ConvertToV8(isolate, std::forward<ArgTypes>(raw))...};
+    v8::MaybeLocal<v8::Value> ret = holder->Call(
+        context, holder, args.size(), args.empty() ? nullptr : &args.front());
+    if (ret.IsEmpty())
+      return v8::Undefined(isolate);
+    else
+      return handle_scope.Escape(ret.ToLocalChecked());
+  }
+};
+
+template <typename... ArgTypes>
+struct V8FunctionInvoker<void(ArgTypes...)> {
+  static void Go(v8::Isolate* isolate,
+                 const SafeV8Function& function,
+                 ArgTypes... raw) {
+    mate::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);
+    if (!function.IsAlive())
+      return;
+    v8::MicrotasksScope script_scope(isolate,
+                                     v8::MicrotasksScope::kRunMicrotasks);
+    v8::Local<v8::Function> holder = function.NewHandle(isolate);
+    v8::Local<v8::Context> context = holder->CreationContext();
+    v8::Context::Scope context_scope(context);
+    std::vector<v8::Local<v8::Value>> args{
+        gin::ConvertToV8(isolate, std::forward<ArgTypes>(raw))...};
+    holder
+        ->Call(context, holder, args.size(),
+               args.empty() ? nullptr : &args.front())
+        .IsEmpty();
+  }
+};
+
+template <typename ReturnType, typename... ArgTypes>
+struct V8FunctionInvoker<ReturnType(ArgTypes...)> {
+  static ReturnType Go(v8::Isolate* isolate,
+                       const SafeV8Function& function,
+                       ArgTypes... raw) {
+    mate::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);
+    ReturnType ret = ReturnType();
+    if (!function.IsAlive())
+      return ret;
+    v8::MicrotasksScope script_scope(isolate,
+                                     v8::MicrotasksScope::kRunMicrotasks);
+    v8::Local<v8::Function> holder = function.NewHandle(isolate);
+    v8::Local<v8::Context> context = holder->CreationContext();
+    v8::Context::Scope context_scope(context);
+    std::vector<v8::Local<v8::Value>> args{
+        gin::ConvertToV8(isolate, std::forward<ArgTypes>(raw))...};
+    v8::Local<v8::Value> result;
+    auto maybe_result = holder->Call(context, holder, args.size(),
+                                     args.empty() ? nullptr : &args.front());
+    if (maybe_result.ToLocal(&result))
+      gin::Converter<ReturnType>::FromV8(isolate, result, &ret);
+    return ret;
+  }
+};
+
+// Helper to pass a C++ funtion to JavaScript.
+using Translater = base::Callback<void(gin::Arguments* args)>;
+v8::Local<v8::Value> CreateFunctionFromTranslater(v8::Isolate* isolate,
+                                                  const Translater& translater,
+                                                  bool one_time);
+v8::Local<v8::Value> BindFunctionWith(v8::Isolate* isolate,
+                                      v8::Local<v8::Context> context,
+                                      v8::Local<v8::Function> func,
+                                      v8::Local<v8::Value> arg1,
+                                      v8::Local<v8::Value> arg2);
+
+// Calls callback with Arguments.
+template <typename Sig>
+struct NativeFunctionInvoker {};
+
+template <typename ReturnType, typename... ArgTypes>
+struct NativeFunctionInvoker<ReturnType(ArgTypes...)> {
+  static void Go(base::Callback<ReturnType(ArgTypes...)> val,
+                 gin::Arguments* args) {
+    using Indices = typename IndicesGenerator<sizeof...(ArgTypes)>::type;
+    Invoker<Indices, ArgTypes...> invoker(args, 0);
+    if (invoker.IsOK())
+      invoker.DispatchToCallback(val);
+  }
+};
+
+// Convert a callback to V8 without the call number limitation, this can easily
+// cause memory leaks so use it with caution.
+template <typename Sig>
+v8::Local<v8::Value> CallbackToV8Leaked(
+    v8::Isolate* isolate,
+    const base::RepeatingCallback<Sig>& val) {
+  Translater translater = base::Bind(&NativeFunctionInvoker<Sig>::Go, val);
+  return CreateFunctionFromTranslater(isolate, translater, false);
+}
+
+}  // namespace gin_helper
+
+#endif  // SHELL_COMMON_GIN_HELPER_CALLBACK_H_
diff --git a/shell/common/gin_helper/dictionary.h b/shell/common/gin_helper/dictionary.h
new file mode 100644
index 000000000000..f3f61a098c63
--- /dev/null
+++ b/shell/common/gin_helper/dictionary.h
@@ -0,0 +1,84 @@
+// Copyright (c) 2019 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_HELPER_DICTIONARY_H_
+#define SHELL_COMMON_GIN_HELPER_DICTIONARY_H_
+
+#include <type_traits>
+
+#include "base/bind.h"
+#include "gin/dictionary.h"
+#include "shell/common/gin_helper/function_template.h"
+
+namespace gin_helper {
+
+// Base template - used only for non-member function pointers. Other types
+// either go to one of the below specializations, or go here and fail to compile
+// because of base::Bind().
+template <typename T, typename Enable = void>
+struct CallbackTraits {
+  static v8::Local<v8::FunctionTemplate> CreateTemplate(v8::Isolate* isolate,
+                                                        T callback) {
+    return CreateFunctionTemplate(isolate, base::BindRepeating(callback));
+  }
+};
+
+// Specialization for base::Callback.
+template <typename T>
+struct CallbackTraits<base::Callback<T>> {
+  static v8::Local<v8::FunctionTemplate> CreateTemplate(
+      v8::Isolate* isolate,
+      const base::RepeatingCallback<T>& callback) {
+    return CreateFunctionTemplate(isolate, callback);
+  }
+};
+
+// Specialization for member function pointers. We need to handle this case
+// specially because the first parameter for callbacks to MFP should typically
+// come from the the JavaScript "this" object the function was called on, not
+// from the first normal parameter.
+template <typename T>
+struct CallbackTraits<
+    T,
+    typename std::enable_if<std::is_member_function_pointer<T>::value>::type> {
+  static v8::Local<v8::FunctionTemplate> CreateTemplate(v8::Isolate* isolate,
+                                                        T callback) {
+    int flags = HolderIsFirstArgument;
+    return CreateFunctionTemplate(isolate, base::BindRepeating(callback),
+                                  flags);
+  }
+};
+
+// Adds a few more extends methods to gin::Dictionary.
+//
+// Note that as the destructor of gin::Dictionary is not virtual, and we want to
+// convert between 2 types, we must not add any member.
+class Dictionary : public gin::Dictionary {
+ public:
+  Dictionary(v8::Isolate* isolate, v8::Local<v8::Object> object)
+      : gin::Dictionary(isolate, object) {}
+
+  template <typename T>
+  bool SetMethod(base::StringPiece key, const T& callback) {
+    auto context = isolate()->GetCurrentContext();
+    auto templ = CallbackTraits<T>::CreateTemplate(isolate(), callback);
+    return GetHandle()
+        ->Set(context, gin::StringToV8(isolate(), key),
+              templ->GetFunction(context).ToLocalChecked())
+        .ToChecked();
+  }
+
+  v8::Local<v8::Object> GetHandle() const {
+    return gin::ConvertToV8(isolate(),
+                            *static_cast<const gin::Dictionary*>(this))
+        .As<v8::Object>();
+  }
+
+ private:
+  // DO NOT ADD ANY DATA MEMBER.
+};
+
+}  // namespace gin_helper
+
+#endif  // SHELL_COMMON_GIN_HELPER_DICTIONARY_H_
diff --git a/shell/common/gin_helper/function_template.cc b/shell/common/gin_helper/function_template.cc
new file mode 100644
index 000000000000..9d844bff35b6
--- /dev/null
+++ b/shell/common/gin_helper/function_template.cc
@@ -0,0 +1,36 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE.chromium file.
+
+#include "shell/common/gin_helper/function_template.h"
+
+namespace gin_helper {
+
+CallbackHolderBase::CallbackHolderBase(v8::Isolate* isolate)
+    : v8_ref_(isolate, v8::External::New(isolate, this)) {
+  v8_ref_.SetWeak(this, &CallbackHolderBase::FirstWeakCallback,
+                  v8::WeakCallbackType::kParameter);
+}
+
+CallbackHolderBase::~CallbackHolderBase() {
+  DCHECK(v8_ref_.IsEmpty());
+}
+
+v8::Local<v8::External> CallbackHolderBase::GetHandle(v8::Isolate* isolate) {
+  return v8::Local<v8::External>::New(isolate, v8_ref_);
+}
+
+// static
+void CallbackHolderBase::FirstWeakCallback(
+    const v8::WeakCallbackInfo<CallbackHolderBase>& data) {
+  data.GetParameter()->v8_ref_.Reset();
+  data.SetSecondPassCallback(SecondWeakCallback);
+}
+
+// static
+void CallbackHolderBase::SecondWeakCallback(
+    const v8::WeakCallbackInfo<CallbackHolderBase>& data) {
+  delete data.GetParameter();
+}
+
+}  // namespace gin_helper
diff --git a/shell/common/gin_helper/function_template.h b/shell/common/gin_helper/function_template.h
new file mode 100644
index 000000000000..a685eef76cb9
--- /dev/null
+++ b/shell/common/gin_helper/function_template.h
@@ -0,0 +1,263 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE.chromium file.
+
+#ifndef SHELL_COMMON_GIN_HELPER_FUNCTION_TEMPLATE_H_
+#define SHELL_COMMON_GIN_HELPER_FUNCTION_TEMPLATE_H_
+
+#include "base/callback.h"
+#include "gin/arguments.h"
+#include "shell/common/error_util.h"
+#include "shell/common/gin_helper/destroyable.h"
+
+// This file is forked from gin/function_template.h with 2 differences:
+// 1. Support for additional types of arguments.
+// 2. Support for warning using destroyed objects.
+//
+// TODO(zcbenz): We should seek to remove this file after removing native_mate.
+
+namespace gin_helper {
+
+enum CreateFunctionTemplateFlags {
+  HolderIsFirstArgument = 1 << 0,
+};
+
+template <typename T>
+struct CallbackParamTraits {
+  typedef T LocalType;
+};
+template <typename T>
+struct CallbackParamTraits<const T&> {
+  typedef T LocalType;
+};
+template <typename T>
+struct CallbackParamTraits<const T*> {
+  typedef T* LocalType;
+};
+
+// CallbackHolder and CallbackHolderBase are used to pass a base::Callback from
+// CreateFunctionTemplate through v8 (via v8::FunctionTemplate) to
+// DispatchToCallback, where it is invoked.
+
+// This simple base class is used so that we can share a single object template
+// among every CallbackHolder instance.
+class CallbackHolderBase {
+ public:
+  v8::Local<v8::External> GetHandle(v8::Isolate* isolate);
+
+ protected:
+  explicit CallbackHolderBase(v8::Isolate* isolate);
+  virtual ~CallbackHolderBase();
+
+ private:
+  static void FirstWeakCallback(
+      const v8::WeakCallbackInfo<CallbackHolderBase>& data);
+  static void SecondWeakCallback(
+      const v8::WeakCallbackInfo<CallbackHolderBase>& data);
+
+  v8::Global<v8::External> v8_ref_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallbackHolderBase);
+};
+
+template <typename Sig>
+class CallbackHolder : public CallbackHolderBase {
+ public:
+  CallbackHolder(v8::Isolate* isolate,
+                 const base::Callback<Sig>& callback,
+                 int flags)
+      : CallbackHolderBase(isolate), callback(callback), flags(flags) {}
+  base::Callback<Sig> callback;
+  int flags = 0;
+
+ private:
+  virtual ~CallbackHolder() = default;
+
+  DISALLOW_COPY_AND_ASSIGN(CallbackHolder);
+};
+
+template <typename T>
+bool GetNextArgument(gin::Arguments* args,
+                     int create_flags,
+                     bool is_first,
+                     T* result) {
+  if (is_first && (create_flags & HolderIsFirstArgument) != 0) {
+    return args->GetHolder(result);
+  } else {
+    return args->GetNext(result);
+  }
+}
+
+// For advanced use cases, we allow callers to request the unparsed Arguments
+// object and poke around in it directly.
+inline bool GetNextArgument(gin::Arguments* args,
+                            int create_flags,
+                            bool is_first,
+                            gin::Arguments** result) {
+  *result = args;
+  return true;
+}
+
+// It's common for clients to just need the isolate, so we make that easy.
+inline bool GetNextArgument(gin::Arguments* args,
+                            int create_flags,
+                            bool is_first,
+                            v8::Isolate** result) {
+  *result = args->isolate();
+  return true;
+}
+
+// Allow clients to pass a util::Error to throw errors if they
+// don't need the full gin::Arguments
+inline bool GetNextArgument(gin::Arguments* args,
+                            int create_flags,
+                            bool is_first,
+                            electron::util::ErrorThrower* result) {
+  *result = electron::util::ErrorThrower(args->isolate());
+  return true;
+}
+
+// Classes for generating and storing an argument pack of integer indices
+// (based on well-known "indices trick", see: http://goo.gl/bKKojn):
+template <size_t... indices>
+struct IndicesHolder {};
+
+template <size_t requested_index, size_t... indices>
+struct IndicesGenerator {
+  using type = typename IndicesGenerator<requested_index - 1,
+                                         requested_index - 1,
+                                         indices...>::type;
+};
+template <size_t... indices>
+struct IndicesGenerator<0, indices...> {
+  using type = IndicesHolder<indices...>;
+};
+
+// Class template for extracting and storing single argument for callback
+// at position |index|.
+template <size_t index, typename ArgType>
+struct ArgumentHolder {
+  using ArgLocalType = typename CallbackParamTraits<ArgType>::LocalType;
+
+  ArgLocalType value;
+  bool ok = false;
+
+  ArgumentHolder(gin::Arguments* args, int create_flags) {
+    v8::Local<v8::Object> holder;
+    if (index == 0 && (create_flags & HolderIsFirstArgument) &&
+        args->GetHolder(&holder) &&
+        gin_helper::Destroyable::IsDestroyed(holder)) {
+      args->ThrowTypeError("Object has been destroyed");
+      return;
+    }
+    ok = GetNextArgument(args, create_flags, index == 0, &value);
+    if (!ok) {
+      // Ideally we would include the expected c++ type in the error
+      // message which we can access via typeid(ArgType).name()
+      // however we compile with no-rtti, which disables typeid.
+      args->ThrowError();
+    }
+  }
+};
+
+// Class template for converting arguments from JavaScript to C++ and running
+// the callback with them.
+template <typename IndicesType, typename... ArgTypes>
+class Invoker {};
+
+template <size_t... indices, typename... ArgTypes>
+class Invoker<IndicesHolder<indices...>, ArgTypes...>
+    : public ArgumentHolder<indices, ArgTypes>... {
+ public:
+  // Invoker<> inherits from ArgumentHolder<> for each argument.
+  // C++ has always been strict about the class initialization order,
+  // so it is guaranteed ArgumentHolders will be initialized (and thus, will
+  // extract arguments from Arguments) in the right order.
+  Invoker(gin::Arguments* args, int create_flags)
+      : ArgumentHolder<indices, ArgTypes>(args, create_flags)..., args_(args) {
+    // GCC thinks that create_flags is going unused, even though the
+    // expansion above clearly makes use of it. Per jyasskin@, casting
+    // to void is the commonly accepted way to convince the compiler
+    // that you're actually using a parameter/varible.
+    (void)create_flags;
+  }
+
+  bool IsOK() { return And(ArgumentHolder<indices, ArgTypes>::ok...); }
+
+  template <typename ReturnType>
+  void DispatchToCallback(base::Callback<ReturnType(ArgTypes...)> callback) {
+    v8::MicrotasksScope script_scope(args_->isolate(),
+                                     v8::MicrotasksScope::kRunMicrotasks);
+    args_->Return(callback.Run(ArgumentHolder<indices, ArgTypes>::value...));
+  }
+
+  // In C++, you can declare the function foo(void), but you can't pass a void
+  // expression to foo. As a result, we must specialize the case of Callbacks
+  // that have the void return type.
+  void DispatchToCallback(base::Callback<void(ArgTypes...)> callback) {
+    v8::MicrotasksScope script_scope(args_->isolate(),
+                                     v8::MicrotasksScope::kRunMicrotasks);
+    callback.Run(ArgumentHolder<indices, ArgTypes>::value...);
+  }
+
+ private:
+  static bool And() { return true; }
+  template <typename... T>
+  static bool And(bool arg1, T... args) {
+    return arg1 && And(args...);
+  }
+
+  gin::Arguments* args_;
+};
+
+// DispatchToCallback converts all the JavaScript arguments to C++ types and
+// invokes the base::Callback.
+template <typename Sig>
+struct Dispatcher {};
+
+template <typename ReturnType, typename... ArgTypes>
+struct Dispatcher<ReturnType(ArgTypes...)> {
+  static void DispatchToCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info) {
+    gin::Arguments args(info);
+    v8::Local<v8::External> v8_holder;
+    args.GetData(&v8_holder);
+    CallbackHolderBase* holder_base =
+        reinterpret_cast<CallbackHolderBase*>(v8_holder->Value());
+
+    typedef CallbackHolder<ReturnType(ArgTypes...)> HolderT;
+    HolderT* holder = static_cast<HolderT*>(holder_base);
+
+    using Indices = typename IndicesGenerator<sizeof...(ArgTypes)>::type;
+    Invoker<Indices, ArgTypes...> invoker(&args, holder->flags);
+    if (invoker.IsOK())
+      invoker.DispatchToCallback(holder->callback);
+  }
+};
+
+// CreateFunctionTemplate creates a v8::FunctionTemplate that will create
+// JavaScript functions that execute a provided C++ function or base::Callback.
+// JavaScript arguments are automatically converted via gin::Converter, as is
+// the return value of the C++ function, if any.
+//
+// NOTE: V8 caches FunctionTemplates for a lifetime of a web page for its own
+// internal reasons, thus it is generally a good idea to cache the template
+// returned by this function.  Otherwise, repeated method invocations from JS
+// will create substantial memory leaks. See http://crbug.com/463487.
+template <typename Sig>
+v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
+    v8::Isolate* isolate,
+    const base::Callback<Sig> callback,
+    int callback_flags = 0) {
+  typedef CallbackHolder<Sig> HolderT;
+  HolderT* holder = new HolderT(isolate, callback, callback_flags);
+
+  return v8::FunctionTemplate::New(isolate,
+                                   &Dispatcher<Sig>::DispatchToCallback,
+                                   gin::ConvertToV8<v8::Local<v8::External>>(
+                                       isolate, holder->GetHandle(isolate)));
+}
+
+}  // namespace gin_helper
+
+#endif  // SHELL_COMMON_GIN_HELPER_FUNCTION_TEMPLATE_H_
diff --git a/shell/common/gin_util.h b/shell/common/gin_util.h
deleted file mode 100644
index 3cb286444a4c..000000000000
--- a/shell/common/gin_util.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2018 Slack Technologies, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef SHELL_COMMON_GIN_UTIL_H_
-#define SHELL_COMMON_GIN_UTIL_H_
-
-#include "gin/converter.h"
-#include "gin/function_template.h"
-
-namespace gin_util {
-
-template <typename T>
-bool SetMethod(v8::Local<v8::Object> recv,
-               base::StringPiece key,
-               const T& callback) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  auto context = isolate->GetCurrentContext();
-  return recv
-      ->Set(context, gin::StringToV8(isolate, key),
-            gin::CreateFunctionTemplate(isolate, callback)
-                ->GetFunction(context)
-                .ToLocalChecked())
-      .ToChecked();
-}
-
-}  // namespace gin_util
-
-#endif  // SHELL_COMMON_GIN_UTIL_H_
diff --git a/shell/common/native_mate_converters/callback_converter_deprecated.cc b/shell/common/native_mate_converters/callback_converter_deprecated.cc
new file mode 100644
index 000000000000..baea655485e1
--- /dev/null
+++ b/shell/common/native_mate_converters/callback_converter_deprecated.cc
@@ -0,0 +1,163 @@
+// Copyright (c) 2015 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
+#include "base/stl_util.h"
+#include "content/public/browser/browser_thread.h"
+
+#include "native_mate/dictionary.h"
+
+using content::BrowserThread;
+
+namespace mate {
+
+namespace internal {
+
+namespace {
+
+struct TranslaterHolder {
+  explicit TranslaterHolder(v8::Isolate* isolate)
+      : handle(isolate, v8::External::New(isolate, this)) {
+    handle.SetWeak(this, &GC, v8::WeakCallbackType::kFinalizer);
+  }
+  ~TranslaterHolder() {
+    if (!handle.IsEmpty()) {
+      handle.ClearWeak();
+      handle.Reset();
+    }
+  }
+
+  static void GC(const v8::WeakCallbackInfo<TranslaterHolder>& data) {
+    delete data.GetParameter();
+  }
+
+  v8::Global<v8::External> handle;
+  Translater translater;
+};
+
+// Cached JavaScript version of |CallTranslater|.
+v8::Persistent<v8::FunctionTemplate> g_call_translater;
+
+void CallTranslater(v8::Local<v8::External> external,
+                    v8::Local<v8::Object> state,
+                    mate::Arguments* args) {
+  // Whether the callback should only be called for once.
+  v8::Isolate* isolate = args->isolate();
+  auto context = isolate->GetCurrentContext();
+  bool one_time =
+      state->Has(context, mate::StringToSymbol(isolate, "oneTime")).ToChecked();
+
+  // Check if the callback has already been called.
+  if (one_time) {
+    auto called_symbol = mate::StringToSymbol(isolate, "called");
+    if (state->Has(context, called_symbol).ToChecked()) {
+      args->ThrowError("callback can only be called for once");
+      return;
+    } else {
+      state->Set(context, called_symbol, v8::Boolean::New(isolate, true))
+          .ToChecked();
+    }
+  }
+
+  TranslaterHolder* holder = static_cast<TranslaterHolder*>(external->Value());
+  holder->translater.Run(args);
+
+  // Free immediately for one-time callback.
+  if (one_time)
+    delete holder;
+}
+
+}  // namespace
+
+// Destroy the class on UI thread when possible.
+struct DeleteOnUIThread {
+  template <typename T>
+  static void Destruct(const T* x) {
+    if (Locker::IsBrowserProcess() &&
+        !BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+      BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, x);
+    } else {
+      delete x;
+    }
+  }
+};
+
+// Like v8::Global, but ref-counted.
+template <typename T>
+class RefCountedGlobal
+    : public base::RefCountedThreadSafe<RefCountedGlobal<T>, DeleteOnUIThread> {
+ public:
+  RefCountedGlobal(v8::Isolate* isolate, v8::Local<v8::Value> value)
+      : handle_(isolate, v8::Local<T>::Cast(value)) {}
+
+  bool IsAlive() const { return !handle_.IsEmpty(); }
+
+  v8::Local<T> NewHandle(v8::Isolate* isolate) const {
+    return v8::Local<T>::New(isolate, handle_);
+  }
+
+ private:
+  v8::Global<T> handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedGlobal);
+};
+
+SafeV8Function::SafeV8Function(v8::Isolate* isolate, v8::Local<v8::Value> value)
+    : v8_function_(new RefCountedGlobal<v8::Function>(isolate, value)) {}
+
+SafeV8Function::SafeV8Function(const SafeV8Function& other)
+    : v8_function_(other.v8_function_) {}
+
+SafeV8Function::~SafeV8Function() {}
+
+bool SafeV8Function::IsAlive() const {
+  return v8_function_.get() && v8_function_->IsAlive();
+}
+
+v8::Local<v8::Function> SafeV8Function::NewHandle(v8::Isolate* isolate) const {
+  return v8_function_->NewHandle(isolate);
+}
+
+v8::Local<v8::Value> CreateFunctionFromTranslater(v8::Isolate* isolate,
+                                                  const Translater& translater,
+                                                  bool one_time) {
+  // The FunctionTemplate is cached.
+  if (g_call_translater.IsEmpty())
+    g_call_translater.Reset(isolate,
+                            mate::CreateFunctionTemplate(
+                                isolate, base::BindRepeating(&CallTranslater)));
+
+  v8::Local<v8::FunctionTemplate> call_translater =
+      v8::Local<v8::FunctionTemplate>::New(isolate, g_call_translater);
+  auto* holder = new TranslaterHolder(isolate);
+  holder->translater = translater;
+  Dictionary state = mate::Dictionary::CreateEmpty(isolate);
+  if (one_time)
+    state.Set("oneTime", true);
+  auto context = isolate->GetCurrentContext();
+  return BindFunctionWith(
+      isolate, context, call_translater->GetFunction(context).ToLocalChecked(),
+      holder->handle.Get(isolate), state.GetHandle());
+}
+
+// func.bind(func, arg1).
+// NB(zcbenz): Using C++11 version crashes VS.
+v8::Local<v8::Value> BindFunctionWith(v8::Isolate* isolate,
+                                      v8::Local<v8::Context> context,
+                                      v8::Local<v8::Function> func,
+                                      v8::Local<v8::Value> arg1,
+                                      v8::Local<v8::Value> arg2) {
+  v8::MaybeLocal<v8::Value> bind =
+      func->Get(context, mate::StringToV8(isolate, "bind"));
+  CHECK(!bind.IsEmpty());
+  v8::Local<v8::Function> bind_func =
+      v8::Local<v8::Function>::Cast(bind.ToLocalChecked());
+  v8::Local<v8::Value> converted[] = {func, arg1, arg2};
+  return bind_func->Call(context, func, base::size(converted), converted)
+      .ToLocalChecked();
+}
+
+}  // namespace internal
+
+}  // namespace mate
diff --git a/shell/common/native_mate_converters/callback.h b/shell/common/native_mate_converters/callback_converter_deprecated.h
similarity index 94%
rename from shell/common/native_mate_converters/callback.h
rename to shell/common/native_mate_converters/callback_converter_deprecated.h
index df8f19ae7ec0..7edd21bde6ac 100644
--- a/shell/common/native_mate_converters/callback.h
+++ b/shell/common/native_mate_converters/callback_converter_deprecated.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_COMMON_NATIVE_MATE_CONVERTERS_CALLBACK_H_
-#define SHELL_COMMON_NATIVE_MATE_CONVERTERS_CALLBACK_H_
+#ifndef SHELL_COMMON_NATIVE_MATE_CONVERTERS_CALLBACK_CONVERTER_DEPRECATED_H_
+#define SHELL_COMMON_NATIVE_MATE_CONVERTERS_CALLBACK_CONVERTER_DEPRECATED_H_
 
 #include <utility>
 #include <vector>
@@ -16,6 +16,10 @@
 #include "native_mate/scoped_persistent.h"
 #include "shell/common/api/locker.h"
 
+// =============================== NOTICE ===============================
+// Do not add code here, native_mate is being removed. Any new code
+// should use gin instead.
+
 namespace mate {
 
 namespace internal {
@@ -178,4 +182,4 @@ v8::Local<v8::Value> CallbackToV8(v8::Isolate* isolate,
 
 }  // namespace mate
 
-#endif  // SHELL_COMMON_NATIVE_MATE_CONVERTERS_CALLBACK_H_
+#endif  // SHELL_COMMON_NATIVE_MATE_CONVERTERS_CALLBACK_CONVERTER_DEPRECATED_H_
diff --git a/shell/common/native_mate_converters/content_converter.cc b/shell/common/native_mate_converters/content_converter.cc
index 2db61481cd7b..a03be29a985c 100644
--- a/shell/common/native_mate_converters/content_converter.cc
+++ b/shell/common/native_mate_converters/content_converter.cc
@@ -13,7 +13,7 @@
 #include "shell/browser/api/atom_api_web_contents.h"
 #include "shell/browser/web_contents_permission_helper.h"
 #include "shell/common/native_mate_converters/blink_converter.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/gurl_converter.h"
 #include "shell/common/native_mate_converters/string16_converter.h"
 #include "shell/common/native_mate_converters/ui_base_types_converter.h"
diff --git a/shell/common/native_mate_converters/once_callback.h b/shell/common/native_mate_converters/once_callback.h
index 89895a9986b5..cb8e46e25631 100644
--- a/shell/common/native_mate_converters/once_callback.h
+++ b/shell/common/native_mate_converters/once_callback.h
@@ -7,7 +7,7 @@
 
 #include <utility>
 
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 
 namespace mate {
 
diff --git a/shell/common/promise_util.h b/shell/common/promise_util.h
index a73f585b9fc1..e7dee469120b 100644
--- a/shell/common/promise_util.h
+++ b/shell/common/promise_util.h
@@ -15,7 +15,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "native_mate/converter.h"
 #include "shell/common/api/locker.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/once_callback.h"
 
 namespace electron {
diff --git a/shell/renderer/api/atom_api_web_frame.cc b/shell/renderer/api/atom_api_web_frame.cc
index 8b00a9d129d9..e8f37aba8c89 100644
--- a/shell/renderer/api/atom_api_web_frame.cc
+++ b/shell/renderer/api/atom_api_web_frame.cc
@@ -18,7 +18,7 @@
 #include "shell/common/api/api.mojom.h"
 #include "shell/common/api/event_emitter_caller.h"
 #include "shell/common/native_mate_converters/blink_converter.h"
-#include "shell/common/native_mate_converters/callback.h"
+#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
 #include "shell/common/native_mate_converters/gfx_converter.h"
 #include "shell/common/native_mate_converters/string16_converter.h"
 #include "shell/common/node_includes.h"