Merge branch 'master' into nativeimage_ico_support_windows

atom/common/api/api_messages.h

@@ -34,6 +34,10 @@ IPC_MESSAGE_ROUTED2(AtomViewMsg_Message,
                     base::string16 /* channel */,
                     base::ListValue /* arguments */)
 
+IPC_MESSAGE_ROUTED2(AtomViewMsg_ExecuteJavaScript,
+                    base::string16 /* code */,
+                    bool /* has user gesture */)
+
 // Sent by the renderer when the draggable regions are updated.
 IPC_MESSAGE_ROUTED1(AtomViewHostMsg_UpdateDraggableRegions,
                     std::vector<atom::DraggableRegion> /* regions */)

atom/common/api/atom_api_asar.cc

@@ -8,9 +8,9 @@
 
 #include "atom_natives.h"  // NOLINT: This file is generated with coffee2c.
 #include "atom/common/asar/archive.h"
+#include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "native_mate/arguments.h"
-#include "native_mate/callback.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 #include "native_mate/wrappable.h"

atom/common/api/atom_api_native_image.cc

@@ -82,7 +82,7 @@ bool AddImageSkiaRep(gfx::ImageSkia* image,
   if (!decoded)
     return false;
 
-  image->AddRepresentation(gfx::ImageSkiaRep(*decoded.release(), scale_factor));
+  image->AddRepresentation(gfx::ImageSkiaRep(*decoded, scale_factor));
   return true;
 }
 
@@ -117,7 +117,7 @@ bool PopulateImageSkiaRepsFromPath(gfx::ImageSkia* image,
 }
 
 #if defined(OS_MACOSX)
-bool IsTemplateImage(const base::FilePath& path) {
+bool IsTemplateFilename(const base::FilePath& path) {
   return (MatchPattern(path.value(), "*Template.*") ||
           MatchPattern(path.value(), "*Template@*x.*"));
 }
@@ -143,6 +143,7 @@ mate::ObjectTemplateBuilder NativeImage::GetObjectTemplateBuilder(
         .SetMethod("isEmpty", &NativeImage::IsEmpty)
         .SetMethod("getSize", &NativeImage::GetSize)
         .SetMethod("setTemplateImage", &NativeImage::SetTemplateImage)
+        .SetMethod("isTemplateImage", &NativeImage::IsTemplateImage)
         .Build());
 
   return mate::ObjectTemplateBuilder(
@@ -184,6 +185,10 @@ gfx::Size NativeImage::GetSize() {
 #if !defined(OS_MACOSX)
 void NativeImage::SetTemplateImage(bool setAsTemplate) {
 }
+
+bool NativeImage::IsTemplateImage() {
+  return false;
+}
 #endif
 
 // static
@@ -249,7 +254,7 @@ mate::Handle<NativeImage> NativeImage::CreateFromPath(
   gfx::Image image(image_skia);
   mate::Handle<NativeImage> handle = Create(isolate, image);
 #if defined(OS_MACOSX)
-  if (IsTemplateImage(path))
+  if (IsTemplateFilename(path))
     handle->SetTemplateImage(true);
 #endif
   return handle;

atom/common/api/atom_api_native_image.h

@@ -67,6 +67,8 @@ class NativeImage : public mate::Wrappable {
 
   // Mark the image as template image.
   void SetTemplateImage(bool setAsTemplate);
+  // Determine if the image is a template image.
+  bool IsTemplateImage();
 
   gfx::Image image_;
 

atom/common/api/atom_api_native_image_mac.mm

@@ -14,6 +14,10 @@ void NativeImage::SetTemplateImage(bool setAsTemplate) {
   [image_.AsNSImage() setTemplate:setAsTemplate];
 }
 
+bool NativeImage::IsTemplateImage() {
+  return [image_.AsNSImage() isTemplate];
+}
+
 }  // namespace api
 
 }  // namespace atom

atom/common/api/atom_bindings.cc

@@ -98,6 +98,10 @@ void AtomBindings::OnCallNextTick(uv_async_t* handle) {
     if (tick_info->in_tick())
       continue;
 
+    if (tick_info->length() == 0) {
+      env->isolate()->RunMicrotasks();
+    }
+
     if (tick_info->length() == 0) {
       tick_info->set_index(0);
       continue;

atom/common/api/event_emitter_caller.cc

@@ -0,0 +1,32 @@
+// 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 "atom/common/api/event_emitter_caller.h"
+
+#include "atom/common/api/locker.h"
+#include "base/memory/scoped_ptr.h"
+#include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
+
+#include "atom/common/node_includes.h"
+
+namespace mate {
+
+namespace internal {
+
+v8::Local<v8::Value> CallEmitWithArgs(v8::Isolate* isolate,
+                                      v8::Local<v8::Object> obj,
+                                      ValueVector* args) {
+  // Perform microtask checkpoint after running JavaScript.
+  scoped_ptr<blink::WebScopedRunV8Script> script_scope(
+      Locker::IsBrowserProcess() ?
+      nullptr : new blink::WebScopedRunV8Script(isolate));
+  // Use node::MakeCallback to call the callback, and it will also run pending
+  // tasks in Node.js.
+  return node::MakeCallback(
+      isolate, obj, "emit", args->size(), &args->front());
+}
+
+}  // namespace internal
+
+}  // namespace mate

atom/common/api/event_emitter_caller.h

@@ -0,0 +1,53 @@
+// 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 ATOM_COMMON_API_EVENT_EMITTER_CALLER_H_
+#define ATOM_COMMON_API_EVENT_EMITTER_CALLER_H_
+
+#include <vector>
+
+#include "native_mate/converter.h"
+
+namespace mate {
+
+namespace internal {
+
+using ValueVector = std::vector<v8::Local<v8::Value>>;
+
+v8::Local<v8::Value> CallEmitWithArgs(v8::Isolate* isolate,
+                                      v8::Local<v8::Object> obj,
+                                      ValueVector* args);
+
+}  // namespace internal
+
+// obj.emit.apply(obj, name, args...);
+// The caller is responsible of allocating a HandleScope.
+template<typename StringType, typename... Args>
+v8::Local<v8::Value> EmitEvent(v8::Isolate* isolate,
+                               v8::Local<v8::Object> obj,
+                               const StringType& name,
+                               const internal::ValueVector& args) {
+  internal::ValueVector concatenated_args = { StringToV8(isolate, name) };
+  concatenated_args.reserve(1 + args.size());
+  concatenated_args.insert(concatenated_args.end(), args.begin(), args.end());
+  return internal::CallEmitWithArgs(isolate, obj, &concatenated_args);
+}
+
+// obj.emit(name, args...);
+// The caller is responsible of allocating a HandleScope.
+template<typename StringType, typename... Args>
+v8::Local<v8::Value> EmitEvent(v8::Isolate* isolate,
+                               v8::Local<v8::Object> obj,
+                               const StringType& name,
+                               const Args&... args) {
+  internal::ValueVector converted_args = {
+      StringToV8(isolate, name),
+      ConvertToV8(isolate, args)...,
+  };
+  return internal::CallEmitWithArgs(isolate, obj, &converted_args);
+}
+
+}  // namespace mate
+
+#endif  // ATOM_COMMON_API_EVENT_EMITTER_CALLER_H_

atom/common/api/lib/callbacks-registry.coffee

@@ -1,3 +1,5 @@
+savedGlobal = global  # the "global.global" might be deleted later
+
 module.exports =
 class CallbacksRegistry
   constructor: ->
@@ -16,10 +18,10 @@ class CallbacksRegistry
     @callbacks[id] ? ->
 
   call: (id, args...) ->
-    @get(id).call global, args...
+    @get(id).call savedGlobal, args...
 
   apply: (id, args...) ->
-    @get(id).apply global, args...
+    @get(id).apply savedGlobal, args...
 
   remove: (id) ->
     delete @callbacks[id]

atom/common/api/locker.cc

@@ -0,0 +1,17 @@
+// Copyright 2014 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 "atom/common/api/locker.h"
+
+namespace mate {
+
+Locker::Locker(v8::Isolate* isolate) {
+  if (IsBrowserProcess())
+    locker_.reset(new v8::Locker(isolate));
+}
+
+Locker::~Locker() {
+}
+
+}  // namespace mate

atom/common/api/locker.h

@@ -0,0 +1,34 @@
+// Copyright 2014 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 ATOM_COMMON_API_LOCKER_H_
+#define ATOM_COMMON_API_LOCKER_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "v8/include/v8.h"
+
+namespace mate {
+
+// Only lock when lockers are used in current thread.
+class Locker {
+ public:
+  explicit Locker(v8::Isolate* isolate);
+  ~Locker();
+
+  // Returns whether current process is browser process, currently we detect it
+  // by checking whether current has used V8 Lock, but it might be a bad idea.
+  static inline bool IsBrowserProcess() { return v8::Locker::IsActive(); }
+
+ private:
+  void* operator new(size_t size);
+  void operator delete(void*, size_t);
+
+  scoped_ptr<v8::Locker> locker_;
+
+  DISALLOW_COPY_AND_ASSIGN(Locker);
+};
+
+}  // namespace mate
+
+#endif  // ATOM_COMMON_API_LOCKER_H_