Various OpenGLUI changes:

runtime/embedders/openglui/common/canvas_context.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 "embedders/openglui/common/canvas_context.h"
 
 #include <ctype.h>
 #include <string.h>
 #include "core/SkStream.h"
+#include "embedders/openglui/common/image_cache.h"
 #include "embedders/openglui/common/support.h"
 
 // TODO(gram): this should be dynamic.
-#define MAX_CONTEXTS 16
+#define MAX_CONTEXTS 256
 CanvasContext* contexts[MAX_CONTEXTS] = { 0 };
 
 CanvasContext* Context2D(int handle) {
   if (handle < 0 || handle >= MAX_CONTEXTS) {
     LOGE("Request for out-of-range handle %d", handle);
     return NULL;
   }
   if (contexts[handle] == NULL) {
     LOGE("Warning: request for context with handle %d returns NULL", handle);
   }
   return contexts[handle];
 }
 
 void FreeContexts() {
   extern CanvasContext* display_context;
   for (int i = 0; i < MAX_CONTEXTS; i++) {
     delete contexts[i];
     contexts[i] = NULL;
   }
   display_context = NULL;
 }
 
 
 CanvasContext::CanvasContext(int handle, int16_t widthp, int16_t heightp)
   : canvas_(NULL),
     width_(widthp),
     height_(heightp),
     imageSmoothingEnabled_(true),
     state_(NULL) {
+  if (handle >= MAX_CONTEXTS) {
+    LOGE("Max contexts exceeded");
+    exit(-1);
+  }
   if (handle == 0) {
     canvas_ = graphics->CreateDisplayCanvas();
   } else {
     canvas_ = graphics->CreateBitmapCanvas(widthp, heightp);
   }
   state_ = new CanvasState(canvas_);
   contexts[handle] = this;
   LOGI("Created context with handle %d", handle);
 }
 
 CanvasContext::~CanvasContext() {
   delete state_;
   delete canvas_;
 }
 
+void CanvasContext::Save() {
+  state_ = state_->Save();
+}
+
+void CanvasContext::Restore() {
+  CanvasState* popped_state = state_;
+  state_ = state_->Restore();
+  if (state_ == NULL) {
+    LOGE("Popping last state!");
+    state_ = popped_state;
+  }
+  if (state_ != popped_state) {
+    // Only delete if the pop was successful.
+    delete popped_state;
+  }
+}
+
 void CanvasContext::DrawImage(const char* src_url,
                               int sx, int sy,
                               bool has_src_dimensions, int sw, int sh,
                               int dx, int dy,
                               bool has_dst_dimensions, int dw, int dh) {
-  SkBitmap bm;
-  if (strncmp(src_url, "context2d://", 12) == 0) {
-    int handle = atoi(src_url + 12);
-    CanvasContext* otherContext = Context2D(handle);
-    SkDevice* device = otherContext->canvas_->getDevice();
-    bm = device->accessBitmap(false);
-  } else {
-    const char* filepath;
-    if (strncmp(src_url, "file://", 7) == 0) {
-      filepath = src_url + 7;
-    } else {
-      // TODO(gram): We need a way to remap URLs to local file names.
-      // For now I am just using the characters after the last '/'.
-      // Note also that if we want to support URLs and network fetches,
-      // then we introduce more complexity; this can't just be an URL.
-      int pos = strlen(src_url);
-      while (--pos >= 0 && src_url[pos] != '/');
-      filepath = src_url + pos + 1;
-    }
-    char* path;
-    if (filepath[0] == '/') {
-      path = const_cast<char*>(filepath);
-    } else {
-      size_t len1 = strlen(graphics->resource_path());
-      size_t len2 = strlen(filepath);
-      path = new char[len1 + 1 + len2 + 1];
-      strncpy(path, graphics->resource_path(), len1+1);
-      strncat(path, "/", 1);
-      strncat(path, filepath, len2);
-    }
-    SkFILEStream stream(path);
-    if (stream.isValid()) {
-      // We could use DecodeFile and pass the path, but by creating the
-      // SkStream here we can produce better error log messages.
-      if (!SkImageDecoder::DecodeStream(&stream, &bm)) {
-        LOGI("Image decode of %s failed", path);
-        return;
-      } else {
-        LOGI("Decode image %s: width=%d,height=%d",
-            path, bm.width(), bm.height());
-      }
-    } else {
-      LOGI("Path %s is invalid", path);
-    }
-    if (path != filepath) {
-      delete[] path;
-    }
-  }
+  const SkBitmap* bm = ImageCache::GetImage(src_url);
+  if (bm == NULL) return;
   if (!has_src_dimensions) {
-    sw = bm.width();
-    sh = bm.height();
+    sw = bm->width();
+    sh = bm->height();
   }
   if (!has_dst_dimensions) {
-    dw = bm.width();
-    dh = bm.height();
+    dw = bm->width();
+    dh = bm->height();
   }
-  state_->DrawImage(bm, sx, sy, sw, sh, dx, dy, dw, dh);
+  state_->DrawImage(*bm, sx, sy, sw, sh, dx, dy, dw, dh);
   isDirty_ = true;
 }
 
 void CanvasContext::ClearRect(float left, float top,
                               float width, float height) {
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(0xFFFFFFFF);
   canvas_->drawRectCoords(left, top, left + width, top + height, paint);
   isDirty_ = true;
 }