Oilpan: move 2D Canvas and WebGL objects to the heap.

Source/core/html/canvas/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 334 matching lines @@
 }
 
 void CanvasRenderingContext2D::State::fontsNeedUpdate(CSSFontSelector* fontSelector)
 {
     ASSERT_ARG(fontSelector, fontSelector == m_font.fontSelector());
     ASSERT(m_realizedFont);
 
     m_font.update(fontSelector);
 }
 
+void CanvasRenderingContext2D::State::trace(Visitor* visitor)
+{
+    visitor->trace(m_strokeStyle);
+    visitor->trace(m_fillStyle);
+    CSSFontSelectorClient::trace(visitor);
+}
+
 void CanvasRenderingContext2D::realizeSaves()
 {
     validateStateStack();
     if (state().m_unrealizedSaveCount) {
         ASSERT(m_stateStack.size() >= 1);
         // Reduce the current state's unrealized count by one now,
         // to reflect the fact we are saving one state.
         m_stateStack.last()->m_unrealizedSaveCount--;
         m_stateStack.append(adoptPtrWillBeNoop(new State(state())));
         // Set the new state's unrealized count to 0, because it has no outstanding saves.
@@ skipping 26 matching lines @@
     if (c)
         c->restore();
     validateStateStack();
 }
 
 CanvasStyle* CanvasRenderingContext2D::strokeStyle() const
 {
     return state().m_strokeStyle.get();
 }
 
-void CanvasRenderingContext2D::setStrokeStyle(PassRefPtr<CanvasStyle> prpStyle)
+void CanvasRenderingContext2D::setStrokeStyle(PassRefPtrWillBeRawPtr<CanvasStyle> prpStyle)
 {
-    RefPtr<CanvasStyle> style = prpStyle;
+    RefPtrWillBeRawPtr<CanvasStyle> style = prpStyle;
 
     if (!style)
         return;
 
     if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentColor(*style))
         return;
 
     if (style->isCurrentColor()) {
         if (style->hasOverrideAlpha())
             style = CanvasStyle::createFromRGBA(colorWithOverrideAlpha(currentColor(canvas()), style->overrideAlpha()));
@@ skipping 10 matching lines @@
         return;
     state().m_strokeStyle->applyStrokeColor(c);
     modifiableState().m_unparsedStrokeColor = String();
 }
 
 CanvasStyle* CanvasRenderingContext2D::fillStyle() const
 {
     return state().m_fillStyle.get();
 }
 
-void CanvasRenderingContext2D::setFillStyle(PassRefPtr<CanvasStyle> prpStyle)
+void CanvasRenderingContext2D::setFillStyle(PassRefPtrWillBeRawPtr<CanvasStyle> prpStyle)
 {
-    RefPtr<CanvasStyle> style = prpStyle;
+    RefPtrWillBeRawPtr<CanvasStyle> style = prpStyle;
 
     if (!style)
         return;
 
     if (state().m_fillStyle && state().m_fillStyle->isEquivalentColor(*style))
         return;
 
     if (style->isCurrentColor()) {
         if (style->hasOverrideAlpha())
             style = CanvasStyle::createFromRGBA(colorWithOverrideAlpha(currentColor(canvas()), style->overrideAlpha()));
@@ skipping 1203 matching lines @@
     GraphicsContext* c = drawingContext();
     ASSERT(c);
     c->beginLayer(1, state().m_globalComposite);
     CompositeOperator previousOperator = c->compositeOperation();
     c->setCompositeOperation(CompositeSourceOver);
     strokePrimitive(area, c);
     c->setCompositeOperation(previousOperator);
     c->endLayer();
 }
 
-PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
+PassRefPtrWillBeRawPtr<CanvasGradient> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
 {
-    RefPtr<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
+    RefPtrWillBeRawPtr<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
     return gradient.release();
 }
 
-PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionState& exceptionState)
+PassRefPtrWillBeRawPtr<CanvasGradient> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionState& exceptionState)
 {
     if (r0 < 0 || r1 < 0) {
         exceptionState.throwDOMException(IndexSizeError, String::format("The %s provided is less than 0.", r0 < 0 ? "r0" : "r1"));
         return nullptr;
     }
 
-    RefPtr<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);
+    RefPtrWillBeRawPtr<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);
     return gradient.release();
 }
 
-PassRefPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(CanvasImageSource* imageSource,
+PassRefPtrWillBeRawPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(CanvasImageSource* imageSource,
     const String& repetitionType, ExceptionState& exceptionState)
 {
     bool repeatX, repeatY;
     CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     SourceImageStatus status;
     RefPtr<Image> imageForRendering = imageSource->getSourceImageForCanvas(CopySourceImageIfVolatile, &status);
 
@@ skipping 369 matching lines @@
     for (unsigned i = 0; i < textLength; i++) {
         if (isSpaceCharacter(text[i]))
             charVector[i] = ' ';
         else
             charVector[i] = text[i];
     }
 
     return String(charVector);
 }
 
-PassRefPtr<TextMetrics> CanvasRenderingContext2D::measureText(const String& text)
+PassRefPtrWillBeRawPtr<TextMetrics> CanvasRenderingContext2D::measureText(const String& text)
 {
-    RefPtr<TextMetrics> metrics = TextMetrics::create();
+    RefPtrWillBeRawPtr<TextMetrics> metrics = TextMetrics::create();
 
     // The style resolution required for rendering text is not available in frame-less documents.
     if (!canvas()->document().frame())
         return metrics.release();
 
     FontCachePurgePreventer fontCachePurgePreventer;
     canvas()->document().updateRenderTreeIfNeeded();
     const Font& font = accessFont();
     String normalizedText = normalizeSpaces(text);
     const TextRun textRun(normalizedText);
@@ skipping 201 matching lines @@
     if (enabled == state().m_imageSmoothingEnabled)
         return;
 
     realizeSaves();
     modifiableState().m_imageSmoothingEnabled = enabled;
     GraphicsContext* c = drawingContext();
     if (c)
         c->setImageInterpolationQuality(enabled ? CanvasDefaultInterpolationQuality : InterpolationNone);
 }
 
-PassRefPtr<Canvas2DContextAttributes> CanvasRenderingContext2D::getContextAttributes() const
+PassRefPtrWillBeRawPtr<Canvas2DContextAttributes> CanvasRenderingContext2D::getContextAttributes() const
 {
-    RefPtr<Canvas2DContextAttributes> attributes = Canvas2DContextAttributes::create();
+    RefPtrWillBeRawPtr<Canvas2DContextAttributes> attributes = Canvas2DContextAttributes::create();
     attributes->setAlpha(m_hasAlpha);
     return attributes.release();
 }
 
 void CanvasRenderingContext2D::drawFocusIfNeeded(Element* element)
 {
     drawFocusIfNeededInternal(m_path, element);
 }
 
 void CanvasRenderingContext2D::drawFocusIfNeeded(Path2D* path2d, Element* element)
@@ skipping 64 matching lines @@
 {
     HitRegionOptions passOptions;
 
     options.getWithUndefinedOrNullCheck("id", passOptions.id);
     options.getWithUndefinedOrNullCheck("control", passOptions.control);
     if (passOptions.id.isEmpty() && !passOptions.control) {
         exceptionState.throwDOMException(NotSupportedError, "Both id and control are null.");
         return;
     }
 
-    RefPtr<Path2D> path2d;
+    RefPtrWillBeMember<Path2D> path2d;

[Mads Ager (chromium), 2014/07/11 09:15:01]

RefPtrWillBeRawPtr<Path2D> path2d = nullptr;

     options.getWithUndefinedOrNullCheck("path", path2d);
     Path hitRegionPath = path2d ? path2d->path() : m_path;
 
     FloatRect clipBounds;
     GraphicsContext* context = drawingContext();
 
     if (hitRegionPath.isEmpty() || !context || !state().m_invertibleCTM
         || !context->getTransformedClipBounds(&clipBounds)) {
         exceptionState.throwDOMException(NotSupportedError, "The specified path has no pixels.");
         return;
@@ skipping 57 matching lines @@
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
 } // namespace WebCore