Use native_mate to simplify dialog api.

atom.gyp

@@ -51,7 +51,6 @@
       'atom/browser/api/atom_api_browser_ipc.cc',
       'atom/browser/api/atom_api_browser_ipc.h',
       'atom/browser/api/atom_api_dialog.cc',
-      'atom/browser/api/atom_api_dialog.h',
       'atom/browser/api/atom_api_event.cc',
       'atom/browser/api/atom_api_event.h',
       'atom/browser/api/atom_api_menu.cc',

atom/browser/api/atom_api_dialog.cc

@@ -2,143 +2,174 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "atom/browser/api/atom_api_dialog.h"
-
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
+#include "atom/browser/api/atom_api_window.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/ui/file_dialog.h"
 #include "atom/browser/ui/message_box.h"
+#include "atom/common/v8_converters/file_path_converter.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/scoped_persistent.h"
+
 #include "atom/common/v8/node_common.h"
-#include "atom/common/v8/native_type_conversions.h"
 
-namespace atom {
+namespace mate {
+
+template<>
+struct Converter<atom::NativeWindow*> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     atom::NativeWindow** out) {
+    using atom::api::Window;
+    if (val->IsNull()) {
+      *out = NULL;
+      return true;  // NULL is a valid value for NativeWindow*.
+    } else if (val->IsObject()) {
+      Window* window = Window::Unwrap<Window>(val->ToObject());
+      *out = window->window();
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+
+
+typedef scoped_refptr<RefCountedPersistent<v8::Function>> RefCountedV8Function;
+
+template<>
+struct Converter<mate::RefCountedV8Function> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     RefCountedV8Function* out) {
+    if (!val->IsFunction())
+      return false;
+
+    v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(val);
+    *out = new mate::RefCountedPersistent<v8::Function>(function);
+    return true;
+  }
+};
+
+}  // namespace mate
 
-namespace api {
 
 namespace {
 
 template<typename T>
-void CallV8Function(const RefCountedV8Function& callback, T arg) {
+void CallV8Function(const mate::RefCountedV8Function& callback, T arg) {
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
 
-  v8::Handle<v8::Value> value = ToV8Value(arg);
+  v8::Handle<v8::Value> value = mate::Converter<T>::ToV8(node_isolate, arg);
   callback->NewHandle(node_isolate)->Call(
       v8::Context::GetCurrent()->Global(), 1, &value);
 }
 
 template<typename T>
-void CallV8Function2(const RefCountedV8Function& callback, bool result, T arg) {
+void CallV8Function2(
+    const mate::RefCountedV8Function& callback, bool result, const T& arg) {
   if (result)
     return CallV8Function<T>(callback, arg);
   else
     return CallV8Function<void*>(callback, NULL);
 }
 
-void Initialize(v8::Handle<v8::Object> target) {
-  NODE_SET_METHOD(target, "showMessageBox", ShowMessageBox);
-  NODE_SET_METHOD(target, "showOpenDialog", ShowOpenDialog);
-  NODE_SET_METHOD(target, "showSaveDialog", ShowSaveDialog);
-}
 
-}  // namespace
+void ShowMessageBox(int type,
-
+                    const std::vector<std::string>& buttons,
-void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args) {
+                    const std::string& title,
-  int type;
+                    const std::string& message,
-  std::vector<std::string> buttons;
+                    const std::string& detail,
-  std::string title, message, detail;
+                    atom::NativeWindow* window,
-  if (!FromV8Arguments(args, &type, &buttons, &title, &message, &detail))
+                    mate::Arguments* args) {
-    return node::ThrowTypeError("Bad argument");
+  v8::Handle<v8::Value> peek = args->PeekNext();
-
+  mate::RefCountedV8Function callback;
-  NativeWindow* native_window = FromV8Value(args[5]);
+  if (mate::Converter<mate::RefCountedV8Function>::FromV8(node_isolate,
-
+                                                          peek,
-  if (!args[6]->IsFunction()) {
+                                                          &callback)) {
-    int chosen = atom::ShowMessageBox(
-        native_window,
-        (MessageBoxType)type,
-        buttons,
-        title,
-        message,
-        detail);
-    args.GetReturnValue().Set(chosen);
-  } else {
-    RefCountedV8Function callback = FromV8Value(args[6]);
     atom::ShowMessageBox(
-        native_window,
+        window,
-        (MessageBoxType)type,
+        (atom::MessageBoxType)type,
         buttons,
         title,
         message,
         detail,
         base::Bind(&CallV8Function<int>, callback));
+  } else {
+    int chosen = atom::ShowMessageBox(
+        window,
+        (atom::MessageBoxType)type,
+        buttons,
+        title,
+        message,
+        detail);
+    args->Return(chosen);
   }
 }
 
-void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
+void ShowOpenDialog(const std::string& title,
-  std::string title;
+                    const base::FilePath& default_path,
-  base::FilePath default_path;
+                    int properties,
-  int properties;
+                    atom::NativeWindow* window,
-  if (!FromV8Arguments(args, &title, &default_path, &properties))
+                    mate::Arguments* args) {
-    return node::ThrowTypeError("Bad argument");
+  v8::Handle<v8::Value> peek = args->PeekNext();
-
+  mate::RefCountedV8Function callback;
-  NativeWindow* native_window = FromV8Value(args[3]);
+  if (mate::Converter<mate::RefCountedV8Function>::FromV8(node_isolate,
-
+                                                          peek,
-  if (!args[4]->IsFunction()) {
+                                                          &callback)) {
-    std::vector<base::FilePath> paths;
-    if (!file_dialog::ShowOpenDialog(native_window,
-                                     title,
-                                     default_path,
-                                     properties,
-                                     &paths))
-      return;
-
-    v8::Handle<v8::Array> result = v8::Array::New(paths.size());
-    for (size_t i = 0; i < paths.size(); ++i)
-      result->Set(i, ToV8Value(paths[i]));
-
-    args.GetReturnValue().Set(result);
-  } else {
-    RefCountedV8Function callback = FromV8Value(args[4]);
     file_dialog::ShowOpenDialog(
-        native_window,
+        window,
         title,
         default_path,
         properties,
-        base::Bind(&CallV8Function2<const std::vector<base::FilePath>&>,
+        base::Bind(&CallV8Function2<std::vector<base::FilePath>>,
                    callback));
+  } else {
+    std::vector<base::FilePath> paths;
+    if (file_dialog::ShowOpenDialog(window,
+                                    title,
+                                    default_path,
+                                    properties,
+                                    &paths))
+      args->Return(paths);
   }
 }
 
-void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
+void ShowSaveDialog(const std::string& title,
-  std::string title;
+                    const base::FilePath& default_path,
-  base::FilePath default_path;
+                    atom::NativeWindow* window,
-  if (!FromV8Arguments(args, &title, &default_path))
+                    mate::Arguments* args) {
-    return node::ThrowTypeError("Bad argument");
+  v8::Handle<v8::Value> peek = args->PeekNext();
-
+  mate::RefCountedV8Function callback;
-  NativeWindow* native_window = FromV8Value(args[2]);
+  if (mate::Converter<mate::RefCountedV8Function>::FromV8(node_isolate,
-
+                                                          peek,
-  if (!args[3]->IsFunction()) {
+                                                          &callback)) {
+    file_dialog::ShowSaveDialog(
+        window,
+        title,
+        default_path,
+        base::Bind(&CallV8Function2<base::FilePath>, callback));
+  } else {
     base::FilePath path;
-    if (file_dialog::ShowSaveDialog(native_window,
+    if (file_dialog::ShowSaveDialog(window,
                                     title,
                                     default_path,
                                     &path))
-      args.GetReturnValue().Set(ToV8Value(path));
+      args->Return(path);
-  } else {
-    RefCountedV8Function callback = FromV8Value(args[3]);
-    file_dialog::ShowSaveDialog(
-        native_window,
-        title,
-        default_path,
-        base::Bind(&CallV8Function2<const base::FilePath&>, callback));
   }
 }
 
-}  // namespace api
+void Initialize(v8::Handle<v8::Object> exports) {
+  mate::Dictionary dict(v8::Isolate::GetCurrent(), exports);
+  dict.SetMethod("showMessageBox", &ShowMessageBox);
+  dict.SetMethod("showOpenDialog", &ShowOpenDialog);
+  dict.SetMethod("showSaveDialog", &ShowSaveDialog);
+}
 
-}  // namespace atom
+}  // namespace
 
-NODE_MODULE(atom_browser_dialog, atom::api::Initialize)
+NODE_MODULE(atom_browser_dialog, Initialize)

atom/browser/api/atom_api_dialog.h

@@ -1,22 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_API_ATOM_API_DIALOG_H_
-#define ATOM_BROWSER_API_ATOM_API_DIALOG_H_
-
-#include "v8/include/v8.h"
-
-namespace atom {
-
-namespace api {
-
-void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args);
-void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
-void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_DIALOG_H_

atom/common/api/atom_api_id_weak_map.cc

@@ -28,7 +28,7 @@ int32_t IDWeakMap::Add(v8::Isolate* isolate, v8::Handle<v8::Object> object) {
   object->SetHiddenValue(mate::StringToV8(isolate, "IDWeakMapKey"),
                          mate::Converter<int32_t>::ToV8(isolate, key));
 
-  map_[key] = new RefCountedPersistent<v8::Object>(object);
+  map_[key] = new mate::RefCountedPersistent<v8::Object>(object);
   map_[key]->MakeWeak(this, WeakCallback);
   return key;
 }

atom/common/api/atom_api_id_weak_map.h

@@ -9,8 +9,8 @@
 #include <map>
 #include <vector>
 
-#include "atom/common/v8/scoped_persistent.h"
 #include "base/basictypes.h"
+#include "native_mate/scoped_persistent.h"
 #include "native_mate/wrappable.h"
 
 namespace atom {
@@ -40,6 +40,9 @@ class IDWeakMap : public mate::Wrappable {
                            IDWeakMap* self);
 
   int32_t next_id_;
+
+  typedef scoped_refptr<mate::RefCountedPersistent<v8::Object> >
+      RefCountedV8Object;
   std::map<int32_t, RefCountedV8Object> map_;
 
   DISALLOW_COPY_AND_ASSIGN(IDWeakMap);

atom/common/api/atom_api_shell.cc

@@ -5,7 +5,7 @@
 #include <string>
 
 #include "atom/common/platform_util.h"
-#include "base/files/file_path.h"
+#include "atom/common/v8_converters/file_path_converter.h"
 #include "native_mate/object_template_builder.h"
 #include "url/gurl.h"
 
@@ -28,21 +28,6 @@ struct Converter<GURL> {
   }
 };
 
-template<>
-struct Converter<base::FilePath> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     base::FilePath* out) {
-    std::string path;
-    if (Converter<std::string>::FromV8(isolate, val, &path)) {
-      *out = base::FilePath::FromUTF8Unsafe(path);
-      return true;
-    } else {
-      return false;
-    }
-  }
-};
-
 }  // namespace mate
 
 namespace {

atom/common/v8_converters/file_path_converter.h

@@ -0,0 +1,34 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_COMMON_V8_CONVERTERS_FILE_PATH_CONVERTER_H_
+#define ATOM_COMMON_V8_CONVERTERS_FILE_PATH_CONVERTER_H_
+
+#include "atom/common/v8_converters/string16_converter.h"
+#include "base/files/file_path.h"
+
+namespace mate {
+
+template<>
+struct Converter<base::FilePath> {
+  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+                                    const base::FilePath& val) {
+    return Converter<base::FilePath::StringType>::ToV8(isolate, val.value());
+  }
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     base::FilePath* out) {
+    std::string path;
+    if (Converter<std::string>::FromV8(isolate, val, &path)) {
+      *out = base::FilePath::FromUTF8Unsafe(path);
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+
+}  // namespace mate
+
+#endif  // ATOM_COMMON_V8_CONVERTERS_FILE_PATH_CONVERTER_H_

atom/common/v8_converters/string16_converter.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_COMMON_V8_CONVERTERS_STRING16_CONVERTER_H_
+#define ATOM_COMMON_V8_CONVERTERS_STRING16_CONVERTER_H_
+
+#include "base/strings/string16.h"
+#include "native_mate/converter.h"
+
+namespace mate {
+
+template<>
+struct Converter<string16> {
+  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+                                    const string16& val) {
+    return v8::String::New(reinterpret_cast<const uint16_t*>(val.data()),
+                           val.size());
+  }
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     string16* out) {
+    v8::String::Value s(val);
+    *out = string16(reinterpret_cast<const char16*>(*s), s.length());
+    return true;
+  }
+};
+
+}  // namespace mate
+
+#endif  // ATOM_COMMON_V8_CONVERTERS_STRING16_CONVERTER_H_

atom/renderer/api/atom_api_renderer_ipc.cc

@@ -4,6 +4,7 @@
 
 #include "atom/common/api/api_messages.h"
 #include "atom/common/v8/v8_value_converter.h"
+#include "atom/common/v8_converters/string16_converter.h"
 #include "content/public/renderer/render_view.h"
 #include "native_mate/object_template_builder.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
@@ -17,22 +18,6 @@ using WebKit::WebView;
 
 namespace mate {
 
-template<>
-struct Converter<string16> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    const string16& val) {
-    return v8::String::New(reinterpret_cast<const uint16_t*>(val.data()),
-                           val.size());
-  }
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     string16* out) {
-    v8::String::Value s(val);
-    *out = string16(reinterpret_cast<const char16*>(*s), s.length());
-    return true;
-  }
-};
-
 template<>
 struct Converter<base::ListValue> {
   static bool FromV8(v8::Isolate* isolate,

vendor/native_mate

@@ -1 +1 @@
-Subproject commit ace550d6b20a62ca1101153a06bccb4ba1484a14
+Subproject commit c9fa29ef640e8d3d2edf6b48c2311b16ce314464