Add a setTimer() function.

experimental/SkV8Example/SkV8Example.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 <v8.h>
 
 using namespace v8;
 
 #include "SkV8Example.h"
+#include "Global.h"
 
 #include "gl/GrGLUtil.h"
 #include "gl/GrGLDefines.h"
 #include "gl/GrGLInterface.h"
 #include "SkApplication.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkDraw.h"
 #include "SkGpuDevice.h"
 #include "SkGraphics.h"
 #include "SkScalar.h"
 
 
 DEFINE_string2(infile, i, NULL, "Name of file to load JS from.\n");
 
 void application_init() {
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
     SkGraphics::Term();
 }
 
 // Extracts a C string from a V8 Utf8Value.
-const char* ToCString(const v8::String::Utf8Value& value) {
+// TODO(jcgregrio) Currently dup'd in two files, fix.

[robertphillips, 2013/12/17 23:35:53]

to_cstring?

[jcgregorio, 2013/12/18 04:32:53]

Done.

+static const char* ToCString(const v8::String::Utf8Value& value) {
     return *value ? *value : "<string conversion failed>";
 }
 
-// Slight modification to an original function found in the V8 sample shell.cc.
-void reportException(Isolate* isolate, TryCatch* try_catch) {
-    HandleScope handleScope(isolate);
-    String::Utf8Value exception(try_catch->Exception());
-    const char* exception_string = ToCString(exception);
-    Handle<Message> message = try_catch->Message();
-    if (message.IsEmpty()) {
-        // V8 didn't provide any extra information about this error; just
-        // print the exception.
-        fprintf(stderr, "%s\n", exception_string);
-    } else {
-        // Print (filename):(line number): (message).
-        String::Utf8Value filename(message->GetScriptResourceName());
-        const char* filename_string = ToCString(filename);
-        int linenum = message->GetLineNumber();
-        fprintf(stderr,
-                "%s:%i: %s\n", filename_string, linenum, exception_string);
-        // Print line of source code.
-        String::Utf8Value sourceline(message->GetSourceLine());
-        const char* sourceline_string = ToCString(sourceline);
-        fprintf(stderr, "%s\n", sourceline_string);
-        // Print wavy underline.
-        int start = message->GetStartColumn();
-        for (int i = 0; i < start; i++) {
-            fprintf(stderr, " ");
-        }
-        int end = message->GetEndColumn();
-        for (int i = start; i < end; i++) {
-            fprintf(stderr, "^");
-        }
-        fprintf(stderr, "\n");
-        String::Utf8Value stack_trace(try_catch->StackTrace());
-        if (stack_trace.length() > 0) {
-            const char* stack_trace_string = ToCString(stack_trace);
-            fprintf(stderr, "%s\n", stack_trace_string);
-        }
-    }
-}
-
-SkV8ExampleWindow::SkV8ExampleWindow(void* hwnd, JsCanvas* canvas)
-    : INHERITED(hwnd)
-    , fJsCanvas(canvas)
-{
-    this->setConfig(SkBitmap::kARGB_8888_Config);
-    this->setVisibleP(true);
-    this->setClipToBounds(false);
-}
 
 JsCanvas* JsCanvas::Unwrap(Handle<Object> obj) {
     Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));
     void* ptr = field->Value();
     return static_cast<JsCanvas*>(ptr);
 }
 
-void JsCanvas::Inval(const v8::FunctionCallbackInfo<Value>& args) {
-    Unwrap(args.This())->fWindow->inval(NULL);
-}
-
 void JsCanvas::FillRect(const v8::FunctionCallbackInfo<Value>& args) {
     JsCanvas* jsCanvas = Unwrap(args.This());
     SkCanvas* canvas = jsCanvas->fCanvas;
 
     if (args.Length() != 4) {
         args.GetIsolate()->ThrowException(
                 v8::String::NewFromUtf8(
                         args.GetIsolate(), "Error: 4 arguments required."));
         return;
     }
@@ skipping 45 matching lines @@
     }
 
     long color = strtol(buf+1, NULL, 16);
     jsCanvas->fFillStyle.setColor(SkColorSetA(SkColor(color), SK_AlphaOPAQUE));
 }
 
 
 Persistent<ObjectTemplate> JsCanvas::fCanvasTemplate;
 
 Handle<ObjectTemplate> JsCanvas::makeCanvasTemplate() {
-    EscapableHandleScope handleScope(fIsolate);
+    EscapableHandleScope handleScope(fGlobal->getIsolate());
 
     Local<ObjectTemplate> result = ObjectTemplate::New();
 
     // Add a field to store the pointer to a JsCanvas instance.
     result->SetInternalFieldCount(1);
 
     // Add accessors for each of the fields of the canvas object.
     result->SetAccessor(
-      String::NewFromUtf8(fIsolate, "fillStyle", String::kInternalizedString),
+      String::NewFromUtf8(
+        fGlobal->getIsolate(), "fillStyle", String::kInternalizedString),
       GetFillStyle, SetFillStyle);
 
     // Add methods.
     result->Set(
             String::NewFromUtf8(
-                    fIsolate, "fillRect", String::kInternalizedString),
+                    fGlobal->getIsolate(), "fillRect",
+                    String::kInternalizedString),
             FunctionTemplate::New(FillRect));
-    result->Set(
-            String::NewFromUtf8(
-                    fIsolate, "inval", String::kInternalizedString),
-            FunctionTemplate::New(Inval));
 
     // Return the result through the current handle scope.
     return handleScope.Escape(result);
 }
 
 
 // Wraps 'this' in a Javascript object.
 Handle<Object> JsCanvas::wrap() {
     // Handle scope for temporary handles.
-    EscapableHandleScope handleScope(fIsolate);
+    EscapableHandleScope handleScope(fGlobal->getIsolate());
 
     // Fetch the template for creating JavaScript JsCanvas wrappers.
     // It only has to be created once, which we do on demand.
     if (fCanvasTemplate.IsEmpty()) {
         Handle<ObjectTemplate> raw_template = this->makeCanvasTemplate();
-        fCanvasTemplate.Reset(fIsolate, raw_template);
+        fCanvasTemplate.Reset(fGlobal->getIsolate(), raw_template);
     }
     Handle<ObjectTemplate> templ =
-            Local<ObjectTemplate>::New(fIsolate, fCanvasTemplate);
+            Local<ObjectTemplate>::New(fGlobal->getIsolate(), fCanvasTemplate);
 
     // Create an empty JsCanvas wrapper.
     Local<Object> result = templ->NewInstance();
 
     // Wrap the raw C++ pointer in an External so it can be referenced
     // from within JavaScript.
-    Handle<External> canvasPtr = External::New(fIsolate, this);
+    Handle<External> canvasPtr = External::New(fGlobal->getIsolate(), this);
 
     // Store the canvas pointer in the JavaScript wrapper.
     result->SetInternalField(0, canvasPtr);
 
     // Return the result through the current handle scope.  Since each
     // of these handles will go away when the handle scope is deleted
     // we need to call Close to let one, the result, escape into the
     // outer handle scope.
     return handleScope.Escape(result);
 }
 
-void JsCanvas::onDraw(SkCanvas* canvas, SkOSWindow* window) {
+void JsCanvas::onDraw(SkCanvas* canvas) {
     // Record canvas and window in this.
     fCanvas = canvas;
-    fWindow = window;
 
     // Create a handle scope to keep the temporary object references.
-    HandleScope handleScope(fIsolate);
+    HandleScope handleScope(fGlobal->getIsolate());
 
     // Create a local context from our global context.
-    Local<Context> context = Local<Context>::New(fIsolate, fContext);
+    Local<Context> context = fGlobal->getContext();
 
     // Enter the context so all the remaining operations take place there.
     Context::Scope contextScope(context);
 
     // Wrap the C++ this pointer in a JavaScript wrapper.
     Handle<Object> canvasObj = this->wrap();
 
     // Set up an exception handler before calling the Process function.
     TryCatch tryCatch;
 
     // Invoke the process function, giving the global object as 'this'
     // and one argument, this JsCanvas.
     const int argc = 1;
     Handle<Value> argv[argc] = { canvasObj };
     Local<Function> onDraw =
-            Local<Function>::New(fIsolate, fOnDraw);
+            Local<Function>::New(fGlobal->getIsolate(), fOnDraw);
     Handle<Value> result = onDraw->Call(context->Global(), argc, argv);
 
     // Handle any exceptions or output.
     if (result.IsEmpty()) {
         SkASSERT(tryCatch.HasCaught());
         // Print errors that happened during execution.
-        reportException(fIsolate, &tryCatch);
+        fGlobal->reportException(&tryCatch);
     } 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 = ToCString(str);
             printf("%s\n", cstr);
         }
     }
 }
 
-void SkV8ExampleWindow::onDraw(SkCanvas* canvas) {
-
-    canvas->save();
-    canvas->drawColor(SK_ColorWHITE);
-
-    // Now jump into JS and call the onDraw(canvas) method defined there.
-    fJsCanvas->onDraw(canvas, this);
-
-    canvas->restore();
-
-    INHERITED::onDraw(canvas);
-}
-
-
-#ifdef SK_BUILD_FOR_WIN
-void SkV8ExampleWindow::onHandleInval(const SkIRect& rect) {
-    RECT winRect;
-    winRect.top = rect.top();
-    winRect.bottom = rect.bottom();
-    winRect.right = rect.right();
-    winRect.left = rect.left();
-    InvalidateRect((HWND)this->getHWND(), &winRect, false);
-}
-#endif
-
-
-// The callback that is invoked by v8 whenever the JavaScript 'print'
-// function is called.  Prints its arguments on stdout separated by
-// spaces and ending with a newline.
-void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    bool first = true;
-    HandleScope handle_scope(args.GetIsolate());
-    for (int i = 0; i < args.Length(); i++) {
-        if (first) {
-            first = false;
-        } else {
-            printf(" ");
-        }
-        v8::String::Utf8Value str(args[i]);
-        printf("%s", ToCString(str));
-    }
-    printf("\n");
-    fflush(stdout);
-}
-
-
-// Creates a new execution environment containing the built-in
-// function draw().
-Handle<Context> createRootContext(Isolate* isolate) {
-  // Create a template for the global object.
-  Handle<ObjectTemplate> global = ObjectTemplate::New();
-
-  // This is where we would inject any globals into the root Context
-  // using global->Set(...)
-
-  global->Set(v8::String::NewFromUtf8(isolate, "print"),
-              v8::FunctionTemplate::New(Print));
-
-  return Context::New(isolate, NULL, global);
-}
-
-
-// Parse and run script. Then fetch out the onDraw function from the global
-// object.
-bool JsCanvas::initialize(const char script[]) {
+// Fetch the onDraw function from the global context.
+bool JsCanvas::initialize() {
 
     // Create a stack-allocated handle scope.
-    HandleScope handleScope(fIsolate);
+    HandleScope handleScope(fGlobal->getIsolate());
 
-    printf("Before create context\n");
-
-    // Create a new context.
-    Handle<Context> context = createRootContext(fIsolate);
+    // Create a local context from our global context.
+    Local<Context> context = fGlobal->getContext();
 
     // Enter the scope so all operations take place in the scope.
     Context::Scope contextScope(context);
 
     v8::TryCatch try_catch;
 
-    // Compile the source code.
-    Handle<String> source = String::NewFromUtf8(fIsolate, script);
-    printf("Before Compile\n");
-    Handle<Script> compiled_script = Script::Compile(source);
-    printf("After Compile\n");
-
-    if (compiled_script.IsEmpty()) {
-        // Print errors that happened during compilation.
-        reportException(fIsolate, &try_catch);
-        return false;
-    }
-    printf("After Exception.\n");
-
-    // Try running it now to create the onDraw function.
-    Handle<Value> result = compiled_script->Run();
-
-    // Handle any exceptions or output.
-    if (result.IsEmpty()) {
-        SkASSERT(try_catch.HasCaught());
-        // Print errors that happened during execution.
-        reportException(fIsolate, &try_catch);
-        return false;
-    } else {
-        SkASSERT(!try_catch.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 = ToCString(str);
-            printf("%s\n", cstr);
-            return false;
-        }
-    }
-
-    Handle<String> fn_name = String::NewFromUtf8(fIsolate, "onDraw");
+    Handle<String> fn_name = String::NewFromUtf8(
+        fGlobal->getIsolate(), "onDraw");
     Handle<Value> fn_val = context->Global()->Get(fn_name);
 
     if (!fn_val->IsFunction()) {
         printf("Not a function.\n");
         return false;
     }
 
     // It is a function; cast it to a Function.
     Handle<Function> fn_fun = Handle<Function>::Cast(fn_val);
 
     // Store the function in a Persistent handle, since we also want that to
     // remain after this call returns.
-    fOnDraw.Reset(fIsolate, fn_fun);
+    fOnDraw.Reset(fGlobal->getIsolate(), fn_fun);
 
-    // Also make the context persistent.
-    fContext.Reset(fIsolate, context);
     return true;
 }
 
+
+SkV8ExampleWindow::SkV8ExampleWindow(void* hwnd, JsCanvas* canvas)
+    : INHERITED(hwnd)
+    , fJsCanvas(canvas)
+{
+    this->setConfig(SkBitmap::kARGB_8888_Config);
+    this->setVisibleP(true);
+    this->setClipToBounds(false);
+}
+
+void SkV8ExampleWindow::onDraw(SkCanvas* canvas) {
+
+    canvas->save();
+    canvas->drawColor(SK_ColorWHITE);
+
+    // Now jump into JS and call the onDraw(canvas) method defined there.
+    fJsCanvas->onDraw(canvas);
+
+    canvas->restore();
+
+    INHERITED::onDraw(canvas);
+}
+
+
+#ifdef SK_BUILD_FOR_WIN
+void SkV8ExampleWindow::onHandleInval(const SkIRect& rect) {
+    RECT winRect;
+    winRect.top = rect.top();
+    winRect.bottom = rect.bottom();
+    winRect.right = rect.right();
+    winRect.left = rect.left();
+    InvalidateRect((HWND)this->getHWND(), &winRect, false);
+}
+#endif
+
 SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv) {
     printf("Started\n");
 
     SkCommandLineFlags::Parse(argc, argv);
 
     // Get the default Isolate created at startup.
     Isolate* isolate = Isolate::GetCurrent();
-
-    JsCanvas* jsCanvas = new JsCanvas(isolate);
+    Global* global = new Global(isolate);
 
     const char* script =
 "function onDraw(canvas) {              \n"
 "    canvas.fillStyle = '#00FF00';      \n"
 "    canvas.fillRect(20, 20, 100, 100); \n"
 "    canvas.inval();                    \n"
 "}                                      \n";
 
     SkAutoTUnref<SkData> data;
     if (FLAGS_infile.count()) {
         data.reset(SkData::NewFromFileName(FLAGS_infile[0]));
         script = static_cast<const char*>(data->data());
     }
     if (NULL == script) {
         printf("Could not load file: %s.\n", FLAGS_infile[0]);
         exit(1);
     }
-    if (!jsCanvas->initialize(script)) {
+
+    if (!global->parseScript(script)) {
+        exit(1);
+    }
+
+    JsCanvas* jsCanvas = new JsCanvas(global);
+
+    if (!jsCanvas->initialize()) {
         printf("Failed to initialize.\n");
         exit(1);
     }
-    return new SkV8ExampleWindow(hwnd, jsCanvas);
+    SkV8ExampleWindow* win = new SkV8ExampleWindow(hwnd, jsCanvas);
+    global->setWindow(win);
+    return win;
 }