cc/paint: Remove PaintCanvas::peekPixels.

ui/gfx/canvas.cc

 // 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.
 
 #include "ui/gfx/canvas.h"
 
 #include <cmath>
 #include <limits>
 
 #include "base/i18n/rtl.h"
@@ skipping 13 matching lines @@
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_paint_util.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace gfx {
 
 namespace {
 
-sk_sp<cc::PaintSurface> CreateSurface(const Size& size, bool is_opaque) {
+SkBitmap CreateBitmap(const Size& size, bool is_opaque) {
   // SkSurface cannot be zero-sized, but clients of Canvas sometimes request
   // that (and then later resize).
   int width = std::max(size.width(), 1);
   int height = std::max(size.height(), 1);
   SkAlphaType alpha = is_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
   SkImageInfo info = SkImageInfo::MakeN32(width, height, alpha);
-  return cc::PaintSurface::MakeRaster(info);
+  SkBitmap bitmap;
+  bool success = bitmap.tryAllocPixels(info);

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

why not allocPixels? We should crash on OOM

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

Done.

+  DCHECK(success);
+  return bitmap;
 }
 
 }  // namespace
 
 Canvas::Canvas(const Size& size, float image_scale, bool is_opaque)
     : image_scale_(image_scale) {
   Size pixel_size = ScaleToCeiledSize(size, image_scale);
-  surface_ = CreateSurface(pixel_size, is_opaque);
-  canvas_ = surface_->getCanvas();
+  canvas_ = CreateOwnedCanvas(pixel_size, is_opaque);
 
 #if !defined(USE_CAIRO)
   // skia::PlatformCanvas instances are initialized to 0 by Cairo, but
   // uninitialized on other platforms.
   if (!is_opaque)
     canvas_->clear(SkColorSetARGB(0, 0, 0, 0));
 #endif
 
   SkScalar scale_scalar = SkFloatToScalar(image_scale);
   canvas_->scale(scale_scalar, scale_scalar);
 }
 
 Canvas::Canvas()
-    : image_scale_(1.f),
-      surface_(CreateSurface({0, 0}, false)),
-      canvas_(surface_->getCanvas()) {}
+    : image_scale_(1.f), canvas_(CreateOwnedCanvas({0, 0}, false)) {}
 
 Canvas::Canvas(cc::PaintCanvas* canvas, float image_scale)
     : image_scale_(image_scale), canvas_(canvas) {
   DCHECK(canvas_);
 }
 
 Canvas::~Canvas() {
 }
 
 void Canvas::RecreateBackingCanvas(const Size& size,
                                    float image_scale,
                                    bool is_opaque) {
   image_scale_ = image_scale;
   Size pixel_size = ScaleToFlooredSize(size, image_scale);
-  surface_ = CreateSurface(pixel_size, is_opaque);
-  canvas_ = surface_->getCanvas();
+  canvas_ = CreateOwnedCanvas(pixel_size, is_opaque);
 
   SkScalar scale_scalar = SkFloatToScalar(image_scale);
   canvas_->scale(scale_scalar, scale_scalar);
 }
 
 // static
 void Canvas::SizeStringInt(const base::string16& text,
                            const FontList& font_list,
                            int* width,
                            int* height,
@@ skipping 459 matching lines @@
                                         shader_scale));
   flags->setBlendMode(SkBlendMode::kSrcOver);
   return true;
 }
 
 void Canvas::Transform(const gfx::Transform& transform) {
   canvas_->concat(transform.matrix());
 }
 
 SkBitmap Canvas::ToBitmap() {
-  SkBitmap bitmap;
-  bitmap.setInfo(canvas_->imageInfo());
-  canvas_->readPixels(&bitmap, 0, 0);
-  return bitmap;
+  DCHECK(bitmap_);
+  return *bitmap_;
 }
 
 bool Canvas::IntersectsClipRect(const SkRect& rect) {
   SkRect clip;
   return canvas_->getLocalClipBounds(&clip) && clip.intersects(rect);
 }
 
 void Canvas::DrawImageIntHelper(const ImageSkiaRep& image_rep,
                                 int src_x,
                                 int src_y,
@@ skipping 36 matching lines @@
   cc::PaintFlags flags(original_flags);
   flags.setFilterQuality(filter ? kLow_SkFilterQuality : kNone_SkFilterQuality);
   flags.setShader(CreateImageRepShaderForScale(
       image_rep, SkShader::kRepeat_TileMode, shader_scale,
       remove_image_scale ? image_rep.scale() : 1.f));
 
   // The rect will be filled by the bitmap.
   canvas_->drawRect(dest_rect, flags);
 }
 
+cc::PaintCanvas* Canvas::CreateOwnedCanvas(const Size& size, bool is_opaque) {
+  bitmap_ = CreateBitmap(size, is_opaque);

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

This is the only caller of CreateBitmap, inline it here?

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

Done.

+  owned_canvas_ = cc::SkiaPaintCanvas(bitmap_.value());
+  return &owned_canvas_.value();
+}
+
 }  // namespace gfx