cc/paint: Remove PaintCanvas::peekPixels.

ui/gfx/canvas.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef UI_GFX_CANVAS_H_
 #define UI_GFX_CANVAS_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/optional.h"
 #include "base/strings/string16.h"
 #include "cc/paint/paint_canvas.h"
 #include "cc/paint/paint_flags.h"
-#include "cc/paint/paint_surface.h"
+#include "cc/paint/skia_paint_canvas.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/text_constants.h"
 
 namespace gfx {
 
 class Rect;
 class RectF;
 class FontList;
 class Point;
@@ skipping 436 matching lines @@
   // Apply transformation on the canvas.
   void Transform(const Transform& transform);
 
   // Draws the given string with a fade gradient at the end.
   void DrawFadedString(const base::string16& text,
                        const FontList& font_list,
                        SkColor color,
                        const Rect& display_rect,
                        int flags);
 
   SkBitmap ToBitmap();

[danakj, 2017/03/21 20:02:56]

make a note that writing to this bitmap will change the content of the
gfx::Canvas? or maybe it can return const in some way?

[vmpstr, 2017/03/21 22:34:54]

Done. I also renamed it to AsBitmap to (hopefully) make it clear that both refer
to the same pixels and the fact that the canvas has to be backed by its own
bitmap for this to work (as opposed to using an external canvas).

[danakj, 2017/03/21 22:40:01]

GetBitmap() does an even better job of this I think. AsFoo() is used in other
gfx:: things and it returns a different object, not like an accessor.

[danakj, 2017/03/21 22:42:48]

In fact, why not return const SkBitmap&?

 
   // TODO(enne): rename sk_canvas members and interface.
   cc::PaintCanvas* sk_canvas() { return canvas_; }
   float image_scale() const { return image_scale_; }
 
  private:
   // Tests whether the provided rectangle intersects the current clip rect.
   bool IntersectsClipRect(const SkRect& rect);
 
   // Helper for the DrawImageInt functions declared above. The
   // |remove_image_scale| parameter indicates if the scale of the |image_rep|
   // should be removed when drawing the image, to avoid double-scaling it.
   void DrawImageIntHelper(const ImageSkiaRep& image_rep,
                           int src_x,
                           int src_y,
                           int src_w,
                           int src_h,
                           int dest_x,
                           int dest_y,
                           int dest_w,
                           int dest_h,
                           bool filter,
                           const cc::PaintFlags& flags,
                           bool remove_image_scale);
+  cc::PaintCanvas* CreateOwnedCanvas(const Size& size, bool is_opaque);
 
   // The device scale factor at which drawing on this canvas occurs.
   // An additional scale can be applied via Canvas::Scale(). However,
   // Canvas::Scale() does not affect |image_scale_|.
   float image_scale_;
 
   // canvas_ is our active canvas object. Sometimes we are also the owner,
-  // in which case surface_ will be set. Other times we are just
-  // borrowing someone else's canvas, in which case canvas_ will point there
-  // but surface_ will be null.
-  sk_sp<cc::PaintSurface> surface_;
+  // in which case bitmap_ and owned_canvas_ will be set. Other times we are
+  // just borrowing someone else's canvas, in which case canvas_ will point
+  // there but bitmap_ and owned_canvas_ will not exist.
+  base::Optional<SkBitmap> bitmap_;
+  base::Optional<cc::SkiaPaintCanvas> owned_canvas_;
   cc::PaintCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(Canvas);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_CANVAS_H_