src/third_party/skia/experimental/SkV8Example/JsContext.cpp

   1
   2 /*
   3  * Copyright 2013 Google Inc.
   4  *
   5  *
   6  * Use of this source code is governed by a BSD-style license that can be
   7  * found in the LICENSE file.
   8  *
   9  */
  10 #include <v8.h>
  11
  12 #include "Global.h"
  13 #include "JsContext.h"
  14 #include "Path2D.h"
  15 #include "SkCanvas.h"
  16
  17
  18 // Extracts a C string from a V8 Utf8Value.
  19 // TODO(jcgregrio) Currently dup'd in two files, fix.
  20 static const char* to_cstring(const v8::String::Utf8Value& value) {
  21     return *value ? *value : "<string conversion failed>";
  22 }
  23
  24 v8::Persistent<v8::ObjectTemplate> JsContext::gContextTemplate;
  25
  26 // Wraps 'this' in a Javascript object.
  27 v8::Handle<v8::Object> JsContext::wrap() {
  28     // Handle scope for temporary handles.
  29     v8::EscapableHandleScope handleScope(fGlobal->getIsolate());
  30
  31     // Fetch the template for creating JavaScript JsContext wrappers.
  32     // It only has to be created once, which we do on demand.
  33     if (gContextTemplate.IsEmpty()) {
  34         v8::Local<v8::ObjectTemplate> localTemplate = v8::ObjectTemplate::New();
  35
  36         // Add a field to store the pointer to a JsContext instance.
  37         localTemplate->SetInternalFieldCount(1);
  38
  39         this->addAttributesAndMethods(localTemplate);
  40
  41         gContextTemplate.Reset(fGlobal->getIsolate(), localTemplate);
  42     }
  43     v8::Handle<v8::ObjectTemplate> templ =
  44             v8::Local<v8::ObjectTemplate>::New(fGlobal->getIsolate(), gContextTemplate);
  45
  46     // Create an empty JsContext wrapper.
  47     v8::Local<v8::Object> result = templ->NewInstance();
  48
  49     // Wrap the raw C++ pointer in an External so it can be referenced
  50     // from within JavaScript.
  51     v8::Handle<v8::External> contextPtr = v8::External::New(fGlobal->getIsolate(), this);
  52
  53     // Store the context pointer in the JavaScript wrapper.
  54     result->SetInternalField(0, contextPtr);
  55
  56     // Return the result through the current handle scope.  Since each
  57     // of these handles will go away when the handle scope is deleted
  58     // we need to call Close to let one, the result, escape into the
  59     // outer handle scope.
  60     return handleScope.Escape(result);
  61 }
  62
  63 void JsContext::onDraw(SkCanvas* canvas) {
  64     // Record canvas and window in this.
  65     fCanvas = canvas;
  66
  67     // Create a handle scope to keep the temporary object references.
  68     v8::HandleScope handleScope(fGlobal->getIsolate());
  69
  70     // Create a local context from our global context.
  71     v8::Local<v8::Context> context = fGlobal->getContext();
  72
  73     // Enter the context so all the remaining operations take place there.
  74     v8::Context::Scope contextScope(context);
  75
  76     // Wrap the C++ this pointer in a JavaScript wrapper.
  77     v8::Handle<v8::Object> contextObj = this->wrap();
  78
  79     // Set up an exception handler before calling the Process function.
  80     v8::TryCatch tryCatch;
  81
  82     // Invoke the process function, giving the global object as 'this'
  83     // and one argument, this JsContext.
  84     const int argc = 1;
  85     v8::Handle<v8::Value> argv[argc] = { contextObj };
  86     v8::Local<v8::Function> onDraw =
  87             v8::Local<v8::Function>::New(fGlobal->getIsolate(), fOnDraw);
  88     v8::Handle<v8::Value> result = onDraw->Call(context->Global(), argc, argv);
  89
  90     // Handle any exceptions or output.
  91     if (result.IsEmpty()) {
  92         SkASSERT(tryCatch.HasCaught());
  93         // Print errors that happened during execution.
  94         fGlobal->reportException(&tryCatch);
  95     } else {
  96         SkASSERT(!tryCatch.HasCaught());
  97         if (!result->IsUndefined()) {
  98             // If all went well and the result wasn't undefined then print
  99             // the returned value.
 100             v8::String::Utf8Value str(result);
 101             const char* cstr = to_cstring(str);
 102             printf("%s\n", cstr);
 103         }
 104     }
 105 }
 106
 107 // Fetch the onDraw function from the global context.
 108 bool JsContext::initialize() {
 109
 110     // Create a stack-allocated handle scope.
 111     v8::HandleScope handleScope(fGlobal->getIsolate());
 112
 113     // Create a local context from our global context.
 114     v8::Local<v8::Context> context = fGlobal->getContext();
 115
 116     // Enter the scope so all operations take place in the scope.
 117     v8::Context::Scope contextScope(context);
 118
 119     v8::TryCatch try_catch;
 120
 121     v8::Handle<v8::String> fn_name = v8::String::NewFromUtf8(
 122         fGlobal->getIsolate(), "onDraw");
 123     v8::Handle<v8::Value> fn_val = context->Global()->Get(fn_name);
 124
 125     if (!fn_val->IsFunction()) {
 126         printf("Not a function.\n");
 127         return false;
 128     }
 129
 130     // It is a function; cast it to a Function.
 131     v8::Handle<v8::Function> fn_fun = v8::Handle<v8::Function>::Cast(fn_val);
 132
 133     // Store the function in a Persistent handle, since we also want that to
 134     // remain after this call returns.
 135     fOnDraw.Reset(fGlobal->getIsolate(), fn_fun);
 136
 137     return true;
 138 }