Allow multiple concurrent timers.

experimental/SkV8Example/Global.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  */
 #include "Global.h"
 
 #include "SkWindow.h"
 #include "SkEvent.h"
 
 
 Global* Global::gGlobal = NULL;
 
 // Extracts a C string from a V8 Utf8Value.
 static const char* to_cstring(const v8::String::Utf8Value& value) {
     return *value ? *value : "<string conversion failed>";
 }
 
+int32_t Global::getNextTimerID() {
+    do {
+        fLastTimerID++;
+        if (fLastTimerID < 0) {
+            fLastTimerID = 0;
+        }
+    } while (fTimeouts.find(fLastTimerID) != fTimeouts.end());
+    return fLastTimerID;
+}
+
 // Slight modification to an original function found in the V8 sample shell.cc.
 void Global::reportException(TryCatch* tryCatch) {
     HandleScope handleScope(fIsolate);
     String::Utf8Value exception(tryCatch->Exception());
     const char* exceptionString = to_cstring(exception);
     Handle<Message> message = tryCatch->Message();
     if (message.IsEmpty()) {
         // V8 didn't provide any extra information about this error; just
         // print the exception.
         fprintf(stderr, "%s\n", exceptionString);
@@ skipping 52 matching lines @@
         printf("%s", to_cstring(str));
     }
     printf("\n");
     fflush(stdout);
 }
 
 // The callback that is invoked by v8 whenever the JavaScript 'setTimeout'
 // function is called.
 //
 // JS: setTimeout(on_timeout, 500);
-//
-// TODO(jcgregorio) Currently only handles one timeout, should support any
-// number.
 void Global::SetTimeout(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 2) {
         args.GetIsolate()->ThrowException(
                 v8::String::NewFromUtf8(
                         args.GetIsolate(), "Error: 2 arguments required."));
         return;
     }
 
     // Pull out the first arg, make sure it's a function.
     if (!args[0]->IsFunction()) {
         printf("Not a function passed to setTimeout.\n");
         return;
     }
     Handle<Function> timeoutFn = Handle<Function>::Cast(args[0]);
-    gGlobal->fTimeout.Reset(args.GetIsolate(), timeoutFn);
 
     double delay = args[1]->NumberValue();
+    int32_t id = gGlobal->getNextTimerID();
+
+    gGlobal->fTimeouts[id].Reset(gGlobal->fIsolate, timeoutFn);
 
     // Create an SkEvent and add it with the right delay.
-    (new SkEvent())->setTargetProc(Global::TimeOutProc)->postDelay(delay);
+    SkEvent* evt = new SkEvent();
+    evt->setTargetProc(Global::TimeOutProc);
+    evt->setFast32(id);
+    evt->postDelay(delay);
 
-    // TODO(jcgregorio) Return the ID as the return value.
+    args.GetReturnValue().Set(Integer::New(id));
 }
 
 // Callback function for SkEvents used to implement timeouts.
 bool Global::TimeOutProc(const SkEvent& evt) {
     // Create a handle scope to keep the temporary object references.
     HandleScope handleScope(gGlobal->getIsolate());
 
     // Create a local context from our global context.
     Local<Context> context = gGlobal->getContext();
 
     // Enter the context so all the remaining operations take place there.
     Context::Scope contextScope(context);
 
     // Set up an exception handler before calling the Process function.
     TryCatch tryCatch;
 
+    int32_t id = evt.getFast32();
+    if (gGlobal->fTimeouts.find(gGlobal->fLastTimerID) == gGlobal->fTimeouts.end()) {
+        printf("Not a valid timer ID.\n");
+        return true;
+    }
+
     const int argc = 0;
     Local<Function> onTimeout =
-            Local<Function>::New(gGlobal->getIsolate(), gGlobal->fTimeout);
+            Local<Function>::New(gGlobal->getIsolate(), gGlobal->fTimeouts[id]);
     Handle<Value> result = onTimeout->Call(context->Global(), argc, NULL);
+    gGlobal->fTimeouts.erase(id);
 
     // Handle any exceptions or output.
     if (result.IsEmpty()) {
         SkASSERT(tryCatch.HasCaught());
         // Print errors that happened during execution.
         gGlobal->reportException(&tryCatch);
     } else {
         SkASSERT(!tryCatch.HasCaught());
         if (!result->IsUndefined()) {
             // If all went well and the result wasn't undefined then print the
@@ skipping 58 matching lines @@
 
     // Try running it now to create the onDraw function.
     Handle<Value> result = compiledScript->Run();
 
     // Handle any exceptions or output.
     if (result.IsEmpty()) {
         SkASSERT(tryCatch.HasCaught());
         // Print errors that happened during execution.
         this->reportException(&tryCatch);
         return false;
-    } else {
-        SkASSERT(!tryCatch.HasCaught());
-        if (!result->IsUndefined()) {
-            // If all went well and the result wasn't undefined then print
-            // the returned value.
-            String::Utf8Value str(result);
-            const char* cstr = to_cstring(str);
-            printf("%s\n", cstr);
-            return false;
-        }
     }
 
     // Also make the context persistent.
     fContext.Reset(fIsolate, context);
     return true;
 }