ui: Use skia::RefPtr<T> for implicit safe reference counting.

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 <limits>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 #if defined(OS_WIN)
 #include "ui/gfx/canvas_skia_paint.h"
 #endif
 
 namespace gfx {
 
 Canvas::Canvas(const gfx::Size& size,
                ui::ScaleFactor scale_factor,
                bool is_opaque)
       : scale_factor_(scale_factor),
-        owned_canvas_(NULL),
+        owned_canvas_(),

[sky, 2012/11/29 23:54:56]

nit: remove this entirely.

[danakj, 2012/11/30 00:12:21]

Removing owned_canvas is tricky, and makes this CL much larger. Because
sometimes it is empty even tho canvas_ is not.

I can do that though, is that what you want to see?

[sky, 2012/11/30 01:31:47]

I actually just meant you can remove owned_canvas_ from the member initializer.

[danakj, 2012/11/30 01:32:39]

OOhh! ok :)

         canvas_(NULL) {
   gfx::Size pixel_size = gfx::ToFlooredSize(
       gfx::ScaleSize(size, ui::GetScaleFactorScale(scale_factor)));
-  owned_canvas_.reset(skia::CreatePlatformCanvas(pixel_size.width(),
-                                                 pixel_size.height(),
-                                                 is_opaque));
+  owned_canvas_ = skia::AdoptRef(skia::CreatePlatformCanvas(pixel_size.width(),

[sky, 2012/11/29 23:54:56]

Why do we need the extra AdoptRef step? Can't we just assign?

[danakj, 2012/11/30 00:12:21]

skia::CreatePlatformCanvas() returns an SkCanvas* still. We need some 3-sided
WebKit patching to fix it.

+                                                            pixel_size.height(),
+                                                            is_opaque));
   canvas_ = owned_canvas_.get();
 #if defined(OS_WIN) || defined(OS_MACOSX)
   // skia::PlatformCanvas instances are initialized to 0 by Cairo on Linux, but
   // uninitialized on Win and Mac.
   if (!is_opaque)
     owned_canvas_->clear(SkColorSetARGB(0, 0, 0, 0));
 #endif
 
   SkScalar scale = SkFloatToScalar(ui::GetScaleFactorScale(scale_factor));
   canvas_->scale(scale, scale);
 }
 
 Canvas::Canvas(const gfx::ImageSkiaRep& image_rep, bool is_opaque)
     : scale_factor_(image_rep.scale_factor()),
-    owned_canvas_(skia::CreatePlatformCanvas(image_rep.pixel_width(),
-                                             image_rep.pixel_height(),
-                                             is_opaque)),
+      owned_canvas_(skia::AdoptRef(
+          skia::CreatePlatformCanvas(image_rep.pixel_width(),
+                                     image_rep.pixel_height(),
+                                     is_opaque))),
       canvas_(owned_canvas_.get()) {
   SkScalar scale = SkFloatToScalar(ui::GetScaleFactorScale(scale_factor_));
   canvas_->scale(scale, scale);
   DrawImageInt(gfx::ImageSkia(image_rep), 0, 0);
 }
 
 Canvas::Canvas()
     : scale_factor_(ui::SCALE_FACTOR_100P),
-      owned_canvas_(skia::CreatePlatformCanvas(0, 0, false)),
+      owned_canvas_(skia::AdoptRef(skia::CreatePlatformCanvas(0, 0, false))),
       canvas_(owned_canvas_.get()) {
 }
 
 Canvas::~Canvas() {
 }
 
 // static
 Canvas* Canvas::CreateCanvasWithoutScaling(SkCanvas* canvas,
                                            ui::ScaleFactor scale_factor) {
   return new Canvas(canvas, scale_factor);
 }
 
 void Canvas::RecreateBackingCanvas(const gfx::Size& size,
                                    ui::ScaleFactor scale_factor,
                                    bool is_opaque) {
   scale_factor_ = scale_factor;
   gfx::Size pixel_size = gfx::ToFlooredSize(
       gfx::ScaleSize(size, ui::GetScaleFactorScale(scale_factor)));
-  owned_canvas_.reset(skia::CreatePlatformCanvas(pixel_size.width(),
-                                                 pixel_size.height(),
-                                                 is_opaque));
+  owned_canvas_ = skia::AdoptRef(skia::CreatePlatformCanvas(pixel_size.width(),
+                                                            pixel_size.height(),
+                                                            is_opaque));
   canvas_ = owned_canvas_.get();
   SkScalar scale = SkFloatToScalar(ui::GetScaleFactorScale(scale_factor_));
   canvas_->scale(scale, scale);
 }
 
 // static
 int Canvas::GetStringWidth(const string16& text, const gfx::Font& font) {
   int width = 0, height = 0;
   Canvas::SizeStringInt(text, font, &width, &height, NO_ELLIPSIS);
   return width;
@@ skipping 39 matching lines @@
       for (int u = 0; u < col_pixels; u++) {
         if ((u % 2 + i % 2) % 2 != 0) {
           dot[i * row_pixels + u] = color;
         }
       }
     }
   }
 
   // Make a shader for the bitmap with an origin of the box we'll draw. This
   // shader is refcounted and will have an initial refcount of 1.
-  SkShader* shader = SkShader::CreateBitmapShader(
-      *dots, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
+  skia::RefPtr<SkShader> shader = skia::AdoptRef(
+      SkShader::CreateBitmapShader(
+          *dots, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode));
   // Assign the shader to the paint & release our reference. The paint will
   // now own the shader and the shader will be destroyed when the paint goes
   // out of scope.
   SkPaint paint;
-  paint.setShader(shader);
-  shader->unref();
+  paint.setShader(shader.get());
 
   DrawRect(gfx::Rect(rect.x(), rect.y(), rect.width(), 1), paint);
   DrawRect(gfx::Rect(rect.x(), rect.y() + rect.height() - 1, rect.width(), 1),
            paint);
   DrawRect(gfx::Rect(rect.x(), rect.y(), 1, rect.height()), paint);
   DrawRect(gfx::Rect(rect.x() + rect.width() - 1, rect.y(), 1, rect.height()),
            paint);
 }
 
 void Canvas::Save() {
@@ skipping 205 matching lines @@
   // Make a bitmap shader that contains the bitmap we want to draw. This is
   // basically what SkCanvas.drawBitmap does internally, but it gives us
   // more control over quality and will use the mipmap in the source image if
   // it has one, whereas drawBitmap won't.
   SkMatrix shader_scale;
   shader_scale.setScale(SkFloatToScalar(user_scale_x),
                         SkFloatToScalar(user_scale_y));
   shader_scale.preTranslate(SkIntToScalar(-src_x), SkIntToScalar(-src_y));
   shader_scale.postTranslate(SkIntToScalar(dest_x), SkIntToScalar(dest_y));
 
-  SkShader* shader = gfx::CreateImageRepShader(image_rep,
-                                               SkShader::kRepeat_TileMode,
-                                               shader_scale);
+  skia::RefPtr<SkShader> shader = gfx::CreateImageRepShader(
+      image_rep,
+      SkShader::kRepeat_TileMode,
+      shader_scale);
 
   // Set up our paint to use the shader & release our reference (now just owned
   // by the paint).
   SkPaint p(paint);
   p.setFilterBitmap(filter);
-  p.setShader(shader);
-  shader->unref();
+  p.setShader(shader.get());
 
   // The rect will be filled by the bitmap.
   canvas_->drawRect(dest_rect, p);
 }
 
 void Canvas::DrawImageInPath(const gfx::ImageSkia& image,
                              int x,
                              int y,
                              const SkPath& path,
                              const SkPaint& paint) {
   const gfx::ImageSkiaRep& image_rep = GetImageRepToPaint(image);
   if (image_rep.is_null())
     return;
 
   SkMatrix matrix;
   matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
-  SkShader* shader = gfx::CreateImageRepShader(image_rep,
-      SkShader::kRepeat_TileMode, matrix);
+  skia::RefPtr<SkShader> shader = gfx::CreateImageRepShader(
+      image_rep,
+      SkShader::kRepeat_TileMode,
+      matrix);
 
   SkPaint p(paint);
-  p.setShader(shader);
-  shader->unref();
+  p.setShader(shader.get());
   canvas_->drawPath(path, p);
 }
 
 void Canvas::DrawStringInt(const string16& text,
                            const gfx::Font& font,
                            SkColor color,
                            int x, int y, int w, int h) {
   DrawStringInt(text, font, color, x, y, w, h, DefaultCanvasTextAlignment());
 }
 
@@ skipping 40 matching lines @@
       tile_scale_x, tile_scale_y);
   if (image_rep.is_null())
     return;
 
   SkMatrix shader_scale;
   shader_scale.setScale(SkFloatToScalar(tile_scale_x),
                         SkFloatToScalar(tile_scale_y));
   shader_scale.preTranslate(SkIntToScalar(-src_x), SkIntToScalar(-src_y));
   shader_scale.postTranslate(SkIntToScalar(dest_x), SkIntToScalar(dest_y));
 
-  SkShader* shader = gfx::CreateImageRepShader(image_rep,
-                                               SkShader::kRepeat_TileMode,
-                                               shader_scale);
+  skia::RefPtr<SkShader> shader = gfx::CreateImageRepShader(
+      image_rep,
+      SkShader::kRepeat_TileMode,
+      shader_scale);
 
   SkPaint paint;
-  paint.setShader(shader);
+  paint.setShader(shader.get());
   paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
-  shader->unref();
 
   SkRect dest_rect = { SkIntToScalar(dest_x),
                        SkIntToScalar(dest_y),
                        SkIntToScalar(dest_x + w),
                        SkIntToScalar(dest_y + h) };
   canvas_->drawRect(dest_rect, paint);
 }
 
 gfx::NativeDrawingContext Canvas::BeginPlatformPaint() {
   return skia::BeginPlatformPaint(canvas_);
@@ skipping 46 matching lines @@
 
     float bitmap_scale = image_rep.GetScale();
     if (scale_x < bitmap_scale || scale_y < bitmap_scale)
       const_cast<SkBitmap&>(image_rep.sk_bitmap()).buildMipMap();
   }
 
   return image_rep;
 }
 
 }  // namespace gfx