Canvas API. There are still a number of things to do:

runtime/embedders/openglui/common/vm_glue.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
@@ skipping 25 matching lines @@
     extension_script = "gl.dart";
   }
   size_t len = strlen(script_path) + strlen(main_script) + 2;
   main_script_ = new char[len];
   snprintf(main_script_, len, "%s/%s", script_path, main_script);
   len = strlen(script_path) + strlen(extension_script) + 2;
   extension_script_ = new char[len];
   snprintf(extension_script_, len, "%s/%s", script_path, extension_script);
 }
 
-int VMGlue::ErrorExit(const char* format, ...) {
-  va_list arguments;
-  va_start(arguments, format);
-  LOGE(format, arguments);
-  va_end(arguments);
-  Dart_ExitScope();
-  Dart_ShutdownIsolate();
-  LOGE("Shutdown isolate");
-  return -1;
-}
-
 Dart_Handle VMGlue::CheckError(Dart_Handle handle) {
   if (Dart_IsError(handle)) {
     LOGE("Unexpected Error Handle: %s", Dart_GetError(handle));
     Dart_PropagateError(handle);
   }
   return handle;
 }
 
 #define CHECK_RESULT(result)                   \
   if (Dart_IsError(result)) {                  \
@@ skipping 55 matching lines @@
   const char* main,
   void* data, char** error) {
   return CreateIsolateAndSetupHelper(script_uri,
                                      main,
                                      data,
                                      error);
 }
 
 const char* VM_FLAGS[] = {
   "--enable_type_checks",  // TODO(gram): This should be an option!
-  "--trace_isolates",
-  "--trace_natives",
+  // "--trace_isolates",
+  // "--trace_natives",
+  // "--trace_compiler",
 };
 
 int VMGlue::InitializeVM() {
   // We need the next call to get Dart_Initialize not to bail early.
   LOGI("Setting VM Options");
   Dart_SetVMFlags(sizeof(VM_FLAGS) / sizeof(VM_FLAGS[0]), VM_FLAGS);
 
   // Initialize the Dart VM, providing the callbacks to use for
   // creating and shutting down isolates.
   LOGI("Initializing Dart");
@@ skipping 60 matching lines @@
   CheckError(Dart_LoadScript(url, source));
 
   Dart_ExitScope();
   Dart_ExitIsolate();
   return 0;
 }
 
 int VMGlue::CallSetup() {
   if (!initialized_script_) {
     initialized_script_ = true;
-    LOGI("Invoking setup(0,0,%d,%d)", surface_->width(), surface_->height());
+    LOGI("Invoking setup(NULL, %d,%d)", surface_->width(), surface_->height());
     Dart_EnterIsolate(isolate_);
     Dart_EnterScope();
-    Dart_Handle args[2];
-    args[0] = CheckError(Dart_NewInteger(surface_->width()));
-    args[1] = CheckError(Dart_NewInteger(surface_->height()));
-    int rtn = Invoke("setup", 2, args);
+    Dart_Handle args[3];
+    args[0] = CheckError(Dart_Null());
+    args[1] = CheckError(Dart_NewInteger(surface_->width()));
+    args[2] = CheckError(Dart_NewInteger(surface_->height()));
+    int rtn = Invoke("setup", 3, args);
 
     if (rtn == 0) {
       // Plug in the print handler. It would be nice if we could do this
       // before calling setup, but the call to GetField blows up if we
       // haven't run anything yet.
       Dart_Handle library = CheckError(Dart_LookupLibrary(
           Dart_NewStringFromCString("gl.dart")));
       Dart_Handle print = CheckError(
           Dart_GetField(library, Dart_NewStringFromCString("_printClosure")));
       Dart_Handle corelib = CheckError(Dart_LookupLibrary(
           Dart_NewStringFromCString("dart:core")));
       CheckError(Dart_SetField(corelib,
         Dart_NewStringFromCString("_printClosure"), print));
     }
-
     Dart_ExitScope();
     Dart_ExitIsolate();
     LOGI("Done setup");
     return rtn;
   }
   return 0;
 }
 
 int VMGlue::CallUpdate() {
   if (initialized_script_) {
@@ skipping 52 matching lines @@
 int VMGlue::Invoke(const char* function,
                    int argc,
                    Dart_Handle* args,
                    bool failIfNotDefined) {
   LOGI("in invoke(%s)", function);
 
   // Lookup the library of the root script.
   LOGI("looking up the root library");
   Dart_Handle library = Dart_RootLibrary();
   if (Dart_IsNull(library)) {
-     return ErrorExit("Unable to find root library\n");
+     LOGE("Unable to find root library\n");
+     return -1;
   }
 
   Dart_Handle nameHandle = Dart_NewStringFromCString(function);
 
   LOGI("invoking %s", function);
   Dart_Handle result = Dart_Invoke(library, nameHandle, argc, args);
 
   if (Dart_IsError(result)) {
+    const char* error = Dart_GetError(result);
+    LOGE("Invoke %s failed: %s", function, error);
     if (failIfNotDefined) {
-      return ErrorExit("Invoke %s: %s\n", function, Dart_GetError(result));
-    } else {
-      LOGE("Invoke %s: %s", function, Dart_GetError(result));
+      return -1;
     }
   }
 
   // TODO(vsm): I don't think we need this.
   // Keep handling messages until the last active receive port is closed.
   LOGI("Entering Dart message loop");
   result = Dart_RunLoop();
   if (Dart_IsError(result)) {
-    return ErrorExit("Dart_RunLoop: %s\n", Dart_GetError(result));
+    LOGE("Dart_RunLoop: %s\n", Dart_GetError(result));
+    return -1;
   }
 
   LOGI("out invoke");
   return 0;
 }
 
 void VMGlue::FinishMainIsolate() {
   LOGI("Finish main isolate");
   Dart_EnterIsolate(isolate_);
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   isolate_ = NULL;
   initialized_script_ = false;
 }