gin/function_template.h

   1 // This file was GENERATED by command:
   2 //     pump.py function_template.h.pump
   3 // DO NOT EDIT BY HAND!!!
   4
   5
   6
   7 #ifndef GIN_FUNCTION_TEMPLATE_H_
   8 #define GIN_FUNCTION_TEMPLATE_H_
   9
  10 // Copyright 2013 The Chromium Authors. All rights reserved.
  11 // Use of this source code is governed by a BSD-style license that can be
  12 // found in the LICENSE file.
  13
  14 #include "base/callback.h"
  15 #include "base/logging.h"
  16 #include "gin/arguments.h"
  17 #include "gin/converter.h"
  18 #include "gin/gin_export.h"
  19 #include "v8/include/v8.h"
  20
  21 namespace gin {
  22
  23 class PerIsolateData;
  24
  25 enum CreateFunctionTemplateFlags {
  26   HolderIsFirstArgument = 1 << 0,
  27 };
  28
  29 namespace internal {
  30
  31 template<typename T>
  32 struct CallbackParamTraits {
  33   typedef T LocalType;
  34 };
  35 template<typename T>
  36 struct CallbackParamTraits<const T&> {
  37   typedef T LocalType;
  38 };
  39 template<typename T>
  40 struct CallbackParamTraits<const T*> {
  41   typedef T* LocalType;
  42 };
  43
  44
  45 // CallbackHolder and CallbackHolderBase are used to pass a base::Callback from
  46 // CreateFunctionTemplate through v8 (via v8::FunctionTemplate) to
  47 // DispatchToCallback, where it is invoked.
  48
  49 // This simple base class is used so that we can share a single object template
  50 // among every CallbackHolder instance.
  51 class GIN_EXPORT CallbackHolderBase {
  52  public:
  53   v8::Handle<v8::External> GetHandle(v8::Isolate* isolate);
  54
  55  protected:
  56   explicit CallbackHolderBase(v8::Isolate* isolate);
  57   virtual ~CallbackHolderBase();
  58
  59  private:
  60   static void WeakCallback(
  61       const v8::WeakCallbackData<v8::External, CallbackHolderBase>& data);
  62
  63   v8::Persistent<v8::External> v8_ref_;
  64
  65   DISALLOW_COPY_AND_ASSIGN(CallbackHolderBase);
  66 };
  67
  68 template<typename Sig>
  69 class CallbackHolder : public CallbackHolderBase {
  70  public:
  71   CallbackHolder(v8::Isolate* isolate,
  72                  const base::Callback<Sig>& callback,
  73                  int flags)
  74       : CallbackHolderBase(isolate), callback(callback), flags(flags) {}
  75   base::Callback<Sig> callback;
  76   int flags;
  77  private:
  78   virtual ~CallbackHolder() {}
  79
  80   DISALLOW_COPY_AND_ASSIGN(CallbackHolder);
  81 };
  82
  83
  84 // This set of templates invokes a base::Callback, converts the return type to a
  85 // JavaScript value, and returns that value to script via the provided
  86 // gin::Arguments object.
  87 //
  88 // In C++, you can declare the function foo(void), but you can't pass a void
  89 // expression to foo. As a result, we must specialize the case of Callbacks that
  90 // have the void return type.
  91 template<typename R, typename P1 = void, typename P2 = void,
  92     typename P3 = void, typename P4 = void, typename P5 = void,
  93     typename P6 = void>
  94 struct Invoker {
  95   inline static void Go(
  96       Arguments* args,
  97       const base::Callback<R(P1, P2, P3, P4, P5, P6)>& callback,
  98       const P1& a1,
  99       const P2& a2,
 100       const P3& a3,
 101       const P4& a4,
 102       const P5& a5,
 103       const P6& a6) {
 104     args->Return(callback.Run(a1, a2, a3, a4, a5, a6));
 105   }
 106 };
 107 template<typename P1, typename P2, typename P3, typename P4, typename P5,
 108     typename P6>
 109 struct Invoker<void, P1, P2, P3, P4, P5, P6> {
 110   inline static void Go(
 111       Arguments* args,
 112       const base::Callback<void(P1, P2, P3, P4, P5, P6)>& callback,
 113       const P1& a1,
 114       const P2& a2,
 115       const P3& a3,
 116       const P4& a4,
 117       const P5& a5,
 118       const P6& a6) {
 119     callback.Run(a1, a2, a3, a4, a5, a6);
 120   }
 121 };
 122
 123 template<typename R, typename P1, typename P2, typename P3, typename P4,
 124     typename P5>
 125 struct Invoker<R, P1, P2, P3, P4, P5, void> {
 126   inline static void Go(
 127       Arguments* args,
 128       const base::Callback<R(P1, P2, P3, P4, P5)>& callback,
 129       const P1& a1,
 130       const P2& a2,
 131       const P3& a3,
 132       const P4& a4,
 133       const P5& a5) {
 134     args->Return(callback.Run(a1, a2, a3, a4, a5));
 135   }
 136 };
 137 template<typename P1, typename P2, typename P3, typename P4, typename P5>
 138 struct Invoker<void, P1, P2, P3, P4, P5, void> {
 139   inline static void Go(
 140       Arguments* args,
 141       const base::Callback<void(P1, P2, P3, P4, P5)>& callback,
 142       const P1& a1,
 143       const P2& a2,
 144       const P3& a3,
 145       const P4& a4,
 146       const P5& a5) {
 147     callback.Run(a1, a2, a3, a4, a5);
 148   }
 149 };
 150
 151 template<typename R, typename P1, typename P2, typename P3, typename P4>
 152 struct Invoker<R, P1, P2, P3, P4, void, void> {
 153   inline static void Go(
 154       Arguments* args,
 155       const base::Callback<R(P1, P2, P3, P4)>& callback,
 156       const P1& a1,
 157       const P2& a2,
 158       const P3& a3,
 159       const P4& a4) {
 160     args->Return(callback.Run(a1, a2, a3, a4));
 161   }
 162 };
 163 template<typename P1, typename P2, typename P3, typename P4>
 164 struct Invoker<void, P1, P2, P3, P4, void, void> {
 165   inline static void Go(
 166       Arguments* args,
 167       const base::Callback<void(P1, P2, P3, P4)>& callback,
 168       const P1& a1,
 169       const P2& a2,
 170       const P3& a3,
 171       const P4& a4) {
 172     callback.Run(a1, a2, a3, a4);
 173   }
 174 };
 175
 176 template<typename R, typename P1, typename P2, typename P3>
 177 struct Invoker<R, P1, P2, P3, void, void, void> {
 178   inline static void Go(
 179       Arguments* args,
 180       const base::Callback<R(P1, P2, P3)>& callback,
 181       const P1& a1,
 182       const P2& a2,
 183       const P3& a3) {
 184     args->Return(callback.Run(a1, a2, a3));
 185   }
 186 };
 187 template<typename P1, typename P2, typename P3>
 188 struct Invoker<void, P1, P2, P3, void, void, void> {
 189   inline static void Go(
 190       Arguments* args,
 191       const base::Callback<void(P1, P2, P3)>& callback,
 192       const P1& a1,
 193       const P2& a2,
 194       const P3& a3) {
 195     callback.Run(a1, a2, a3);
 196   }
 197 };
 198
 199 template<typename R, typename P1, typename P2>
 200 struct Invoker<R, P1, P2, void, void, void, void> {
 201   inline static void Go(
 202       Arguments* args,
 203       const base::Callback<R(P1, P2)>& callback,
 204       const P1& a1,
 205       const P2& a2) {
 206     args->Return(callback.Run(a1, a2));
 207   }
 208 };
 209 template<typename P1, typename P2>
 210 struct Invoker<void, P1, P2, void, void, void, void> {
 211   inline static void Go(
 212       Arguments* args,
 213       const base::Callback<void(P1, P2)>& callback,
 214       const P1& a1,
 215       const P2& a2) {
 216     callback.Run(a1, a2);
 217   }
 218 };
 219
 220 template<typename R, typename P1>
 221 struct Invoker<R, P1, void, void, void, void, void> {
 222   inline static void Go(
 223       Arguments* args,
 224       const base::Callback<R(P1)>& callback,
 225       const P1& a1) {
 226     args->Return(callback.Run(a1));
 227   }
 228 };
 229 template<typename P1>
 230 struct Invoker<void, P1, void, void, void, void, void> {
 231   inline static void Go(
 232       Arguments* args,
 233       const base::Callback<void(P1)>& callback,
 234       const P1& a1) {
 235     callback.Run(a1);
 236   }
 237 };
 238
 239 template<typename R>
 240 struct Invoker<R, void, void, void, void, void, void> {
 241   inline static void Go(
 242       Arguments* args,
 243       const base::Callback<R()>& callback) {
 244     args->Return(callback.Run());
 245   }
 246 };
 247 template<>
 248 struct Invoker<void, void, void, void, void, void, void> {
 249   inline static void Go(
 250       Arguments* args,
 251       const base::Callback<void()>& callback) {
 252     callback.Run();
 253   }
 254 };
 255
 256
 257 template<typename T>
 258 bool GetNextArgument(Arguments* args, int create_flags, bool is_first,
 259                      T* result) {
 260   if (is_first && (create_flags & HolderIsFirstArgument) != 0) {
 261     return args->GetHolder(result);
 262   } else {
 263     return args->GetNext(result);
 264   }
 265 }
 266
 267 // For advanced use cases, we allow callers to request the unparsed Arguments
 268 // object and poke around in it directly.
 269 inline bool GetNextArgument(Arguments* args, int create_flags, bool is_first,
 270                             Arguments* result) {
 271   *result = *args;
 272   return true;
 273 }
 274 inline bool GetNextArgument(Arguments* args, int create_flags, bool is_first,
 275                             Arguments** result) {
 276   *result = args;
 277   return true;
 278 }
 279
 280 // It's common for clients to just need the isolate, so we make that easy.
 281 inline bool GetNextArgument(Arguments* args, int create_flags,
 282                             bool is_first, v8::Isolate** result) {
 283   *result = args->isolate();
 284   return true;
 285 }
 286
 287
 288 // DispatchToCallback converts all the JavaScript arguments to C++ types and
 289 // invokes the base::Callback.
 290 template<typename Sig>
 291 struct Dispatcher {
 292 };
 293
 294 template<typename R>
 295 struct Dispatcher<R()> {
 296   static void DispatchToCallback(
 297       const v8::FunctionCallbackInfo<v8::Value>& info) {
 298     Arguments args(info);
 299     v8::Handle<v8::External> v8_holder;
 300     CHECK(args.GetData(&v8_holder));
 301     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
 302         v8_holder->Value());
 303
 304     typedef CallbackHolder<R()> HolderT;
 305     HolderT* holder = static_cast<HolderT*>(holder_base);
 306
 307     Invoker<R>::Go(&args, holder->callback);
 308   }
 309 };
 310
 311 template<typename R, typename P1>
 312 struct Dispatcher<R(P1)> {
 313   static void DispatchToCallback(
 314       const v8::FunctionCallbackInfo<v8::Value>& info) {
 315     Arguments args(info);
 316     v8::Handle<v8::External> v8_holder;
 317     CHECK(args.GetData(&v8_holder));
 318     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
 319         v8_holder->Value());
 320
 321     typedef CallbackHolder<R(P1)> HolderT;
 322     HolderT* holder = static_cast<HolderT*>(holder_base);
 323
 324     typename CallbackParamTraits<P1>::LocalType a1;
 325     if (!GetNextArgument(&args, holder->flags, true, &a1)) {
 326       args.ThrowError();
 327       return;
 328     }
 329
 330     Invoker<R, P1>::Go(&args, holder->callback, a1);
 331   }
 332 };
 333
 334 template<typename R, typename P1, typename P2>
 335 struct Dispatcher<R(P1, P2)> {
 336   static void DispatchToCallback(
 337       const v8::FunctionCallbackInfo<v8::Value>& info) {
 338     Arguments args(info);
 339     v8::Handle<v8::External> v8_holder;
 340     CHECK(args.GetData(&v8_holder));
 341     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
 342         v8_holder->Value());
 343
 344     typedef CallbackHolder<R(P1, P2)> HolderT;
 345     HolderT* holder = static_cast<HolderT*>(holder_base);
 346
 347     typename CallbackParamTraits<P1>::LocalType a1;
 348     typename CallbackParamTraits<P2>::LocalType a2;
 349     if (!GetNextArgument(&args, holder->flags, true, &a1) ||
 350         !GetNextArgument(&args, holder->flags, false, &a2)) {
 351       args.ThrowError();
 352       return;
 353     }
 354
 355     Invoker<R, P1, P2>::Go(&args, holder->callback, a1, a2);
 356   }
 357 };
 358
 359 template<typename R, typename P1, typename P2, typename P3>
 360 struct Dispatcher<R(P1, P2, P3)> {
 361   static void DispatchToCallback(
 362       const v8::FunctionCallbackInfo<v8::Value>& info) {
 363     Arguments args(info);
 364     v8::Handle<v8::External> v8_holder;
 365     CHECK(args.GetData(&v8_holder));
 366     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
 367         v8_holder->Value());
 368
 369     typedef CallbackHolder<R(P1, P2, P3)> HolderT;
 370     HolderT* holder = static_cast<HolderT*>(holder_base);
 371
 372     typename CallbackParamTraits<P1>::LocalType a1;
 373     typename CallbackParamTraits<P2>::LocalType a2;
 374     typename CallbackParamTraits<P3>::LocalType a3;
 375     if (!GetNextArgument(&args, holder->flags, true, &a1) ||
 376         !GetNextArgument(&args, holder->flags, false, &a2) ||
 377         !GetNextArgument(&args, holder->flags, false, &a3)) {
 378       args.ThrowError();
 379       return;
 380     }
 381
 382     Invoker<R, P1, P2, P3>::Go(&args, holder->callback, a1, a2, a3);
 383   }
 384 };
 385
 386 template<typename R, typename P1, typename P2, typename P3, typename P4>
 387 struct Dispatcher<R(P1, P2, P3, P4)> {
 388   static void DispatchToCallback(
 389       const v8::FunctionCallbackInfo<v8::Value>& info) {
 390     Arguments args(info);
 391     v8::Handle<v8::External> v8_holder;
 392     CHECK(args.GetData(&v8_holder));
 393     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
 394         v8_holder->Value());
 395
 396     typedef CallbackHolder<R(P1, P2, P3, P4)> HolderT;
 397     HolderT* holder = static_cast<HolderT*>(holder_base);
 398
 399     typename CallbackParamTraits<P1>::LocalType a1;
 400     typename CallbackParamTraits<P2>::LocalType a2;
 401     typename CallbackParamTraits<P3>::LocalType a3;
 402     typename CallbackParamTraits<P4>::LocalType a4;
 403     if (!GetNextArgument(&args, holder->flags, true, &a1) ||
 404         !GetNextArgument(&args, holder->flags, false, &a2) ||
 405         !GetNextArgument(&args, holder->flags, false, &a3) ||
 406         !GetNextArgument(&args, holder->flags, false, &a4)) {
 407       args.ThrowError();
 408       return;
 409     }
 410
 411     Invoker<R, P1, P2, P3, P4>::Go(&args, holder->callback, a1, a2, a3, a4);
 412   }
 413 };
 414
 415 template<typename R, typename P1, typename P2, typename P3, typename P4,
 416     typename P5>
 417 struct Dispatcher<R(P1, P2, P3, P4, P5)> {
 418   static void DispatchToCallback(
 419       const v8::FunctionCallbackInfo<v8::Value>& info) {
 420     Arguments args(info);
 421     v8::Handle<v8::External> v8_holder;
 422     CHECK(args.GetData(&v8_holder));
 423     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
 424         v8_holder->Value());
 425
 426     typedef CallbackHolder<R(P1, P2, P3, P4, P5)> HolderT;
 427     HolderT* holder = static_cast<HolderT*>(holder_base);
 428
 429     typename CallbackParamTraits<P1>::LocalType a1;
 430     typename CallbackParamTraits<P2>::LocalType a2;
 431     typename CallbackParamTraits<P3>::LocalType a3;
 432     typename CallbackParamTraits<P4>::LocalType a4;
 433     typename CallbackParamTraits<P5>::LocalType a5;
 434     if (!GetNextArgument(&args, holder->flags, true, &a1) ||
 435         !GetNextArgument(&args, holder->flags, false, &a2) ||
 436         !GetNextArgument(&args, holder->flags, false, &a3) ||
 437         !GetNextArgument(&args, holder->flags, false, &a4) ||
 438         !GetNextArgument(&args, holder->flags, false, &a5)) {
 439       args.ThrowError();
 440       return;
 441     }
 442
 443     Invoker<R, P1, P2, P3, P4, P5>::Go(&args, holder->callback, a1, a2, a3, a4,
 444         a5);
 445   }
 446 };
 447
 448 template<typename R, typename P1, typename P2, typename P3, typename P4,
 449     typename P5, typename P6>
 450 struct Dispatcher<R(P1, P2, P3, P4, P5, P6)> {
 451   static void DispatchToCallback(
 452       const v8::FunctionCallbackInfo<v8::Value>& info) {
 453     Arguments args(info);
 454     v8::Handle<v8::External> v8_holder;
 455     CHECK(args.GetData(&v8_holder));
 456     CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
 457         v8_holder->Value());
 458
 459     typedef CallbackHolder<R(P1, P2, P3, P4, P5, P6)> HolderT;
 460     HolderT* holder = static_cast<HolderT*>(holder_base);
 461
 462     typename CallbackParamTraits<P1>::LocalType a1;
 463     typename CallbackParamTraits<P2>::LocalType a2;
 464     typename CallbackParamTraits<P3>::LocalType a3;
 465     typename CallbackParamTraits<P4>::LocalType a4;
 466     typename CallbackParamTraits<P5>::LocalType a5;
 467     typename CallbackParamTraits<P6>::LocalType a6;
 468     if (!GetNextArgument(&args, holder->flags, true, &a1) ||
 469         !GetNextArgument(&args, holder->flags, false, &a2) ||
 470         !GetNextArgument(&args, holder->flags, false, &a3) ||
 471         !GetNextArgument(&args, holder->flags, false, &a4) ||
 472         !GetNextArgument(&args, holder->flags, false, &a5) ||
 473         !GetNextArgument(&args, holder->flags, false, &a6)) {
 474       args.ThrowError();
 475       return;
 476     }
 477
 478     Invoker<R, P1, P2, P3, P4, P5, P6>::Go(&args, holder->callback, a1, a2, a3,
 479         a4, a5, a6);
 480   }
 481 };
 482
 483 }  // namespace internal
 484
 485
 486 // CreateFunctionTemplate creates a v8::FunctionTemplate that will create
 487 // JavaScript functions that execute a provided C++ function or base::Callback.
 488 // JavaScript arguments are automatically converted via gin::Converter, as is
 489 // the return value of the C++ function, if any.
 490 template<typename Sig>
 491 v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
 492     v8::Isolate* isolate, const base::Callback<Sig> callback,
 493     int callback_flags = 0) {
 494   typedef internal::CallbackHolder<Sig> HolderT;
 495   HolderT* holder = new HolderT(isolate, callback, callback_flags);
 496
 497   return v8::FunctionTemplate::New(
 498       isolate,
 499       &internal::Dispatcher<Sig>::DispatchToCallback,
 500       ConvertToV8<v8::Handle<v8::External> >(isolate,
 501                                              holder->GetHandle(isolate)));
 502 }
 503
 504 }  // namespace gin
 505
 506 #endif  // GIN_FUNCTION_TEMPLATE_H_