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 440 matching lines @@
   void DrawFadedString(const base::string16& text,
                        const FontList& font_list,
                        SkColor color,
                        const Rect& display_rect,
                        int flags);
 
   SkBitmap ToBitmap();
 
   // TODO(enne): rename sk_canvas members and interface.
   cc::PaintCanvas* sk_canvas() { return canvas_; }
+  SkBitmap& get_bitmap() {

[enne (OOO), 2017/03/21 00:46:38]

Maybe ToBitmap() should return bitmap_ if it exists? and then you can just use
ToBitmap instead of get_bitmap?

[vmpstr, 2017/03/21 17:47:12]

Oh, I completely missed that there is ToBitmap here. It seems that it's only
used in unittests. I've updated it to just return the bitmap instead of doing a
readback and now am using it in canvas_paint_mac.mm. 

I could also change it to do a readback if the bitmap doesn't exist, but I don't
think there are usecases right now that do this. WDYT?

[enne (OOO), 2017/03/21 17:51:02]

Oh, even better! If that's always the case, then let's do that!

+    DCHECK(bitmap_);
+    return bitmap_.value();
+  }
   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_