gin/function_template.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef GIN_FUNCTION_TEMPLATE_H_
   6 #define GIN_FUNCTION_TEMPLATE_H_
   7
   8 #include "base/callback.h"
   9 #include "base/logging.h"
  10 #include "gin/arguments.h"
  11 #include "gin/converter.h"
  12 #include "gin/gin_export.h"
  13 #include "v8/include/v8.h"
  14
  15 namespace gin {
  16
  17 class PerIsolateData;
  18
  19 enum CreateFunctionTemplateFlags {
  20   HolderIsFirstArgument = 1 << 0,
  21 };
  22
  23 namespace internal {
  24
  25 template<typename T>
  26 struct CallbackParamTraits {
  27   typedef T LocalType;
  28 };
  29 template<typename T>
  30 struct CallbackParamTraits<const T&> {
  31   typedef T LocalType;
  32 };
  33 template<typename T>
  34 struct CallbackParamTraits<const T*> {
  35   typedef T* LocalType;
  36 };
  37
  38
  39 // CallbackHolder and CallbackHolderBase are used to pass a base::Callback from
  40 // CreateFunctionTemplate through v8 (via v8::FunctionTemplate) to
  41 // DispatchToCallback, where it is invoked.
  42
  43 // This simple base class is used so that we can share a single object template
  44 // among every CallbackHolder instance.
  45 class GIN_EXPORT CallbackHolderBase {
  46  public:
  47   v8::Handle<v8::External> GetHandle(v8::Isolate* isolate);
  48
  49  protected:
  50   explicit CallbackHolderBase(v8::Isolate* isolate);
  51   virtual ~CallbackHolderBase();
  52
  53  private:
  54   static void FirstWeakCallback(
  55       const v8::WeakCallbackInfo<CallbackHolderBase>& data);
  56   static void SecondWeakCallback(
  57       const v8::WeakCallbackInfo<CallbackHolderBase>& data);
  58
  59   v8::Global<v8::External> v8_ref_;
  60
  61   DISALLOW_COPY_AND_ASSIGN(CallbackHolderBase);
  62 };
  63
  64 template<typename Sig>
  65 class CallbackHolder : public CallbackHolderBase {
  66  public:
  67   CallbackHolder(v8::Isolate* isolate,
  68                  const base::Callback<Sig>& callback,
  69                  int flags)
  70       : CallbackHolderBase(isolate), callback(callback), flags(flags) {}
  71   base::Callback<Sig> callback;
  72   int flags;
  73  private:
  74   virtual ~CallbackHolder() {}
  75
  76   DISALLOW_COPY_AND_ASSIGN(CallbackHolder);
  77 };
  78
  79 template<typename T>
  80 bool GetNextArgument(Arguments* args, int create_flags, bool is_first,
  81                      T* result) {
  82   if (is_first && (create_flags & HolderIsFirstArgument) != 0) {
  83     return args->GetHolder(result);
  84   } else {
  85     return args->GetNext(result);
  86   }
  87 }
  88
  89 // For advanced use cases, we allow callers to request the unparsed Arguments
  90 // object and poke around in it directly.
  91 inline bool GetNextArgument(Arguments* args, int create_flags, bool is_first,
  92                             Arguments* result) {
  93   *result = *args;
  94   return true;
  95 }
  96 inline bool GetNextArgument(Arguments* args, int create_flags, bool is_first,
  97                             Arguments** result) {
  98   *result = args;
  99   return true;
 100 }
 101
 102 // It's common for clients to just need the isolate, so we make that easy.
 103 inline bool GetNextArgument(Arguments* args, int create_flags,
 104                             bool is_first, v8::Isolate** result) {
 105   *result = args->isolate();
 106   return true;
 107 }
 108
 109 // Classes for generating and storing an argument pack of integer indices
 110 // (based on well-known "indices trick", see: http://goo.gl/bKKojn):
 111 template <size_t... indices>
 112 struct IndicesHolder {};
 113
 114 template <size_t requested_index, size_t... indices>
 115 struct IndicesGenerator {
 116   using type = typename IndicesGenerator<requested_index - 1,
 117                                          requested_index - 1,
 118                                          indices...>::type;
 119 };
 120 template <size_t... indices>
 121 struct IndicesGenerator<0, indices...> {
 122   using type = IndicesHolder<indices...>;
 123 };
 124
 125 // Class template for extracting and storing single argument for callback
 126 // at position |index|.
 127 template <size_t index, typename ArgType>
 128 struct ArgumentHolder {
 129   using ArgLocalType = typename CallbackParamTraits<ArgType>::LocalType;
 130
 131   ArgLocalType value;
 132   bool ok;
 133
 134   ArgumentHolder(Arguments* args, int create_flags)
 135       : ok(GetNextArgument(args, create_flags, index == 0, &value)) {
 136     if (!ok) {
 137       // Ideally we would include the expected c++ type in the error
 138       // message which we can access via typeid(ArgType).name()
 139       // however we compile with no-rtti, which disables typeid.
 140       args->ThrowError();
 141     }
 142   }
 143 };
 144
 145 // Class template for converting arguments from JavaScript to C++ and running
 146 // the callback with them.
 147 template <typename IndicesType, typename... ArgTypes>
 148 class Invoker {};
 149
 150 template <size_t... indices, typename... ArgTypes>
 151 class Invoker<IndicesHolder<indices...>, ArgTypes...>
 152     : public ArgumentHolder<indices, ArgTypes>... {
 153  public:
 154   // Invoker<> inherits from ArgumentHolder<> for each argument.
 155   // C++ has always been strict about the class initialization order,
 156   // so it is guaranteed ArgumentHolders will be initialized (and thus, will
 157   // extract arguments from Arguments) in the right order.
 158   Invoker(Arguments* args, int create_flags)
 159       : ArgumentHolder<indices, ArgTypes>(args, create_flags)..., args_(args) {
 160     // GCC thinks that create_flags is going unused, even though the
 161     // expansion above clearly makes use of it. Per jyasskin@, casting
 162     // to void is the commonly accepted way to convince the compiler
 163     // that you're actually using a parameter/varible.
 164     (void)create_flags;
 165   }
 166
 167   bool IsOK() {
 168     return And(ArgumentHolder<indices, ArgTypes>::ok...);
 169   }
 170
 171   template <typename ReturnType>
 172   void DispatchToCallback(base::Callback<ReturnType(ArgTypes...)> callback) {
 173     args_->Return(callback.Run(ArgumentHolder<indices, ArgTypes>::value...));
 174   }
 175
 176   // In C++, you can declare the function foo(void), but you can't pass a void
 177   // expression to foo. As a result, we must specialize the case of Callbacks
 178   // that have the void return type.
 179   void DispatchToCallback(base::Callback<void(ArgTypes...)> callback) {
 180     callback.Run(ArgumentHolder<indices, ArgTypes>::value...);
 181   }
 182
 183  private:
 184   static bool And() { return true; }
 185   template <typename... T>
 186   static bool And(bool arg1, T... args) {
 187     return arg1 && And(args...);
 188   }
 189
 190   Arguments* args_;
 191 };
 192
 193 // DispatchToCallback converts all the JavaScript arguments to C++ types and
 194 // invokes the base::Callback.
 195 template <typename Sig>
 196 struct Dispatcher {};
 197
 198 template <typename ReturnType, typename... ArgTypes>
 199 struct Dispatcher<ReturnType(ArgTypes...)> {
 200   static void DispatchToCallback(
 201       const v8::FunctionCallbackInfo<v8::Value>& info) {
 202     Arguments args(info);
 203     v8::Handle<v8::External> v8_holder;
 204     CHECK(args.GetData(&v8_holder));
 205     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
 206         v8_holder->Value());
 207
 208     typedef CallbackHolder<ReturnType(ArgTypes...)> HolderT;
 209     HolderT* holder = static_cast<HolderT*>(holder_base);
 210
 211     using Indices = typename IndicesGenerator<sizeof...(ArgTypes)>::type;
 212     Invoker<Indices, ArgTypes...> invoker(&args, holder->flags);
 213     if (invoker.IsOK())
 214       invoker.DispatchToCallback(holder->callback);
 215   }
 216 };
 217
 218 }  // namespace internal
 219
 220
 221 // CreateFunctionTemplate creates a v8::FunctionTemplate that will create
 222 // JavaScript functions that execute a provided C++ function or base::Callback.
 223 // JavaScript arguments are automatically converted via gin::Converter, as is
 224 // the return value of the C++ function, if any.
 225 //
 226 // NOTE: V8 caches FunctionTemplates for a lifetime of a web page for its own
 227 // internal reasons, thus it is generally a good idea to cache the template
 228 // returned by this function.  Otherwise, repeated method invocations from JS
 229 // will create substantial memory leaks. See http://crbug.com/463487.
 230 template<typename Sig>
 231 v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
 232     v8::Isolate* isolate, const base::Callback<Sig> callback,
 233     int callback_flags = 0) {
 234   typedef internal::CallbackHolder<Sig> HolderT;
 235   HolderT* holder = new HolderT(isolate, callback, callback_flags);
 236
 237   return v8::FunctionTemplate::New(
 238       isolate,
 239       &internal::Dispatcher<Sig>::DispatchToCallback,
 240       ConvertToV8<v8::Handle<v8::External> >(isolate,
 241                                              holder->GetHandle(isolate)));
 242 }
 243
 244 // CreateFunctionHandler installs a CallAsFunction handler on the given
 245 // object template that forwards to a provided C++ function or base::Callback.
 246 template<typename Sig>
 247 void CreateFunctionHandler(v8::Isolate* isolate,
 248                            v8::Local<v8::ObjectTemplate> tmpl,
 249                            const base::Callback<Sig> callback,
 250                            int callback_flags = 0) {
 251   typedef internal::CallbackHolder<Sig> HolderT;
 252   HolderT* holder = new HolderT(isolate, callback, callback_flags);
 253   tmpl->SetCallAsFunctionHandler(&internal::Dispatcher<Sig>::DispatchToCallback,
 254                                  ConvertToV8<v8::Handle<v8::External> >(
 255                                      isolate, holder->GetHandle(isolate)));
 256 }
 257
 258 }  // namespace gin
 259
 260 #endif  // GIN_FUNCTION_TEMPLATE_H_