Allow multiple concurrent timers.

experimental/SkV8Example/Global.h

 /*
  * Copyright 2013 Google Inc.
  *
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  */
 
 #ifndef SkV8Example_Global_DEFINED
 #define SkV8Example_Global_DEFINED
 

[robertphillips, 2013/12/20 14:49:43]

I'm not sure if we want to start using STL. Thoughts?

[jcgregorio, 2013/12/20 14:53:07]

Yeah, I was hesitant on that, are there Sk* alternatives? 

OTOH, this is just a sample and not part of Skia core, so I'm not sure how much
it matters.

+#include <map>
+
 #include <v8.h>
 
 using namespace v8;
 
 #include "SkTypes.h"
 #include "SkEvent.h"
 
 class SkOSWindow;
 
+typedef Persistent<Function, CopyablePersistentTraits<Function> > CopyablePersistentFn;
+
 // Provides the global isolate and context for our V8 instance.
 // Also implements all the global level functions.
 class Global : SkNoncopyable  {
 public:
     Global(Isolate* isolate)
         : fIsolate(isolate)
         , fWindow(NULL)
+        , fLastTimerID(0)
     {
         gGlobal = this;
     }
     virtual ~Global() {}
 
     // The script will be parsed into the context this Global contains.
     bool parseScript(const char script[]);
 
     Local<Context> getContext() {
         return Local<Context>::New(fIsolate, fContext);
     }
 
     Isolate* getIsolate() {
         return fIsolate;
     }
 
     void setWindow(SkOSWindow* win) {
         fWindow = win;
     }
     SkOSWindow* getWindow() {
         return fWindow;
     }
 
     void reportException(TryCatch* tryCatch);
 
 private:
     Handle<Context> createRootContext();
+    int32_t getNextTimerID();
 
     static bool TimeOutProc(const SkEvent& evt);
 
     // Static functions that implement the global JS functions we add to
     // the context.
     static void SetTimeout(const v8::FunctionCallbackInfo<v8::Value>& args);
     static void Print(const v8::FunctionCallbackInfo<v8::Value>& args);
     static void Inval(const v8::FunctionCallbackInfo<Value>& args);
 
     Persistent<Context> fContext;
     Isolate*            fIsolate;
     SkOSWindow*         fWindow;
     static Global*      gGlobal;
 
-    // Handle to the function to call when the timeout triggers.
-    Persistent<Function> fTimeout;
+    // Handle to the functions to call when a timeout triggers as indexed by id.
+    std::map<int32_t, CopyablePersistentFn > fTimeouts;
+
+    // Last timer ID generated.
+    int32_t fLastTimerID;
 };
 
 #endif