Merge the Sky Engine changes from the SkyDart branch

sky/engine/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 15 matching lines @@
  */
 
 #include "sky/engine/config.h"
 #include "sky/engine/core/html/HTMLCanvasElement.h"
 
 #include <math.h>
 
 #include "base/bind.h"
 #include "gen/sky/core/HTMLNames.h"
 #include "gen/sky/platform/RuntimeEnabledFeatures.h"
-#include "sky/engine/bindings/core/v8/ExceptionMessages.h"
-#include "sky/engine/bindings/core/v8/ExceptionState.h"
-#include "sky/engine/bindings/core/v8/ScriptController.h"
+#include "sky/engine/bindings2/exception_messages.h"
+#include "sky/engine/bindings2/exception_state.h"
 #include "sky/engine/core/dom/Document.h"
 #include "sky/engine/core/dom/ExceptionCode.h"
 #include "sky/engine/core/dom/Microtask.h"
 #include "sky/engine/core/frame/LocalFrame.h"
 #include "sky/engine/core/frame/Settings.h"
 #include "sky/engine/core/html/ImageData.h"
 #include "sky/engine/core/html/canvas/Canvas2DContextAttributes.h"
 #include "sky/engine/core/html/canvas/CanvasRenderingContext2D.h"
 #include "sky/engine/core/html/canvas/WebGLContextAttributes.h"
 #include "sky/engine/core/html/canvas/WebGLContextEvent.h"
 #include "sky/engine/core/html/canvas/WebGLRenderingContext.h"
 #include "sky/engine/core/rendering/RenderHTMLCanvas.h"
 #include "sky/engine/core/rendering/RenderLayer.h"
 #include "sky/engine/platform/MIMETypeRegistry.h"
 #include "sky/engine/platform/graphics/Canvas2DImageBufferSurface.h"
 #include "sky/engine/platform/graphics/GraphicsContextStateSaver.h"
 #include "sky/engine/platform/graphics/ImageBuffer.h"
 #include "sky/engine/platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "sky/engine/platform/graphics/gpu/WebGLImageBufferSurface.h"
 #include "sky/engine/platform/transforms/AffineTransform.h"
 #include "sky/engine/public/platform/Platform.h"
-#include "v8/include/v8.h"
 
 namespace blink {
 
 // These values come from the WhatWG spec.
 static const int DefaultWidth = 300;
 static const int DefaultHeight = 150;
 
 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
 // in exchange for a smaller maximum canvas size.
@@ skipping 13 matching lines @@
     , m_didFailToCreateImageBuffer(false)
     , m_didClearImageBuffer(false)
 {
 }
 
 DEFINE_NODE_FACTORY(HTMLCanvasElement)
 
 HTMLCanvasElement::~HTMLCanvasElement()
 {
     resetDirtyRect();
-    v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
 #if !ENABLE(OILPAN)
     HashSet<RawPtr<CanvasObserver> >::iterator end = m_observers.end();
     for (HashSet<RawPtr<CanvasObserver> >::iterator it = m_observers.begin(); it != end; ++it)
         (*it)->canvasDestroyed(this);
     // Ensure these go away before the ImageBuffer.
     m_contextStateSaver.clear();
     m_context.clear();
 #endif
 }
 
@@ skipping 22 matching lines @@
 void HTMLCanvasElement::setHeight(int value)
 {
     setIntegralAttribute(HTMLNames::heightAttr, value);
 }
 
 void HTMLCanvasElement::setWidth(int value)
 {
     setIntegralAttribute(HTMLNames::widthAttr, value);
 }
 
-CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
+CanvasRenderingContext2D* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
 {
     // A Canvas can either be "2D" or "webgl" but never both. If you request a 2D canvas and the existing
     // context is already 2D, just return that. If the existing context is WebGL, then destroy it
     // before creating a new 2D context. Vice versa when requesting a WebGL canvas. Requesting a
     // context with any other type string will destroy any existing context.
     enum ContextType {
         // Do not change assigned numbers of existing items: add new features to the end of the list.
         Context2d = 0,
         ContextExperimentalWebgl = 2,
         ContextWebgl = 3,
         ContextTypeCount,
     };
 
     // FIXME - The code depends on the context not going away once created, to prevent JS from
     // seeing a dangling pointer. So for now we will disallow the context from being changed
     // once it is created.
     if (type == "2d") {
         if (m_context && !m_context->is2d())
             return 0;
         if (!m_context) {
             blink::Platform::current()->histogramEnumeration("Canvas.ContextType", Context2d, ContextTypeCount);
             m_context = CanvasRenderingContext2D::create(this, static_cast<Canvas2DContextAttributes*>(attrs));
         }
-        return m_context.get();
+        return static_cast<CanvasRenderingContext2D*>(m_context.get());
     }
 
     // Accept the the provisional "experimental-webgl" or official "webgl" context ID.
-    if (type == "webgl" || type == "experimental-webgl") {
-        ContextType contextType = (type == "webgl") ? ContextWebgl : ContextExperimentalWebgl;
-        if (!m_context) {
-            blink::Platform::current()->histogramEnumeration("Canvas.ContextType", contextType, ContextTypeCount);
-            m_context = WebGLRenderingContext::create(this, static_cast<WebGLContextAttributes*>(attrs));
-            updateExternallyAllocatedMemory();
-        } else if (!m_context->is3d()) {
-            dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Canvas has an existing, non-WebGL context"));
-            return 0;
-        }
-        return m_context.get();
-    }
+    // if (type == "webgl" || type == "experimental-webgl") {
+    //     ContextType contextType = (type == "webgl") ? ContextWebgl : ContextExperimentalWebgl;
+    //     if (!m_context) {
+    //         blink::Platform::current()->histogramEnumeration("Canvas.ContextType", contextType, ContextTypeCount);
+    //         m_context = WebGLRenderingContext::create(this, static_cast<WebGLContextAttributes*>(attrs));
+    //         updateExternallyAllocatedMemory();
+    //     } else if (!m_context->is3d()) {
+    //         dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Canvas has an existing, non-WebGL context"));
+    //         return 0;
+    //     }
+    //     return m_context.get();
+    // }
 
-    return 0;
+    return nullptr;
 }
 
 void HTMLCanvasElement::didDraw(const FloatRect& rect)
 {
     if (rect.isEmpty())
         return;
     clearCopiedImage();
     if (m_dirtyRect.isEmpty()) {
         m_finalizeFrameTask.Reset(base::Bind(
             &HTMLCanvasElement::finalizeFrameMicrotask, base::Unretained(this)));
@@ skipping 338 matching lines @@
         bufferCount++;
 
     Checked<intptr_t, RecordOverflow> checkedExternallyAllocatedMemory = 4 * bufferCount;
     checkedExternallyAllocatedMemory *= width();
     checkedExternallyAllocatedMemory *= height();
     intptr_t externallyAllocatedMemory;
     if (checkedExternallyAllocatedMemory.safeGet(externallyAllocatedMemory) == CheckedState::DidOverflow)
         externallyAllocatedMemory = std::numeric_limits<intptr_t>::max();
 
     // Subtracting two intptr_t that are known to be positive will never underflow.
-    v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(externallyAllocatedMemory - m_externallyAllocatedMemory);
     m_externallyAllocatedMemory = externallyAllocatedMemory;
 }
 
 GraphicsContext* HTMLCanvasElement::drawingContext() const
 {
     return buffer() ? m_imageBuffer->context() : 0;
 }
 
 GraphicsContext* HTMLCanvasElement::existingDrawingContext() const
 {
@@ skipping 102 matching lines @@
     }
     return m_imageBuffer->copyImage(DontCopyBackingStore, Unscaled);
 }
 
 FloatSize HTMLCanvasElement::sourceSize() const
 {
     return FloatSize(width(), height());
 }
 
 }