Implement more of the JavaScript GL API.

Right now I am just translating as directly as possible from the C spinning cube demo -- once it all works I will circle back through and refine the JavaScript.

R=abarth@chromium.org

Review URL: https://codereview.chromium.org/114883003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@242230 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 168 insertions, 18 deletions

diff --git a/gin/converter.cc b/gin/converter.cc
index 54736f95..07437b7 100644
--- a/gin/converter.cc
+++ b/gin/converter.cc
@@ -79,6 +79,18 @@ bool Converter<uint64_t>::FromV8(Isolate* isolate, Handle<Value> val,
   return true;
 }
 
+Handle<Value> Converter<float>::ToV8(Isolate* isolate, float val) {
+  return Number::New(isolate, val).As<Value>();
+}
+
+bool Converter<float>::FromV8(Isolate* isolate, Handle<Value> val,
+                              float* out) {
+  if (!val->IsNumber())
+    return false;
+  *out = static_cast<float>(val->NumberValue());
+  return true;
+}
+
 Handle<Value> Converter<double>::ToV8(Isolate* isolate, double val) {
   return Number::New(isolate, val).As<Value>();
 }
diff --git a/gin/converter.h b/gin/converter.h
index ee029a7..1ce459e 100644
--- a/gin/converter.h
+++ b/gin/converter.h
@@ -65,6 +65,15 @@ struct GIN_EXPORT Converter<uint64_t> {
 };
 
 template<>
+struct GIN_EXPORT Converter<float> {
+  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+                                    float val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     float* out);
+};
+
+template<>
 struct GIN_EXPORT Converter<double> {
   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
                                     double val);
diff --git a/gin/function_template.h b/gin/function_template.h
index 91b3cdb..202fe6f 100644
--- a/gin/function_template.h
+++ b/gin/function_template.h
@@ -62,6 +62,7 @@ struct CallbackParamTraits<const T*> {
 class GIN_EXPORT CallbackHolderBase : public Wrappable<CallbackHolderBase> {
  public:
   static WrapperInfo kWrapperInfo;
+
  protected:
   virtual ~CallbackHolderBase() {}
 };
@@ -86,10 +87,69 @@ class CallbackHolder : public CallbackHolderBase {
 // expression to foo. As a result, we must specialize the case of Callbacks that
 // have the void return type.
 template<typename R, typename P1 = void, typename P2 = void,
-    typename P3 = void, typename P4 = void>
+    typename P3 = void, typename P4 = void, typename P5 = void,
+    typename P6 = void>
 struct Invoker {
   inline static void Go(
       Arguments* args,
+      const base::Callback<R(P1, P2, P3, P4, P5, P6)>& callback,
+      const P1& a1,
+      const P2& a2,
+      const P3& a3,
+      const P4& a4,
+      const P5& a5,
+      const P6& a6) {
+    args->Return(callback.Run(a1, a2, a3, a4, a5, a6));
+  }
+};
+template<typename P1, typename P2, typename P3, typename P4, typename P5,
+    typename P6>
+struct Invoker<void, P1, P2, P3, P4, P5, P6> {
+  inline static void Go(
+      Arguments* args,
+      const base::Callback<void(P1, P2, P3, P4, P5, P6)>& callback,
+      const P1& a1,
+      const P2& a2,
+      const P3& a3,
+      const P4& a4,
+      const P5& a5,
+      const P6& a6) {
+    callback.Run(a1, a2, a3, a4, a5, a6);
+  }
+};
+
+template<typename R, typename P1, typename P2, typename P3, typename P4,
+    typename P5>
+struct Invoker<R, P1, P2, P3, P4, P5, void> {
+  inline static void Go(
+      Arguments* args,
+      const base::Callback<R(P1, P2, P3, P4, P5)>& callback,
+      const P1& a1,
+      const P2& a2,
+      const P3& a3,
+      const P4& a4,
+      const P5& a5) {
+    args->Return(callback.Run(a1, a2, a3, a4, a5));
+  }
+};
+template<typename P1, typename P2, typename P3, typename P4, typename P5>
+struct Invoker<void, P1, P2, P3, P4, P5, void> {
+  inline static void Go(
+      Arguments* args,
+      const base::Callback<void(P1, P2, P3, P4, P5)>& callback,
+      const P1& a1,
+      const P2& a2,
+      const P3& a3,
+      const P4& a4,
+      const P5& a5) {
+    callback.Run(a1, a2, a3, a4, a5);
+  }
+};
+
+template<typename R, typename P1, typename P2, typename P3, typename P4>
+struct Invoker<R, P1, P2, P3, P4, void, void> {
+  inline static void Go(
+      Arguments* args,
       const base::Callback<R(P1, P2, P3, P4)>& callback,
       const P1& a1,
       const P2& a2,
@@ -99,7 +159,7 @@ struct Invoker {
   }
 };
 template<typename P1, typename P2, typename P3, typename P4>
-struct Invoker<void, P1, P2, P3, P4> {
+struct Invoker<void, P1, P2, P3, P4, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void(P1, P2, P3, P4)>& callback,
@@ -112,7 +172,7 @@ struct Invoker<void, P1, P2, P3, P4> {
 };
 
 template<typename R, typename P1, typename P2, typename P3>
-struct Invoker<R, P1, P2, P3, void> {
+struct Invoker<R, P1, P2, P3, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<R(P1, P2, P3)>& callback,
@@ -123,7 +183,7 @@ struct Invoker<R, P1, P2, P3, void> {
   }
 };
 template<typename P1, typename P2, typename P3>
-struct Invoker<void, P1, P2, P3, void> {
+struct Invoker<void, P1, P2, P3, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void(P1, P2, P3)>& callback,
@@ -135,7 +195,7 @@ struct Invoker<void, P1, P2, P3, void> {
 };
 
 template<typename R, typename P1, typename P2>
-struct Invoker<R, P1, P2, void, void> {
+struct Invoker<R, P1, P2, void, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<R(P1, P2)>& callback,
@@ -145,7 +205,7 @@ struct Invoker<R, P1, P2, void, void> {
   }
 };
 template<typename P1, typename P2>
-struct Invoker<void, P1, P2, void, void> {
+struct Invoker<void, P1, P2, void, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void(P1, P2)>& callback,
@@ -156,7 +216,7 @@ struct Invoker<void, P1, P2, void, void> {
 };
 
 template<typename R, typename P1>
-struct Invoker<R, P1, void, void, void> {
+struct Invoker<R, P1, void, void, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<R(P1)>& callback,
@@ -165,7 +225,7 @@ struct Invoker<R, P1, void, void, void> {
   }
 };
 template<typename P1>
-struct Invoker<void, P1, void, void, void> {
+struct Invoker<void, P1, void, void, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void(P1)>& callback,
@@ -175,7 +235,7 @@ struct Invoker<void, P1, void, void, void> {
 };
 
 template<typename R>
-struct Invoker<R, void, void, void, void> {
+struct Invoker<R, void, void, void, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<R()>& callback) {
@@ -183,7 +243,7 @@ struct Invoker<R, void, void, void, void> {
   }
 };
 template<>
-struct Invoker<void, void, void, void, void> {
+struct Invoker<void, void, void, void, void, void, void> {
   inline static void Go(
       Arguments* args,
       const base::Callback<void()>& callback) {
@@ -328,6 +388,70 @@ struct Dispatcher<R(P1, P2, P3, P4)> {
   }
 };
 
+template<typename R, typename P1, typename P2, typename P3, typename P4,
+    typename P5>
+struct Dispatcher<R(P1, P2, P3, P4, P5)> {
+  static void DispatchToCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info) {
+    Arguments args(info);
+    CallbackHolderBase* holder_base = NULL;
+    CHECK(args.GetData(&holder_base));
+
+    typedef CallbackHolder<R(P1, P2, P3, P4, P5)> HolderT;
+    HolderT* holder = static_cast<HolderT*>(holder_base);
+
+    typename CallbackParamTraits<P1>::LocalType a1;
+    typename CallbackParamTraits<P2>::LocalType a2;
+    typename CallbackParamTraits<P3>::LocalType a3;
+    typename CallbackParamTraits<P4>::LocalType a4;
+    typename CallbackParamTraits<P5>::LocalType a5;
+    if (!GetNextArgument(&args, holder->flags, true, &a1) ||
+        !GetNextArgument(&args, holder->flags, false, &a2) ||
+        !GetNextArgument(&args, holder->flags, false, &a3) ||
+        !GetNextArgument(&args, holder->flags, false, &a4) ||
+        !GetNextArgument(&args, holder->flags, false, &a5)) {
+      args.ThrowError();
+      return;
+    }
+
+    Invoker<R, P1, P2, P3, P4, P5>::Go(&args, holder->callback, a1, a2, a3, a4,
+        a5);
+  }
+};
+
+template<typename R, typename P1, typename P2, typename P3, typename P4,
+    typename P5, typename P6>
+struct Dispatcher<R(P1, P2, P3, P4, P5, P6)> {
+  static void DispatchToCallback(
+      const v8::FunctionCallbackInfo<v8::Value>& info) {
+    Arguments args(info);
+    CallbackHolderBase* holder_base = NULL;
+    CHECK(args.GetData(&holder_base));
+
+    typedef CallbackHolder<R(P1, P2, P3, P4, P5, P6)> HolderT;
+    HolderT* holder = static_cast<HolderT*>(holder_base);
+
+    typename CallbackParamTraits<P1>::LocalType a1;
+    typename CallbackParamTraits<P2>::LocalType a2;
+    typename CallbackParamTraits<P3>::LocalType a3;
+    typename CallbackParamTraits<P4>::LocalType a4;
+    typename CallbackParamTraits<P5>::LocalType a5;
+    typename CallbackParamTraits<P6>::LocalType a6;
+    if (!GetNextArgument(&args, holder->flags, true, &a1) ||
+        !GetNextArgument(&args, holder->flags, false, &a2) ||
+        !GetNextArgument(&args, holder->flags, false, &a3) ||
+        !GetNextArgument(&args, holder->flags, false, &a4) ||
+        !GetNextArgument(&args, holder->flags, false, &a5) ||
+        !GetNextArgument(&args, holder->flags, false, &a6)) {
+      args.ThrowError();
+      return;
+    }
+
+    Invoker<R, P1, P2, P3, P4, P5, P6>::Go(&args, holder->callback, a1, a2, a3,
+        a4, a5, a6);
+  }
+};
+
 }  // namespace internal
 
 
diff --git a/gin/function_template.h.pump b/gin/function_template.h.pump
index 6c1dbfa2..90ae516 100644
--- a/gin/function_template.h.pump
+++ b/gin/function_template.h.pump
@@ -8,7 +8,7 @@ $$
 #ifndef GIN_FUNCTION_TEMPLATE_H_
 #define GIN_FUNCTION_TEMPLATE_H_
 
-$var MAX_ARITY = 4
+$var MAX_ARITY = 6
 
 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
diff --git a/gin/modules/file_module_provider.cc b/gin/modules/file_module_provider.cc
index 990dcd0..660d9b1 100644
--- a/gin/modules/file_module_provider.cc
+++ b/gin/modules/file_module_provider.cc
@@ -37,10 +37,7 @@ void AttempToLoadModule(const base::WeakPtr<Runner>& runner,
       continue;
 
     Runner::Scope scope(runner.get());
-    v8::Handle<v8::Script> script = v8::Script::New(
-        StringToV8(runner->isolate(), source),
-        StringToV8(runner->isolate(), id));
-    runner->Run(script);
+    runner->Run(source, id);
     return;
   }
 }
diff --git a/gin/runner.cc b/gin/runner.cc
index 37e16a0..d1ac4aa 100644
--- a/gin/runner.cc
+++ b/gin/runner.cc
@@ -59,8 +59,15 @@ Runner::~Runner() {
 }
 
 void Runner::Run(const std::string& source, const std::string& resource_name) {
-  Run(Script::New(StringToV8(isolate(), source),
-                  StringToV8(isolate(), resource_name)));
+  TryCatch try_catch;
+  v8::Handle<Script> script = Script::New(StringToV8(isolate(), source),
+                                          StringToV8(isolate(), resource_name));
+  if (try_catch.HasCaught()) {
+    delegate_->UnhandledException(this, try_catch);
+    return;
+  }
+
+  Run(script);
 }
 
 void Runner::Run(v8::Handle<Script> script) {
@@ -84,8 +91,9 @@ v8::Handle<v8::Value> Runner::Call(v8::Handle<v8::Function> function,
   v8::Handle<v8::Value> result = function->Call(receiver, argc, argv);
 
   delegate_->DidRunScript(this);
-  if (try_catch.HasCaught())
+  if (try_catch.HasCaught()) {
     delegate_->UnhandledException(this, try_catch);
+  }
 
   return result;
 }