fold AnalysisDevice functionality into AnalysisCanvas,

to simplify setup and to allow Skia to deprecate SkBitmap::Config

This reverts commit 8aecd702877467893896ceea552f8503fa2d4c8a.

BUG=
R=enne@chromium.org

Review URL: https://codereview.chromium.org/177533024

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@254104 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 200 insertions, 268 deletions

diff --git a/skia/ext/analysis_canvas.cc b/skia/ext/analysis_canvas.cc
index 59279f7..8ba24ad 100644
--- a/skia/ext/analysis_canvas.cc
+++ b/skia/ext/analysis_canvas.cc
@@ -5,7 +5,6 @@
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "skia/ext/analysis_canvas.h"
-#include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkDraw.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkShader.h"
@@ -37,78 +36,48 @@ bool IsSolidColorPaint(const SkPaint& paint) {
            xfermode == SkXfermode::kSrcOver_Mode));
 }
 
-bool IsFullQuad(const SkDraw& draw,
-                const SkRect& canvas_rect,
-                const SkRect& drawn_rect) {
+// Returns true if the specified drawn_rect will cover the entire canvas, and
+// that the canvas is not clipped (i.e. it covers ALL of the canvas).
+bool IsFullQuad(SkCanvas* canvas, const SkRect& drawn_rect) {
+  if (SkCanvas::kRect_ClipType != canvas->getClipType())
+    return false;
+
+  SkIRect clip_irect;
+  canvas->getClipDeviceBounds(&clip_irect);
+  // if the clip is smaller than the canvas, we're partly clipped, so abort.
+  if (!clip_irect.contains(SkIRect::MakeSize(canvas->getDeviceSize())))
+    return false;
 
+  const SkMatrix& matrix = canvas->getTotalMatrix();
   // If the transform results in a non-axis aligned
   // rect, then be conservative and return false.
-  if (!draw.fMatrix->rectStaysRect())
+  if (!matrix.rectStaysRect())
     return false;
 
-  SkRect draw_bitmap_rect;
-  draw.fBitmap->getBounds(&draw_bitmap_rect);
-  SkRect clip_rect = SkRect::Make(draw.fRC->getBounds());
   SkRect device_rect;
-  draw.fMatrix->mapRect(&device_rect, drawn_rect);
-
-  // The drawn rect covers the full canvas, if the following conditions hold:
-  // - Clip rect is an actual rectangle.
-  // - The rect we're drawing (post-transform) contains the clip rect.
-  //   That is, all of clip rect will be colored by the rect.
-  // - Clip rect contains the canvas rect.
-  //   That is, we're not clipping to a portion of this canvas.
-  // - The bitmap into which the draw call happens is at least as
-  //   big as the canvas rect
-  return draw.fRC->isRect() &&
-         device_rect.contains(clip_rect) &&
-         clip_rect.contains(canvas_rect) &&
-         draw_bitmap_rect.contains(canvas_rect);
+  matrix.mapRect(&device_rect, drawn_rect);
+  SkRect clip_rect;
+  clip_rect.set(clip_irect);
+  return device_rect.contains(clip_rect);
 }
 
 } // namespace
 
 namespace skia {
 
-AnalysisDevice::AnalysisDevice(const SkBitmap& bitmap)
-    : INHERITED(bitmap),
-      is_forced_not_solid_(false),
-      is_forced_not_transparent_(false),
-      is_solid_color_(true),
-      is_transparent_(true),
-      has_text_(false) {}
-
-AnalysisDevice::~AnalysisDevice() {}
-
-bool AnalysisDevice::GetColorIfSolid(SkColor* color) const {
-  if (is_transparent_) {
-    *color = SK_ColorTRANSPARENT;
-    return true;
-  }
-  if (is_solid_color_) {
-    *color = color_;
-    return true;
-  }
-  return false;
-}
-
-bool AnalysisDevice::HasText() const {
-  return has_text_;
-}
-
-void AnalysisDevice::SetForceNotSolid(bool flag) {
+void AnalysisCanvas::SetForceNotSolid(bool flag) {
   is_forced_not_solid_ = flag;
   if (is_forced_not_solid_)
     is_solid_color_ = false;
 }
 
-void AnalysisDevice::SetForceNotTransparent(bool flag) {
+void AnalysisCanvas::SetForceNotTransparent(bool flag) {
   is_forced_not_transparent_ = flag;
   if (is_forced_not_transparent_)
     is_transparent_ = false;
 }
 
-void AnalysisDevice::clear(SkColor color) {
+void AnalysisCanvas::clear(SkColor color) {
   is_transparent_ = (!is_forced_not_transparent_ && SkColorGetA(color) == 0);
   has_text_ = false;
 
@@ -120,13 +89,17 @@ void AnalysisDevice::clear(SkColor color) {
   }
 }
 
-void AnalysisDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
+void AnalysisCanvas::drawPaint(const SkPaint& paint) {
+  // This check is in SkCanvas::drawPaint(), and some of our unittests rely on
+  // on this, so we reproduce it here.
+  if (isClipEmpty())
+    return;
+
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
-void AnalysisDevice::drawPoints(const SkDraw& draw,
-                                SkCanvas::PointMode mode,
+void AnalysisCanvas::drawPoints(SkCanvas::PointMode mode,
                                 size_t count,
                                 const SkPoint points[],
                                 const SkPaint& paint) {
@@ -134,11 +107,13 @@ void AnalysisDevice::drawPoints(const SkDraw& draw,
   is_transparent_ = false;
 }
 
-void AnalysisDevice::drawRect(const SkDraw& draw,
-                              const SkRect& rect,
-                              const SkPaint& paint) {
-  bool does_cover_canvas =
-      IsFullQuad(draw, SkRect::MakeWH(width(), height()), rect);
+void AnalysisCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
+  // This recreates the early-exit logic in SkCanvas.cpp, which aborts early
+  // if the paint will "draw nothing".
+  if (paint.nothingToDraw())
+    return;
+
+  bool does_cover_canvas = IsFullQuad(this, rect);
 
   SkXfermode::Mode xfermode;
   SkXfermode::AsMode(paint.getXfermode(), &xfermode);
@@ -175,16 +150,12 @@ void AnalysisDevice::drawRect(const SkDraw& draw,
   }
 }
 
-void AnalysisDevice::drawOval(const SkDraw& draw,
-                              const SkRect& oval,
-                              const SkPaint& paint) {
+void AnalysisCanvas::drawOval(const SkRect& oval, const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
-void AnalysisDevice::drawRRect(const SkDraw& draw,
-                               const SkRRect& rr,
-                               const SkPaint& paint) {
+void AnalysisCanvas::drawRRect(const SkRRect& rr, const SkPaint& paint) {
   // This should add the SkRRect to an SkPath, and call
   // drawPath, but since drawPath ignores the SkPath, just
   // do the same work here.
@@ -192,46 +163,57 @@ void AnalysisDevice::drawRRect(const SkDraw& draw,
   is_transparent_ = false;
 }
 
-void AnalysisDevice::drawPath(const SkDraw& draw,
-                              const SkPath& path,
-                              const SkPaint& paint,
-                              const SkMatrix* pre_path_matrix,
-                              bool path_is_mutable) {
+void AnalysisCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
-void AnalysisDevice::drawBitmap(const SkDraw& draw,
-                                const SkBitmap& bitmap,
-                                const SkMatrix& matrix,
-                                const SkPaint& paint) {
+void AnalysisCanvas::drawBitmap(const SkBitmap& bitmap,
+                                SkScalar left,
+                                SkScalar top,
+                                const SkPaint*) {
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
-void AnalysisDevice::drawSprite(const SkDraw& draw,
-                                const SkBitmap& bitmap,
-                                int x,
-                                int y,
-                                const SkPaint& paint) {
+void AnalysisCanvas::drawBitmapRectToRect(const SkBitmap&,
+                                          const SkRect* src,
+                                          const SkRect& dst,
+                                          const SkPaint* paint,
+                                          DrawBitmapRectFlags flags) {
+  // Call drawRect to determine transparency,
+  // but reset solid color to false.
+  SkPaint tmpPaint;
+  if (!paint)
+    paint = &tmpPaint;
+  drawRect(dst, *paint);
+  is_solid_color_ = false;
+}
+
+void AnalysisCanvas::drawBitmapMatrix(const SkBitmap& bitmap,
+                                      const SkMatrix& matrix,
+                                      const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
-void AnalysisDevice::drawBitmapRect(const SkDraw& draw,
-                                    const SkBitmap& bitmap,
-                                    const SkRect* src_or_null,
+void AnalysisCanvas::drawBitmapNine(const SkBitmap& bitmap,
+                                    const SkIRect& center,
                                     const SkRect& dst,
-                                    const SkPaint& paint,
-                                    SkCanvas::DrawBitmapRectFlags flags) {
-  // Call drawRect to determine transparency,
-  // but reset solid color to false.
-  drawRect(draw, dst, paint);
+                                    const SkPaint* paint) {
   is_solid_color_ = false;
+  is_transparent_ = false;
 }
 
-void AnalysisDevice::drawText(const SkDraw& draw,
-                              const void* text,
+void AnalysisCanvas::drawSprite(const SkBitmap& bitmap,
+                                int left,
+                                int top,
+                                const SkPaint* paint) {
+  is_solid_color_ = false;
+  is_transparent_ = false;
+}
+
+void AnalysisCanvas::drawText(const void* text,
                               size_t len,
                               SkScalar x,
                               SkScalar y,
@@ -241,20 +223,26 @@ void AnalysisDevice::drawText(const SkDraw& draw,
   has_text_ = true;
 }
 
-void AnalysisDevice::drawPosText(const SkDraw& draw,
-                                 const void* text,
-                                 size_t len,
-                                 const SkScalar pos[],
-                                 SkScalar const_y,
-                                 int scalars_per_pos,
+void AnalysisCanvas::drawPosText(const void* text,
+                                 size_t byteLength,
+                                 const SkPoint pos[],
                                  const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
   has_text_ = true;
 }
 
-void AnalysisDevice::drawTextOnPath(const SkDraw& draw,
-                                    const void* text,
+void AnalysisCanvas::drawPosTextH(const void* text,
+                                  size_t byteLength,
+                                  const SkScalar xpos[],
+                                  SkScalar constY,
+                                  const SkPaint& paint) {
+  is_solid_color_ = false;
+  is_transparent_ = false;
+  has_text_ = true;
+}
+
+void AnalysisCanvas::drawTextOnPath(const void* text,
                                     size_t len,
                                     const SkPath& path,
                                     const SkMatrix* matrix,
@@ -264,8 +252,7 @@ void AnalysisDevice::drawTextOnPath(const SkDraw& draw,
   has_text_ = true;
 }
 
-void AnalysisDevice::drawVertices(const SkDraw& draw,
-                                  SkCanvas::VertexMode,
+void AnalysisCanvas::drawVertices(SkCanvas::VertexMode,
                                   int vertex_count,
                                   const SkPoint verts[],
                                   const SkPoint texs[],
@@ -278,30 +265,40 @@ void AnalysisDevice::drawVertices(const SkDraw& draw,
   is_transparent_ = false;
 }
 
-void AnalysisDevice::drawDevice(const SkDraw& draw,
-                                SkBaseDevice* device,
-                                int x,
-                                int y,
-                                const SkPaint& paint) {
-  is_solid_color_ = false;
-  is_transparent_ = false;
+// Needed for now, since SkCanvas requires a bitmap, even if it is not backed
+// by any pixels
+static SkBitmap MakeEmptyBitmap(int width, int height) {
+  SkBitmap bitmap;
+  bitmap.setConfig(SkBitmap::kNo_Config, width, height);
+  return bitmap;
 }
 
-AnalysisCanvas::AnalysisCanvas(AnalysisDevice* device)
-    : INHERITED(device),
+AnalysisCanvas::AnalysisCanvas(int width, int height)
+    : INHERITED(MakeEmptyBitmap(width, height)),
       saved_stack_size_(0),
       force_not_solid_stack_level_(kNoLayer),
-      force_not_transparent_stack_level_(kNoLayer) {}
+      force_not_transparent_stack_level_(kNoLayer),
+      is_forced_not_solid_(false),
+      is_forced_not_transparent_(false),
+      is_solid_color_(true),
+      is_transparent_(true),
+      has_text_(false) {}
 
 AnalysisCanvas::~AnalysisCanvas() {}
 
 bool AnalysisCanvas::GetColorIfSolid(SkColor* color) const {
-  return (static_cast<AnalysisDevice*>(getDevice()))->GetColorIfSolid(color);
+  if (is_transparent_) {
+    *color = SK_ColorTRANSPARENT;
+    return true;
+  }
+  if (is_solid_color_) {
+    *color = color_;
+    return true;
+  }
+  return false;
 }
 
-bool AnalysisCanvas::HasText() const {
-  return (static_cast<AnalysisDevice*>(getDevice()))->HasText();
-}
+bool AnalysisCanvas::HasText() const { return has_text_; }
 
 bool AnalysisCanvas::abortDrawing() {
   // Early out as soon as we have detected that the tile has text.
@@ -318,11 +315,11 @@ bool AnalysisCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool do_aa) {
   // and non-transparent until we pop this
   if (force_not_solid_stack_level_ == kNoLayer) {
     force_not_solid_stack_level_ = saved_stack_size_;
-    (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotSolid(true);
+    SetForceNotSolid(true);
   }
   if (force_not_transparent_stack_level_ == kNoLayer) {
     force_not_transparent_stack_level_ = saved_stack_size_;
-    (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(true);
+    SetForceNotTransparent(true);
   }
 
   return INHERITED::clipRect(path.getBounds(), op, do_aa);
@@ -336,11 +333,11 @@ bool AnalysisCanvas::clipRRect(const SkRRect& rrect,
   // and non-transparent until we pop this
   if (force_not_solid_stack_level_ == kNoLayer) {
     force_not_solid_stack_level_ = saved_stack_size_;
-    (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotSolid(true);
+    SetForceNotSolid(true);
   }
   if (force_not_transparent_stack_level_ == kNoLayer) {
     force_not_transparent_stack_level_ = saved_stack_size_;
-    (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(true);
+    SetForceNotTransparent(true);
   }
 
   return INHERITED::clipRect(rrect.getBounds(), op, do_aa);
@@ -356,15 +353,18 @@ int AnalysisCanvas::saveLayer(const SkRect* bounds,
                               SkCanvas::SaveFlags flags) {
   ++saved_stack_size_;
 
+  SkIRect canvas_ibounds = SkIRect::MakeSize(this->getDeviceSize());
+  SkRect canvas_bounds;
+  canvas_bounds.set(canvas_ibounds);
+
   // If after we draw to the saved layer, we have to blend with the current
   // layer, then we can conservatively say that the canvas will not be of
   // solid color.
   if ((paint && !IsSolidColorPaint(*paint)) ||
-      (bounds && !bounds->contains(SkRect::MakeWH(getDevice()->width(),
-                                                  getDevice()->height())))) {
+      (bounds && !bounds->contains(canvas_bounds))) {
     if (force_not_solid_stack_level_ == kNoLayer) {
       force_not_solid_stack_level_ = saved_stack_size_;
-      (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotSolid(true);
+      SetForceNotSolid(true);
     }
   }
 
@@ -377,7 +377,7 @@ int AnalysisCanvas::saveLayer(const SkRect* bounds,
   if (xfermode != SkXfermode::kSrc_Mode) {
     if (force_not_transparent_stack_level_ == kNoLayer) {
       force_not_transparent_stack_level_ = saved_stack_size_;
-      (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(true);
+      SetForceNotTransparent(true);
     }
   }
 
@@ -397,12 +397,11 @@ void AnalysisCanvas::restore() {
   if (saved_stack_size_) {
     --saved_stack_size_;
     if (saved_stack_size_ < force_not_solid_stack_level_) {
-      (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotSolid(false);
+      SetForceNotSolid(false);
       force_not_solid_stack_level_ = kNoLayer;
     }
     if (saved_stack_size_ < force_not_transparent_stack_level_) {
-      (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(
-          false);
+      SetForceNotTransparent(false);
       force_not_transparent_stack_level_ = kNoLayer;
     }
   }
diff --git a/skia/ext/analysis_canvas.h b/skia/ext/analysis_canvas.h
index 3c8f4f9..df8bf17 100644
--- a/skia/ext/analysis_canvas.h
+++ b/skia/ext/analysis_canvas.h
@@ -6,29 +6,27 @@
 #define SKIA_EXT_ANALYSIS_CANVAS_H_
 
 #include "base/compiler_specific.h"
-#include "third_party/skia/include/core/SkBitmapDevice.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
 
 namespace skia {
 
-class AnalysisDevice;
-
 // Does not render anything, but gathers statistics about a region
 // (specified as a clip rectangle) of an SkPicture as the picture is
 // played back through it.
-// To use: create a SkBitmap with kNo_Config, create an AnalysisDevice
-// using that bitmap, and create an AnalysisCanvas using the device.
-// Play a picture into the canvas, and then check result.
+// To use: play a picture into the canvas, and then check result.
 class SK_API AnalysisCanvas : public SkCanvas, public SkDrawPictureCallback {
  public:
-  AnalysisCanvas(AnalysisDevice*);
+  AnalysisCanvas(int width, int height);
   virtual ~AnalysisCanvas();
 
   // Returns true when a SkColor can be used to represent result.
   bool GetColorIfSolid(SkColor* color) const;
   bool HasText() const;
 
+  void SetForceNotSolid(bool flag);
+  void SetForceNotTransparent(bool flag);
+
   // SkDrawPictureCallback override.
   virtual bool abortDrawing() OVERRIDE;
 
@@ -50,103 +48,69 @@ class SK_API AnalysisCanvas : public SkCanvas, public SkDrawPictureCallback {
 
   virtual void restore() OVERRIDE;
 
- private:
-  typedef SkCanvas INHERITED;
-
-  int saved_stack_size_;
-  int force_not_solid_stack_level_;
-  int force_not_transparent_stack_level_;
-};
-
-// TODO(robertphillips): Once Skia's SkBaseDevice API is refactored to
-// remove the bitmap-specific entry points, it might make sense for this
-// to be derived from SkBaseDevice (rather than SkBitmapDevice)
-class SK_API AnalysisDevice : public SkBitmapDevice {
- public:
-  AnalysisDevice(const SkBitmap& bitmap);
-  virtual ~AnalysisDevice();
-
-  bool GetColorIfSolid(SkColor* color) const;
-  bool HasText() const;
-
-  void SetForceNotSolid(bool flag);
-  void SetForceNotTransparent(bool flag);
-
- protected:
-  // SkBaseDevice overrides.
-  virtual void clear(SkColor color) OVERRIDE;
-  virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) OVERRIDE;
-  virtual void drawPoints(const SkDraw& draw,
-                          SkCanvas::PointMode mode,
+  virtual void clear(SkColor) OVERRIDE;
+  virtual void drawPaint(const SkPaint& paint) OVERRIDE;
+  virtual void drawPoints(PointMode,
                           size_t count,
-                          const SkPoint points[],
-                          const SkPaint& paint) OVERRIDE;
-  virtual void drawRect(const SkDraw& draw,
-                        const SkRect& rect,
-                        const SkPaint& paint) OVERRIDE;
-  virtual void drawRRect(const SkDraw& draw,
-                         const SkRRect& rr,
-                         const SkPaint& paint) OVERRIDE;
-  virtual void drawOval(const SkDraw& draw,
-                        const SkRect& oval,
-                        const SkPaint& paint) OVERRIDE;
-  virtual void drawPath(const SkDraw& draw,
-                        const SkPath& path,
-                        const SkPaint& paint,
-                        const SkMatrix* pre_path_matrix = NULL,
-                        bool path_is_mutable = false) OVERRIDE;
-  virtual void drawBitmap(const SkDraw& draw,
-                          const SkBitmap& bitmap,
-                          const SkMatrix& matrix,
-                          const SkPaint& paint) OVERRIDE;
-  virtual void drawSprite(const SkDraw& draw,
-                          const SkBitmap& bitmap,
-                          int x,
-                          int y,
-                          const SkPaint& paint) OVERRIDE;
-  virtual void drawBitmapRect(const SkDraw& draw,
-                              const SkBitmap& bitmap,
-                              const SkRect* src_or_null,
+                          const SkPoint pts[],
+                          const SkPaint&) OVERRIDE;
+  virtual void drawOval(const SkRect&, const SkPaint&) OVERRIDE;
+  virtual void drawRect(const SkRect&, const SkPaint&) OVERRIDE;
+  virtual void drawRRect(const SkRRect&, const SkPaint&) OVERRIDE;
+  virtual void drawPath(const SkPath& path, const SkPaint&) OVERRIDE;
+  virtual void drawBitmap(const SkBitmap&,
+                          SkScalar left,
+                          SkScalar top,
+                          const SkPaint* paint = NULL) OVERRIDE;
+  virtual void drawBitmapRectToRect(const SkBitmap&,
+                                    const SkRect* src,
+                                    const SkRect& dst,
+                                    const SkPaint* paint,
+                                    DrawBitmapRectFlags flags) OVERRIDE;
+  virtual void drawBitmapMatrix(const SkBitmap&,
+                                const SkMatrix&,
+                                const SkPaint* paint = NULL) OVERRIDE;
+  virtual void drawBitmapNine(const SkBitmap& bitmap,
+                              const SkIRect& center,
                               const SkRect& dst,
-                              const SkPaint& paint,
-                              SkCanvas::DrawBitmapRectFlags flags) OVERRIDE;
-  virtual void drawText(const SkDraw& draw,
-                        const void* text,
-                        size_t len,
+                              const SkPaint* paint = NULL) OVERRIDE;
+  virtual void drawSprite(const SkBitmap&, int left, int top,
+                          const SkPaint* paint = NULL) OVERRIDE;
+  virtual void drawText(const void* text,
+                        size_t byteLength,
                         SkScalar x,
                         SkScalar y,
-                        const SkPaint& paint) OVERRIDE;
-  virtual void drawPosText(const SkDraw& draw,
-                           const void* text,
-                           size_t len,
-                           const SkScalar pos[],
-                           SkScalar const_y,
-                           int scalars_per_pos,
-                           const SkPaint& paint) OVERRIDE;
-  virtual void drawTextOnPath(const SkDraw& draw,
-                              const void* text,
-                              size_t len,
+                        const SkPaint&) OVERRIDE;
+  virtual void drawPosText(const void* text,
+                           size_t byteLength,
+                           const SkPoint pos[],
+                           const SkPaint&) OVERRIDE;
+  virtual void drawPosTextH(const void* text,
+                            size_t byteLength,
+                            const SkScalar xpos[],
+                            SkScalar constY,
+                            const SkPaint&) OVERRIDE;
+  virtual void drawTextOnPath(const void* text,
+                              size_t byteLength,
                               const SkPath& path,
                               const SkMatrix* matrix,
-                              const SkPaint& paint) OVERRIDE;
-  virtual void drawVertices(const SkDraw& draw,
-                            SkCanvas::VertexMode vertex_mode,
-                            int vertex_count,
-                            const SkPoint verts[],
+                              const SkPaint&) OVERRIDE;
+  virtual void drawVertices(VertexMode,
+                            int vertexCount,
+                            const SkPoint vertices[],
                             const SkPoint texs[],
                             const SkColor colors[],
-                            SkXfermode* xmode,
+                            SkXfermode*,
                             const uint16_t indices[],
-                            int index_count,
-                            const SkPaint& paint) OVERRIDE;
-  virtual void drawDevice(const SkDraw& draw,
-                          SkBaseDevice* device,
-                          int x,
-                          int y,
-                          const SkPaint& paint) OVERRIDE;
+                            int indexCount,
+                            const SkPaint&) OVERRIDE;
 
  private:
-  typedef SkBitmapDevice INHERITED;
+  typedef SkCanvas INHERITED;
+
+  int saved_stack_size_;
+  int force_not_solid_stack_level_;
+  int force_not_transparent_stack_level_;
 
   bool is_forced_not_solid_;
   bool is_forced_not_transparent_;
diff --git a/skia/ext/analysis_canvas_unittest.cc b/skia/ext/analysis_canvas_unittest.cc
index 79d97ad..44dea95 100644
--- a/skia/ext/analysis_canvas_unittest.cc
+++ b/skia/ext/analysis_canvas_unittest.cc
@@ -21,10 +21,7 @@ void TransparentFill(skia::AnalysisCanvas& canvas) {
 namespace skia {
 
 TEST(AnalysisCanvasTest, EmptyCanvas) {
-  SkBitmap emptyBitmap;
-  emptyBitmap.setConfig(SkBitmap::kNo_Config, 255, 255);
-  skia::AnalysisDevice device(emptyBitmap);
-  skia::AnalysisCanvas canvas(&device);
+  skia::AnalysisCanvas canvas(255, 255);
 
   SkColor color;
   EXPECT_TRUE(canvas.GetColorIfSolid(&color));
@@ -32,10 +29,7 @@ TEST(AnalysisCanvasTest, EmptyCanvas) {
 }
 
 TEST(AnalysisCanvasTest, ClearCanvas) {
-  SkBitmap emptyBitmap;
-  emptyBitmap.setConfig(SkBitmap::kNo_Config, 255, 255);
-  skia::AnalysisDevice device(emptyBitmap);
-  skia::AnalysisCanvas canvas(&device);
+  skia::AnalysisCanvas canvas(255, 255);
 
   // Transparent color
   SkColor color = SkColorSetARGB(0, 12, 34, 56);
@@ -70,10 +64,7 @@ TEST(AnalysisCanvasTest, ClearCanvas) {
 }
 
 TEST(AnalysisCanvasTest, ComplexActions) {
-  SkBitmap emptyBitmap;
-  emptyBitmap.setConfig(SkBitmap::kNo_Config, 255, 255);
-  skia::AnalysisDevice device(emptyBitmap);
-  skia::AnalysisCanvas canvas(&device);
+  skia::AnalysisCanvas canvas(255, 255);
 
   // Draw paint test.
   SkColor color = SkColorSetARGB(255, 11, 22, 33);
@@ -116,10 +107,7 @@ TEST(AnalysisCanvasTest, ComplexActions) {
 }
 
 TEST(AnalysisCanvasTest, SimpleDrawRect) {
-  SkBitmap emptyBitmap;
-  emptyBitmap.setConfig(SkBitmap::kNo_Config, 255, 255);
-  skia::AnalysisDevice device(emptyBitmap);
-  skia::AnalysisCanvas canvas(&device);
+  skia::AnalysisCanvas canvas(255, 255);
 
   SkColor color = SkColorSetARGB(255, 11, 22, 33);
   SkPaint paint;
@@ -151,6 +139,8 @@ TEST(AnalysisCanvasTest, SimpleDrawRect) {
   paint.setColor(color);
   canvas.drawRect(SkRect::MakeWH(383, 383), paint);
 
+  // This test relies on canvas treating a paint with 0-color as a no-op
+  // thus not changing its "is_solid" status.
   EXPECT_TRUE(canvas.GetColorIfSolid(&outputColor));
   EXPECT_NE(static_cast<SkColor>(SK_ColorTRANSPARENT), outputColor);
   EXPECT_EQ(outputColor, SkColorSetARGB(255, 33, 44, 55));
@@ -188,10 +178,7 @@ TEST(AnalysisCanvasTest, SimpleDrawRect) {
 }
 
 TEST(AnalysisCanvasTest, ClipPath) {
-  SkBitmap emptyBitmap;
-  emptyBitmap.setConfig(SkBitmap::kNo_Config, 255, 255);
-  skia::AnalysisDevice device(emptyBitmap);
-  skia::AnalysisCanvas canvas(&device);
+  skia::AnalysisCanvas canvas(255, 255);
 
   SkPath path;
   path.moveTo(0, 0);
@@ -218,10 +205,7 @@ TEST(AnalysisCanvasTest, ClipPath) {
 }
 
 TEST(AnalysisCanvasTest, SaveLayerRestore) {
-  SkBitmap emptyBitmap;
-  emptyBitmap.setConfig(SkBitmap::kNo_Config, 255, 255);
-  skia::AnalysisDevice device(emptyBitmap);
-  skia::AnalysisCanvas canvas(&device);
+  skia::AnalysisCanvas canvas(255, 255);
 
   SkColor outputColor;
   SolidColorFill(canvas);
@@ -283,9 +267,6 @@ TEST(AnalysisCanvasTest, HasText) {
   int width = 200;
   int height = 100;
 
-  SkBitmap bitmap;
-  bitmap.setConfig(SkBitmap::kNo_Config, width, height);
-
   const char* text = "A";
   size_t byteLength = 1;
 
@@ -299,8 +280,7 @@ TEST(AnalysisCanvasTest, HasText) {
   paint.setTextSize(SkIntToScalar(10));
 
   {
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     // Test after initialization.
     EXPECT_FALSE(canvas.HasText());
     // Test drawing anything other than text.
@@ -309,43 +289,37 @@ TEST(AnalysisCanvasTest, HasText) {
   }
   {
     // Test SkCanvas::drawText.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawText(text, byteLength, point.fX, point.fY, paint);
     EXPECT_TRUE(canvas.HasText());
   }
   {
     // Test SkCanvas::drawPosText.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawPosText(text, byteLength, &point, paint);
     EXPECT_TRUE(canvas.HasText());
   }
   {
     // Test SkCanvas::drawPosTextH.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawPosTextH(text, byteLength, &point.fX, point.fY, paint);
     EXPECT_TRUE(canvas.HasText());
   }
   {
     // Test SkCanvas::drawTextOnPathHV.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawTextOnPathHV(text, byteLength, path, point.fX, point.fY, paint);
     EXPECT_TRUE(canvas.HasText());
   }
   {
     // Test SkCanvas::drawTextOnPath.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawTextOnPath(text, byteLength, path, NULL, paint);
     EXPECT_TRUE(canvas.HasText());
   }
   {
     // Text under opaque rect.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawText(text, byteLength, point.fX, point.fY, paint);
     EXPECT_TRUE(canvas.HasText());
     canvas.drawRect(SkRect::MakeWH(width, height), paint);
@@ -353,8 +327,7 @@ TEST(AnalysisCanvasTest, HasText) {
   }
   {
     // Text under translucent rect.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawText(text, byteLength, point.fX, point.fY, paint);
     EXPECT_TRUE(canvas.HasText());
     SkPaint translucentPaint;
@@ -364,8 +337,7 @@ TEST(AnalysisCanvasTest, HasText) {
   }
   {
     // Text under rect in clear mode.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawText(text, byteLength, point.fX, point.fY, paint);
     EXPECT_TRUE(canvas.HasText());
     SkPaint clearModePaint;
@@ -375,8 +347,7 @@ TEST(AnalysisCanvasTest, HasText) {
   }
   {
     // Clear.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.drawText(text, byteLength, point.fX, point.fY, paint);
     EXPECT_TRUE(canvas.HasText());
     canvas.clear(SK_ColorGRAY);
@@ -384,16 +355,14 @@ TEST(AnalysisCanvasTest, HasText) {
   }
   {
     // Text inside clip region.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.clipRect(SkRect::MakeWH(100, 100));
     canvas.drawText(text, byteLength, point.fX, point.fY, paint);
     EXPECT_TRUE(canvas.HasText());
   }
   {
     // Text outside clip region.
-    skia::AnalysisDevice device(bitmap);
-    skia::AnalysisCanvas canvas(&device);
+    skia::AnalysisCanvas canvas(width, height);
     canvas.clipRect(SkRect::MakeXYWH(100, 0, 100, 100));
     canvas.drawText(text, byteLength, point.fX, point.fY, paint);
     // Analysis device does not do any clipping.