1 files changed, 218 insertions, 411 deletions

diff --git a/Source/WebCore/platform/graphics/android/context/GraphicsOperation.h b/Source/WebCore/platform/graphics/android/context/GraphicsOperation.h
index 927ff0a..c9c382a 100644
--- a/Source/WebCore/platform/graphics/android/context/GraphicsOperation.h
+++ b/Source/WebCore/platform/graphics/android/context/GraphicsOperation.h
@@ -26,8 +26,6 @@
 #ifndef GraphicsOperation_h
 #define GraphicsOperation_h
 
-#if USE(ACCELERATED_COMPOSITING)
-
 #include "Color.h"
 #include "FloatRect.h"
 #include "GlyphBuffer.h"
@@ -44,37 +42,54 @@
 
 #define TYPE_CASE(type) case type: return #type;
 
+#define DEBUG_GRAPHICS_OPERATIONS false
+
+#if DEBUG_GRAPHICS_OPERATIONS
+#define TYPE(x) virtual OperationType type() { return x; }
+#else
+#define TYPE(x)
+#endif
+
 namespace WebCore {
 
+class CanvasState;
+class LinearAllocator;
+
 namespace GraphicsOperation {
 
-class Operation : public SkRefCnt {
+class Operation {
 public:
+    Operation()
+        : m_state(0)
+        , m_canvasState(0)
+    {}
+
+    void* operator new(size_t size, LinearAllocator* allocator);
+
+    // Purposely not implemented - use a LinearAllocator please
+    void* operator new(size_t size);
+    void operator delete(void* ptr);
+
+    // This m_state is applied by ourselves
+    PlatformGraphicsContext::State* m_state;
+    // This is the canvas state that this operation needs
+    // Only used for drawing operations, state operations will be undefined
+    CanvasState* m_canvasState;
+
+    bool apply(PlatformGraphicsContext* context) {
+        if (m_state)
+            context->setRawState(m_state);
+        return applyImpl(context);
+    }
+    virtual bool applyImpl(PlatformGraphicsContext* context) = 0;
+    virtual ~Operation() {}
+
+    virtual const IntRect*  opaqueRect() { return 0; }
+    virtual bool isOpaque() { return false; }
+    virtual void setOpaqueRect(const IntRect& bounds) {}
+
+#if DEBUG_GRAPHICS_OPERATIONS
     typedef enum { UndefinedOperation
-                  // State management
-                  , BeginTransparencyLayerOperation
-                  , EndTransparencyLayerOperation
-                  , SaveOperation
-                  , RestoreOperation
-                  // State setters
-                  , SetAlphaOperation
-                  , SetCompositeOpOperation
-                  , SetFillColorOperation
-                  , SetFillShaderOperation
-                  , SetLineCapOperation
-                  , SetLineDashOperation
-                  , SetLineJoinOperation
-                  , SetMiterLimitOperation
-                  , SetShadowOperation
-                  , SetShouldAntialiasOperation
-                  , SetStrokeColorOperation
-                  , SetStrokeShaderOperation
-                  , SetStrokeStyleOperation
-                  , SetStrokeThicknessOperation
-                  // Paint setup
-                  , SetupPaintFillOperation
-                  , SetupPaintShadowOperation
-                  , SetupPaintStrokeOperation
                   // Matrix operations
                   , ConcatCTMOperation
                   , ScaleOperation
@@ -89,7 +104,9 @@ public:
                   // Drawing
                   , DrawBitmapPatternOperation
                   , DrawBitmapRectOperation
+                  , DrawConvexPolygonQuadOperation
                   , DrawEllipseOperation
+                  , DrawFocusRingOperation
                   , DrawLineOperation
                   , DrawLineForTextOperation
                   , DrawLineForTextCheckingOperation
@@ -100,43 +117,15 @@ public:
                   , StrokeArcOperation
                   , StrokePathOperation
                   , StrokeRectOperation
+                  , DrawMediaButtonOperation
                   // Text
-                  , DrawComplexTextOperation
-                  , DrawTextOperation
+                  , DrawPosTextOperation
     } OperationType;
 
-    virtual void apply(PlatformGraphicsContext* context) = 0;
-    virtual ~Operation() {}
-    virtual OperationType type() { return UndefinedOperation; }
-    virtual String parameters() { return ""; }
-    String name()
+    const char* name()
     {
         switch (type()) {
             TYPE_CASE(UndefinedOperation)
-            // State management
-            TYPE_CASE(BeginTransparencyLayerOperation)
-            TYPE_CASE(EndTransparencyLayerOperation)
-            TYPE_CASE(SaveOperation)
-            TYPE_CASE(RestoreOperation)
-            // State setters
-            TYPE_CASE(SetAlphaOperation)
-            TYPE_CASE(SetCompositeOpOperation)
-            TYPE_CASE(SetFillColorOperation)
-            TYPE_CASE(SetFillShaderOperation)
-            TYPE_CASE(SetLineCapOperation)
-            TYPE_CASE(SetLineDashOperation)
-            TYPE_CASE(SetLineJoinOperation)
-            TYPE_CASE(SetMiterLimitOperation)
-            TYPE_CASE(SetShadowOperation)
-            TYPE_CASE(SetShouldAntialiasOperation)
-            TYPE_CASE(SetStrokeColorOperation)
-            TYPE_CASE(SetStrokeShaderOperation)
-            TYPE_CASE(SetStrokeStyleOperation)
-            TYPE_CASE(SetStrokeThicknessOperation)
-            // Paint setup
-            TYPE_CASE(SetupPaintFillOperation)
-            TYPE_CASE(SetupPaintShadowOperation)
-            TYPE_CASE(SetupPaintStrokeOperation)
             // Matrix operations
             TYPE_CASE(ConcatCTMOperation)
             TYPE_CASE(ScaleOperation)
@@ -151,7 +140,9 @@ public:
             // Drawing
             TYPE_CASE(DrawBitmapPatternOperation)
             TYPE_CASE(DrawBitmapRectOperation)
+            TYPE_CASE(DrawConvexPolygonQuadOperation)
             TYPE_CASE(DrawEllipseOperation)
+            TYPE_CASE(DrawFocusRingOperation)
             TYPE_CASE(DrawLineOperation)
             TYPE_CASE(DrawLineForTextOperation)
             TYPE_CASE(DrawLineForTextCheckingOperation)
@@ -162,258 +153,23 @@ public:
             TYPE_CASE(StrokeArcOperation)
             TYPE_CASE(StrokePathOperation)
             TYPE_CASE(StrokeRectOperation)
+            TYPE_CASE(DrawMediaButtonOperation)
             // Text
-            TYPE_CASE(DrawComplexTextOperation)
-            TYPE_CASE(DrawTextOperation)
+            TYPE_CASE(DrawPosTextOperation)
         }
         return "Undefined";
     }
+#endif
+    TYPE(UndefinedOperation)
 };
 
-//**************************************
-// State management
-//**************************************
-
-class BeginTransparencyLayer : public Operation {
-public:
-    BeginTransparencyLayer(const float opacity) : m_opacity(opacity) {}
-    virtual void apply(PlatformGraphicsContext* context) { context->beginTransparencyLayer(m_opacity); }
-    virtual OperationType type() { return BeginTransparencyLayerOperation; }
-private:
-    float m_opacity;
-};
-class EndTransparencyLayer : public Operation {
-public:
-    EndTransparencyLayer() {}
-    virtual void apply(PlatformGraphicsContext* context) { context->endTransparencyLayer(); }
-    virtual OperationType type() { return EndTransparencyLayerOperation; }
-};
-class Save : public Operation {
-public:
-    virtual void apply(PlatformGraphicsContext* context) { context->save(); }
-    virtual OperationType type() { return SaveOperation; }
-};
-class Restore : public Operation {
-public:
-    virtual void apply(PlatformGraphicsContext* context) { context->restore(); }
-    virtual OperationType type() { return RestoreOperation; }
-};
-
-//**************************************
-// State setters
-//**************************************
-
-class SetAlpha : public Operation {
-public:
-    SetAlpha(const float alpha) : m_alpha(alpha) {}
-    virtual void apply(PlatformGraphicsContext* context) { context->setAlpha(m_alpha); }
-    virtual OperationType type() { return SetAlphaOperation; }
-private:
-    float m_alpha;
-};
-
-class SetCompositeOperation : public Operation {
-public:
-    SetCompositeOperation(CompositeOperator op) : m_operator(op) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setCompositeOperation(m_operator);
-    }
-    virtual OperationType type() { return SetCompositeOpOperation; }
-private:
-    CompositeOperator m_operator;
-};
-
-class SetFillColor : public Operation {
-public:
-    SetFillColor(Color color) : m_color(color) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setFillColor(m_color);
-    }
-    virtual OperationType type() { return SetFillColorOperation; }
-    virtual String parameters() {
-        return String::format("r: %d g: %d b: %d a: %d",
-                              m_color.red(),
-                              m_color.green(),
-                              m_color.blue(),
-                              m_color.alpha());
-    }
-private:
-    Color m_color;
-};
-
-class SetFillShader : public Operation {
-public:
-    SetFillShader(SkShader* shader) : m_shader(shader) {
-        SkSafeRef(m_shader);
-    }
-    ~SetFillShader() { SkSafeUnref(m_shader); }
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setFillShader(m_shader);
-    }
-    virtual OperationType type() { return SetFillShaderOperation; }
-private:
-    SkShader* m_shader;
-};
-
-class SetLineCap : public Operation {
-public:
-    SetLineCap(LineCap cap) : m_cap(cap) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setLineCap(m_cap);
-    }
-    virtual OperationType type() { return SetLineCapOperation; }
-private:
-    LineCap m_cap;
-};
-
-class SetLineDash : public Operation {
-public:
-    SetLineDash(const DashArray& dashes, float dashOffset)
-        : m_dashes(dashes), m_dashOffset(dashOffset) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setLineDash(m_dashes, m_dashOffset);
-    }
-    virtual OperationType type() { return SetLineDashOperation; }
-private:
-    DashArray m_dashes;
-    float m_dashOffset;
-};
-
-class SetLineJoin : public Operation {
-public:
-    SetLineJoin(LineJoin join) : m_join(join) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setLineJoin(m_join);
-    }
-    virtual OperationType type() { return SetLineJoinOperation; }
-private:
-    LineJoin m_join;
-};
-
-class SetMiterLimit : public Operation {
-public:
-    SetMiterLimit(float limit) : m_limit(limit) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setMiterLimit(m_limit);
-    }
-    virtual OperationType type() { return SetMiterLimitOperation; }
-private:
-    float m_limit;
-};
-
-class SetShadow : public Operation {
-public:
-    SetShadow(int radius, int dx, int dy, SkColor c)
-        : m_radius(radius), m_dx(dx), m_dy(dy), m_color(c) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setShadow(m_radius, m_dx, m_dy, m_color);
-    }
-    virtual OperationType type() { return SetShadowOperation; }
-private:
-    int m_radius;
-    int m_dx;
-    int m_dy;
-    SkColor m_color;
-};
-
-class SetShouldAntialias : public Operation {
-public:
-    SetShouldAntialias(bool useAA) : m_useAA(useAA) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setShouldAntialias(m_useAA);
-    }
-    virtual OperationType type() { return SetShouldAntialiasOperation; }
-private:
-    bool m_useAA;
-};
-
-class SetStrokeColor : public Operation {
-public:
-    SetStrokeColor(const Color& c) : m_color(c) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setStrokeColor(m_color);
-    }
-    virtual OperationType type() { return SetStrokeColorOperation; }
-private:
-    Color m_color;
-};
-
-class SetStrokeShader : public Operation {
-public:
-    SetStrokeShader(SkShader* strokeShader) : m_shader(strokeShader) {
-        SkSafeRef(m_shader);
-    }
-    ~SetStrokeShader() { SkSafeUnref(m_shader); }
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setStrokeShader(m_shader);
-    }
-    virtual OperationType type() { return SetStrokeShaderOperation; }
-private:
-    SkShader* m_shader;
-};
-
-class SetStrokeStyle : public Operation {
+class PossiblyOpaqueOperation : public Operation {
 public:
-    SetStrokeStyle(StrokeStyle style) : m_style(style) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setStrokeStyle(m_style);
-    }
-    virtual OperationType type() { return SetStrokeStyleOperation; }
-private:
-    StrokeStyle m_style;
-};
-
-class SetStrokeThickness : public Operation {
-public:
-    SetStrokeThickness(float thickness) : m_thickness(thickness) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setStrokeThickness(m_thickness);
-    }
-    virtual OperationType type() { return SetStrokeThicknessOperation; }
-private:
-    float m_thickness;
-};
-
-//**************************************
-// Paint setup
-//**************************************
-
-class SetupPaintFill : public Operation {
-public:
-    SetupPaintFill(SkPaint* paint) : m_paint(*paint) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setupPaintFill(&m_paint);
-    }
-    virtual OperationType type() { return SetupPaintFillOperation; }
-private:
-    SkPaint m_paint;
-};
-
-class SetupPaintShadow : public Operation {
-public:
-    SetupPaintShadow(SkPaint* paint, SkPoint* offset)
-        : m_paint(*paint), m_offset(*offset) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setupPaintShadow(&m_paint, &m_offset);
-    }
-    virtual OperationType type() { return SetupPaintShadowOperation; }
-private:
-    SkPaint m_paint;
-    SkPoint m_offset;
-};
+    virtual const IntRect* opaqueRect() { return &m_absoluteOpaqueRect; }
+    virtual void setOpaqueRect(const IntRect& bounds) { m_absoluteOpaqueRect = bounds; }
 
-class SetupPaintStroke : public Operation {
-public:
-    SetupPaintStroke(SkPaint* paint, SkRect* rect, bool isHLine)
-        : m_paint(*paint), m_rect(*rect), m_isHLine(isHLine) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->setupPaintStroke(&m_paint, &m_rect, m_isHLine);
-    }
-    virtual OperationType type() { return SetupPaintStrokeOperation; }
 private:
-    SkPaint m_paint;
-    SkRect m_rect;
-    bool m_isHLine;
+    IntRect m_absoluteOpaqueRect;
 };
 
 //**************************************
@@ -423,10 +179,11 @@ private:
 class ConcatCTM : public Operation {
 public:
     ConcatCTM(const AffineTransform& affine) : m_matrix(affine) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->concatCTM(m_matrix);
+        return true;
     }
-    virtual OperationType type() { return ConcatCTMOperation; }
+    TYPE(ConcatCTMOperation)
 private:
     AffineTransform m_matrix;
 };
@@ -434,10 +191,11 @@ private:
 class Rotate : public Operation {
 public:
     Rotate(float angleInRadians) : m_angle(angleInRadians) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->rotate(m_angle);
+        return true;
     }
-    virtual OperationType type() { return RotateOperation; }
+    TYPE(RotateOperation)
 private:
     float m_angle;
 };
@@ -445,10 +203,11 @@ private:
 class Scale : public Operation {
 public:
     Scale(const FloatSize& size) : m_scale(size) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->scale(m_scale);
+        return true;
     }
-    virtual OperationType type() { return ScaleOperation; }
+    TYPE(ScaleOperation)
 private:
     FloatSize m_scale;
 };
@@ -456,10 +215,11 @@ private:
 class Translate : public Operation {
 public:
     Translate(float x, float y) : m_x(x), m_y(y) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->translate(m_x, m_y);
+        return true;
     }
-    virtual OperationType type() { return TranslateOperation; }
+    TYPE(TranslateOperation)
 private:
     float m_x;
     float m_y;
@@ -473,10 +233,11 @@ class InnerRoundedRectClip : public Operation {
 public:
     InnerRoundedRectClip(const IntRect& rect, int thickness)
         : m_rect(rect), m_thickness(thickness) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->addInnerRoundedRectClip(m_rect, m_thickness);
+        return true;
     }
-    virtual OperationType type() { return InnerRoundedRectClipOperation; }
+    TYPE(InnerRoundedRectClipOperation)
 private:
     IntRect m_rect;
     int m_thickness;
@@ -485,10 +246,10 @@ private:
 class Clip : public Operation {
 public:
     Clip(const FloatRect& rect) : m_rect(rect) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->clip(m_rect);
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
+        return context->clip(m_rect);
     }
-    virtual OperationType type() { return ClipOperation; }
+    TYPE(ClipOperation)
 private:
     const FloatRect m_rect;
 };
@@ -498,17 +259,16 @@ public:
     ClipPath(const Path& path, bool clipout = false)
         : m_path(path), m_clipOut(clipout), m_hasWindRule(false) {}
     void setWindRule(WindRule rule) { m_windRule = rule; m_hasWindRule = true; }
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         if (m_hasWindRule) {
-            context->clipPath(m_path, m_windRule);
-            return;
+            return context->clipPath(m_path, m_windRule);
         }
         if (m_clipOut)
-            context->clipOut(m_path);
+            return context->clipOut(m_path);
         else
-            context->clip(m_path);
+            return context->clip(m_path);
     }
-    virtual OperationType type() { return ClipPathOperation; }
+    TYPE(ClipPathOperation)
 private:
     const Path m_path;
     bool m_clipOut;
@@ -519,10 +279,10 @@ private:
 class ClipOut : public Operation {
 public:
     ClipOut(const IntRect& rect) : m_rect(rect) {}
-    virtual void apply(PlatformGraphicsContext* context) {
-        context->clipOut(m_rect);
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
+        return context->clipOut(m_rect);
     }
-    virtual OperationType type() { return ClipOutOperation; }
+    TYPE(ClipOutOperation)
 private:
     const IntRect m_rect;
 };
@@ -530,10 +290,11 @@ private:
 class ClearRect : public Operation {
 public:
     ClearRect(const FloatRect& rect) : m_rect(rect) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->clearRect(m_rect);
+        return true;
     }
-    virtual OperationType type() { return ClearRectOperation; }
+    TYPE(ClearRectOperation)
 private:
     FloatRect m_rect;
 };
@@ -542,63 +303,101 @@ private:
 // Drawing
 //**************************************
 
-class DrawBitmapPattern : public Operation {
+class DrawBitmapPattern : public PossiblyOpaqueOperation {
 public:
     DrawBitmapPattern(const SkBitmap& bitmap, const SkMatrix& matrix,
                       CompositeOperator op, const FloatRect& destRect)
         : m_bitmap(bitmap), m_matrix(matrix), m_operator(op), m_destRect(destRect) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->drawBitmapPattern(m_bitmap, m_matrix, m_operator, m_destRect);
+        return true;
     }
-    virtual OperationType type() { return DrawBitmapPatternOperation; }
+    virtual bool isOpaque() { return m_bitmap.isOpaque(); }
+    TYPE(DrawBitmapPatternOperation)
+
 private:
-    // TODO: use refcounted bitmap
-    const SkBitmap m_bitmap;
+    SkBitmap m_bitmap;
     SkMatrix m_matrix;
     CompositeOperator m_operator;
     FloatRect m_destRect;
 };
 
-class DrawBitmapRect : public Operation {
+class DrawBitmapRect : public PossiblyOpaqueOperation {
 public:
     DrawBitmapRect(const SkBitmap& bitmap, const SkIRect& srcR,
                    const SkRect& dstR, CompositeOperator op)
         : m_bitmap(bitmap), m_srcR(srcR), m_dstR(dstR), m_operator(op) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->drawBitmapRect(m_bitmap, &m_srcR, m_dstR, m_operator);
+        return true;
     }
-    virtual OperationType type() { return DrawBitmapRectOperation; }
-    virtual String parameters() {
-        return String::format("%.2f, %.2f - %.2f x %.2f",
-                 m_dstR.fLeft, m_dstR.fTop,
-                 m_dstR.width(), m_dstR.height());
-    }
+    virtual bool isOpaque() { return m_bitmap.isOpaque(); }
+    TYPE(DrawBitmapRectOperation)
 private:
-    const SkBitmap& m_bitmap;
+    SkBitmap m_bitmap;
     SkIRect m_srcR;
     SkRect m_dstR;
     CompositeOperator m_operator;
 };
 
+class DrawConvexPolygonQuad : public Operation {
+public:
+    DrawConvexPolygonQuad(const FloatPoint* points, bool shouldAntiAlias)
+        : m_shouldAntiAlias(shouldAntiAlias)
+    {
+        memcpy(m_points, points, 4 * sizeof(FloatPoint));
+    }
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
+        context->drawConvexPolygon(4, m_points, m_shouldAntiAlias);
+        return true;
+    }
+    TYPE(DrawConvexPolygonQuadOperation)
+private:
+    bool m_shouldAntiAlias;
+    FloatPoint m_points[4];
+};
+
 class DrawEllipse : public Operation {
 public:
     DrawEllipse(const IntRect& rect) : m_rect(rect) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->drawEllipse(m_rect);
+        return true;
     }
-    virtual OperationType type() { return DrawEllipseOperation; }
+    TYPE(DrawEllipseOperation)
 private:
     IntRect m_rect;
 };
 
+class DrawFocusRing : public Operation {
+public:
+    DrawFocusRing(const Vector<IntRect>& rects, int width, int offset, const Color& color)
+        : m_rects(rects)
+        , m_width(width)
+        , m_offset(offset)
+        , m_color(color)
+    {}
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
+        context->drawFocusRing(m_rects, m_width, m_offset, m_color);
+        return true;
+    }
+    TYPE(DrawFocusRingOperation)
+private:
+    Vector<IntRect> m_rects;
+    int m_width;
+    int m_offset;
+    Color m_color;
+};
+
 class DrawLine : public Operation {
 public:
     DrawLine(const IntPoint& point1, const IntPoint& point2)
         : m_point1(point1), m_point2(point2) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->drawLine(m_point1, m_point2);
+        return true;
     }
-    virtual OperationType type() { return DrawLineOperation; }
+    TYPE(DrawLineOperation)
 private:
     IntPoint m_point1;
     IntPoint m_point2;
@@ -608,10 +407,11 @@ class DrawLineForText : public Operation {
 public:
     DrawLineForText(const FloatPoint& pt, float width)
         : m_point(pt), m_width(width) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->drawLineForText(m_point, m_width);
+        return true;
     }
-    virtual OperationType type() { return DrawLineForTextOperation; }
+    TYPE(DrawLineForTextOperation)
 private:
     FloatPoint m_point;
     float m_width;
@@ -622,10 +422,11 @@ public:
     DrawLineForTextChecking(const FloatPoint& pt, float width,
                             GraphicsContext::TextCheckingLineStyle lineStyle)
         : m_point(pt), m_width(width), m_lineStyle(lineStyle) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->drawLineForTextChecking(m_point, m_width, m_lineStyle);
+        return true;
     }
-    virtual OperationType type() { return DrawLineForTextCheckingOperation; }
+    TYPE(DrawLineForTextCheckingOperation)
 private:
     FloatPoint m_point;
     float m_width;
@@ -635,10 +436,11 @@ private:
 class DrawRect : public Operation {
 public:
     DrawRect(const IntRect& rect) : m_rect(rect) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->drawRect(m_rect);
+        return true;
     }
-    virtual OperationType type() { return DrawRectOperation; }
+    TYPE(DrawRectOperation)
 private:
     IntRect m_rect;
 };
@@ -647,26 +449,30 @@ class FillPath : public Operation {
 public:
     FillPath(const Path& pathToFill, WindRule fillRule)
         : m_path(pathToFill), m_fillRule(fillRule) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->fillPath(m_path, m_fillRule);
+        return true;
     }
-    virtual OperationType type() { return FillPathOperation; }
+    TYPE(FillPathOperation)
 private:
     Path m_path;
     WindRule m_fillRule;
 };
 
-class FillRect : public Operation {
+class FillRect : public PossiblyOpaqueOperation {
 public:
     FillRect(const FloatRect& rect) : m_rect(rect), m_hasColor(false) {}
     void setColor(Color c) { m_color = c; m_hasColor = true; }
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         if (m_hasColor)
              context->fillRect(m_rect, m_color);
         else
              context->fillRect(m_rect);
+        return true;
     }
-    virtual OperationType type() { return FillRectOperation; }
+    virtual bool isOpaque() { return (m_hasColor && !m_color.hasAlpha())
+            || (!m_hasColor && SkColorGetA(m_state->fillColor) == 0xFF); }
+    TYPE(FillRectOperation)
 private:
     FloatRect m_rect;
     Color m_color;
@@ -688,12 +494,13 @@ public:
         , m_bottomRight(bottomRight)
         , m_color(color)
     {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->fillRoundedRect(m_rect, m_topLeft, m_topRight,
                                  m_bottomLeft, m_bottomRight,
                                  m_color);
+        return true;
     }
-    virtual OperationType type() { return FillRoundedRectOperation; }
+    TYPE(FillRoundedRectOperation)
 private:
     IntRect m_rect;
     IntSize m_topLeft;
@@ -710,10 +517,11 @@ public:
         , m_startAngle(startAngle)
         , m_angleSpan(angleSpan)
     {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->strokeArc(m_rect, m_startAngle, m_angleSpan);
+        return true;
     }
-    virtual OperationType type() { return StrokeArcOperation; }
+    TYPE(StrokeArcOperation)
 private:
     IntRect m_rect;
     int m_startAngle;
@@ -723,10 +531,11 @@ private:
 class StrokePath : public Operation {
 public:
     StrokePath(const Path& path) : m_path(path) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->strokePath(m_path);
+        return true;
     }
-    virtual OperationType type() { return StrokePathOperation; }
+    TYPE(StrokePathOperation)
 private:
     Path m_path;
 };
@@ -736,74 +545,72 @@ class StrokeRect : public Operation {
 public:
     StrokeRect(const FloatRect& rect, float lineWidth)
         : m_rect(rect), m_lineWidth(lineWidth) {}
-    virtual void apply(PlatformGraphicsContext* context) {
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
         context->strokeRect(m_rect, m_lineWidth);
+        return true;
     }
-    virtual OperationType type() { return StrokeRectOperation; }
+    TYPE(StrokeRectOperation)
 private:
     FloatRect m_rect;
     float m_lineWidth;
 };
 
-//**************************************
-// Text
-//**************************************
-
-class DrawComplexText : public Operation {
+class DrawMediaButton : public Operation {
 public:
-    DrawComplexText(SkPicture* picture) : m_picture(picture) {
-        SkSafeRef(m_picture);
-    }
-    ~DrawComplexText() { SkSafeUnref(m_picture); }
-    virtual void apply(PlatformGraphicsContext* context) {
-        if (!context->getCanvas())
-            return;
-        context->getCanvas()->drawPicture(*m_picture);
+    DrawMediaButton(const IntRect& rect, RenderSkinMediaButton::MediaButton buttonType,
+                    bool translucent, bool drawBackground,
+                    const IntRect& thumb)
+        : m_rect(rect)
+        , m_thumb(thumb)
+        , m_buttonType(buttonType)
+        , m_translucent(translucent)
+        , m_drawBackground(drawBackground)
+    {}
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
+        context->drawMediaButton(m_rect, m_buttonType, m_translucent, m_drawBackground, m_thumb);
+        return true;
     }
-    virtual OperationType type() { return DrawComplexTextOperation; }
+    TYPE(DrawMediaButtonOperation)
 private:
-    SkPicture* m_picture;
+    IntRect m_rect;
+    IntRect m_thumb;
+    RenderSkinMediaButton::MediaButton m_buttonType;
+    bool m_translucent : 1;
+    bool m_drawBackground : 1;
 };
 
-class DrawText : public Operation {
+//**************************************
+// Text
+//**************************************
+
+class DrawPosText : public Operation {
 public:
-    DrawText(const Font* font, const SimpleFontData* simpleFont,
-             const GlyphBuffer& glyphBuffer,
-             int from, int numGlyphs, const FloatPoint& point)
-        : m_font(font), m_simpleFont(simpleFont)
-        , m_glyphBuffer(glyphBuffer), m_from(from)
-        , m_numGlyphs(numGlyphs), m_point(point) {
-
-        SkPicture* picture = new SkPicture();
-        SkCanvas* canvas = picture->beginRecording(0, 0, 0);
-        PlatformGraphicsContextSkia platformContext(canvas);
-        GraphicsContext graphicsContext(&platformContext);
-        m_font->drawGlyphs(&graphicsContext, m_simpleFont,
-                           m_glyphBuffer, m_from, m_numGlyphs, m_point);
-        picture->endRecording();
-        m_picture = picture;
-    }
-    ~DrawText() { SkSafeUnref(m_picture); }
-    virtual void apply(PlatformGraphicsContext* context) {
-        if (!context->getCanvas())
-            return;
-        context->getCanvas()->drawPicture(*m_picture);
-    }
-    virtual OperationType type() { return DrawTextOperation; }
-private:
-    SkPicture* m_picture;
-    const Font* m_font;
-    const SimpleFontData* m_simpleFont;
-    const GlyphBuffer m_glyphBuffer;
-    int m_from;
-    int m_numGlyphs;
-    const FloatPoint m_point;
+    DrawPosText(const void* text, size_t byteLength,
+                const SkPoint pos[], const SkPaint& paint)
+        : m_byteLength(byteLength)
+        , m_paint(paint)
+    {
+        size_t points = paint.countText(text, byteLength);
+        m_pos = new SkPoint[points];
+        memcpy(m_pos, pos, sizeof(SkPoint) * points);
+        m_text = malloc(byteLength);
+        memcpy(m_text, text, byteLength);
+    }
+    ~DrawPosText() { delete m_pos; free(m_text); }
+    virtual bool applyImpl(PlatformGraphicsContext* context) {
+        context->drawPosText(m_text, m_byteLength, m_pos, m_paint);
+        return true;
+    }
+    TYPE(DrawPosTextOperation)
+private:
+    void* m_text;
+    size_t m_byteLength;
+    SkPoint* m_pos;
+    SkPaint m_paint;
 };
 
 }
 
 }
 
-#endif // USE(ACCELERATED_COMPOSITING)
-
 #endif // GraphicsOperation_h