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.
to_cstring(const v8::String::Utf8Value & value)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.
wrap()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
onDraw(SkCanvas * canvas)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.
initialize()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 }
139