1 files changed, 106 insertions, 19 deletions

diff --git a/Source/WebCore/platform/graphics/android/context/PlatformGraphicsContextRecording.h b/Source/WebCore/platform/graphics/android/context/PlatformGraphicsContextRecording.h
index ebb0075..0461749 100644
--- a/Source/WebCore/platform/graphics/android/context/PlatformGraphicsContextRecording.h
+++ b/Source/WebCore/platform/graphics/android/context/PlatformGraphicsContextRecording.h
@@ -28,21 +28,42 @@
 
 #include "PlatformGraphicsContext.h"
 
+#include "RecordingContextCanvasProxy.h"
+#include "SkRefCnt.h"
+
 namespace WebCore {
-class GraphicsOperationCollection;
+namespace GraphicsOperation {
+class Operation;
+}
+
+class CanvasState;
+class LinearAllocator;
+class RecordingImpl;
+class PlatformGraphicsContextSkia;
+class RecordingData;
+
+class Recording : public SkRefCnt {
+public:
+    Recording()
+        : m_recording(0)
+    {}
+    ~Recording();
+
+    void draw(SkCanvas* canvas);
+    void setRecording(RecordingImpl* impl);
+    RecordingImpl* recording() { return m_recording; }
+
+private:
+    RecordingImpl* m_recording;
+};
 
 class PlatformGraphicsContextRecording : public PlatformGraphicsContext {
 public:
-    PlatformGraphicsContextRecording(GraphicsOperationCollection* picture);
+    PlatformGraphicsContextRecording(Recording* picture);
     virtual ~PlatformGraphicsContextRecording() {}
     virtual bool isPaintingDisabled();
-    virtual SkCanvas* getCanvas() { return 0; }
-
-    GraphicsOperationCollection* mGraphicsOperationCollection;
-    SkMatrix mCurrentMatrix;
 
     virtual SkCanvas* recordingCanvas();
-    virtual void endRecording(int type = 0);
 
     virtual ContextType type() { return RecordingContext; }
 
@@ -55,16 +76,16 @@ public:
     // State values
     virtual void setAlpha(float alpha);
     virtual void setCompositeOperation(CompositeOperator op);
-    virtual void setFillColor(const Color& c);
-    virtual void setFillShader(SkShader* fillShader);
+    virtual bool setFillColor(const Color& c);
+    virtual bool setFillShader(SkShader* fillShader);
     virtual void setLineCap(LineCap cap);
     virtual void setLineDash(const DashArray& dashes, float dashOffset);
     virtual void setLineJoin(LineJoin join);
     virtual void setMiterLimit(float limit);
     virtual void setShadow(int radius, int dx, int dy, SkColor c);
     virtual void setShouldAntialias(bool useAA);
-    virtual void setStrokeColor(const Color& c);
-    virtual void setStrokeShader(SkShader* strokeShader);
+    virtual bool setStrokeColor(const Color& c);
+    virtual bool setStrokeShader(SkShader* strokeShader);
     virtual void setStrokeStyle(StrokeStyle style);
     virtual void setStrokeThickness(float f);
 
@@ -78,19 +99,20 @@ public:
     // Clipping
     virtual void addInnerRoundedRectClip(const IntRect& rect, int thickness);
     virtual void canvasClip(const Path& path);
-    virtual void clip(const FloatRect& rect);
-    virtual void clip(const Path& path);
-    virtual void clipConvexPolygon(size_t numPoints, const FloatPoint*, bool antialias);
-    virtual void clipOut(const IntRect& r);
-    virtual void clipOut(const Path& p);
-    virtual void clipPath(const Path& pathToClip, WindRule clipRule);
+    virtual bool clip(const FloatRect& rect);
+    virtual bool clip(const Path& path);
+    virtual bool clipConvexPolygon(size_t numPoints, const FloatPoint*, bool antialias);
+    virtual bool clipOut(const IntRect& r);
+    virtual bool clipOut(const Path& p);
+    virtual bool clipPath(const Path& pathToClip, WindRule clipRule);
+    virtual SkIRect getTotalClipBounds() { return enclosingIntRect(mRecordingStateStack.last().mBounds); }
 
     // Drawing
     virtual void clearRect(const FloatRect& rect);
     virtual void drawBitmapPattern(const SkBitmap& bitmap, const SkMatrix& matrix,
                            CompositeOperator compositeOp, const FloatRect& destRect);
     virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
-                        const SkRect& dst, CompositeOperator op);
+                        const SkRect& dst, CompositeOperator op = CompositeSourceOver);
     virtual void drawConvexPolygon(size_t numPoints, const FloatPoint* points,
                            bool shouldAntialias);
     virtual void drawEllipse(const IntRect& rect);
@@ -103,7 +125,7 @@ public:
     virtual void drawLine(const IntPoint& point1, const IntPoint& point2);
     virtual void drawLineForText(const FloatPoint& pt, float width);
     virtual void drawLineForTextChecking(const FloatPoint& pt, float width,
-                                 GraphicsContext::TextCheckingLineStyle);
+                                         GraphicsContext::TextCheckingLineStyle);
     virtual void drawRect(const IntRect& rect);
     virtual void fillPath(const Path& pathToFill, WindRule fillRule);
     virtual void fillRect(const FloatRect& rect);
@@ -115,13 +137,78 @@ public:
     virtual void strokePath(const Path& pathToStroke);
     virtual void strokeRect(const FloatRect& rect, float lineWidth);
 
+    virtual void drawPosText(const void* text, size_t byteLength,
+                             const SkPoint pos[], const SkPaint& paint);
+    virtual void drawMediaButton(const IntRect& rect, RenderSkinMediaButton::MediaButton buttonType,
+                                 bool translucent = false, bool drawBackground = true,
+                                 const IntRect& thumb = IntRect());
+
+    bool hasText() { return m_hasText; }
+    bool isEmpty() { return m_isEmpty; }
 private:
 
     virtual bool shadowsIgnoreTransforms() const {
         return false;
     }
 
+    void clipState(const FloatRect& clip);
+    void appendDrawingOperation(GraphicsOperation::Operation* operation, const FloatRect& bounds);
+    void appendStateOperation(GraphicsOperation::Operation* operation);
+    void pushStateOperation(CanvasState* canvasState);
+    void popStateOperation();
+    void pushMatrix();
+    void popMatrix();
+    IntRect calculateFinalBounds(FloatRect bounds);
+    IntRect calculateCoveredBounds(FloatRect bounds);
+    LinearAllocator* operationHeap();
+    LinearAllocator* canvasStateHeap();
+
     SkPicture* mPicture;
+    SkMatrix* mCurrentMatrix;
+
+    Recording* mRecording;
+    class RecordingState {
+    public:
+        RecordingState(CanvasState* state)
+            : mCanvasState(state)
+            , mHasDrawing(false)
+            , mHasClip(false)
+            , mHasComplexClip(false)
+        {}
+
+        RecordingState(const RecordingState& other)
+            : mCanvasState(other.mCanvasState)
+            , mHasDrawing(other.mHasDrawing)
+            , mHasClip(other.mHasClip)
+            , mHasComplexClip(false)
+            , mBounds(other.mBounds)
+        {}
+
+        void setHasComplexClip() { mHasComplexClip = true; }
+
+        void clip(const FloatRect& rect)
+        {
+            if (mHasClip)
+                mBounds.intersect(rect);
+            else {
+                mBounds = rect;
+                mHasClip = true;
+            }
+        }
+
+        CanvasState* mCanvasState;
+        bool mHasDrawing;
+        bool mHasClip;
+        bool mHasComplexClip;
+        FloatRect mBounds;
+    };
+    Vector<RecordingState> mRecordingStateStack;
+    Vector<SkMatrix> mMatrixStack;
+    State* mOperationState;
+
+    bool m_hasText;
+    bool m_isEmpty;
+    RecordingContextCanvasProxy m_canvasProxy;
 };
 
 }