Scrub deprecated Skia APIs.

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 317 matching lines @@
 void Canvas::DrawImageInt(const ImageSkia& image, int x, int y, uint8 a) {
   SkPaint paint;
   paint.setAlpha(a);
   DrawImageInt(image, x, y, paint);
 }
 
 void Canvas::DrawImageInt(const ImageSkia& image,
                           int x,
                           int y,
                           const SkPaint& paint) {
-  const ImageSkiaRep& image_rep = GetImageRepToPaint(image);
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   if (image_rep.is_null())
     return;
   const SkBitmap& bitmap = image_rep.sk_bitmap();
   float bitmap_scale = image_rep.scale();
 
   canvas_->save();
   canvas_->scale(SkFloatToScalar(1.0f / bitmap_scale),
                  SkFloatToScalar(1.0f / bitmap_scale));
   canvas_->drawBitmap(bitmap,
                       SkFloatToScalar(x * bitmap_scale),
@@ skipping 85 matching lines @@
 
   // Restore the state of the canvas.
   Restore();
 }
 
 void Canvas::DrawImageInPath(const ImageSkia& image,
                              int x,
                              int y,
                              const SkPath& path,
                              const SkPaint& paint) {
-  const ImageSkiaRep& image_rep = GetImageRepToPaint(image);
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   if (image_rep.is_null())
     return;
 
   SkMatrix matrix;
   matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
   skia::RefPtr<SkShader> shader = CreateImageRepShader(
       image_rep,
       SkShader::kRepeat_TileMode,
       matrix);
 
@@ skipping 42 matching lines @@
                           int src_y,
                           float tile_scale_x,
                           float tile_scale_y,
                           int dest_x,
                           int dest_y,
                           int w,
                           int h) {
   if (!IntersectsClipRectInt(dest_x, dest_y, w, h))
     return;
 
-  const ImageSkiaRep& image_rep = GetImageRepToPaint(
-      image, image_scale_, tile_scale_x, tile_scale_y);
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   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));
 
   skia::RefPtr<SkShader> shader = CreateImageRepShader(
@@ skipping 36 matching lines @@
   return canvas_->getClipBounds(&clip) &&
       clip.intersect(SkIntToScalar(x), SkIntToScalar(y), SkIntToScalar(x + w),
                      SkIntToScalar(y + h));
 }
 
 bool Canvas::IntersectsClipRect(const Rect& rect) {
   return IntersectsClipRectInt(rect.x(), rect.y(),
                                rect.width(), rect.height());
 }
 
-const ImageSkiaRep& Canvas::GetImageRepToPaint(const ImageSkia& image) const {
-  return GetImageRepToPaint(image, image_scale_, 1.0f, 1.0f);
-}
-
-const ImageSkiaRep& Canvas::GetImageRepToPaint(
-    const ImageSkia& image,
-    float image_scale,
-    float user_additional_scale_x,
-    float user_additional_scale_y) const {
-  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale);
-
-  if (!image_rep.is_null()) {
-    SkMatrix m = canvas_->getTotalMatrix();
-    float scale_x = SkScalarToFloat(SkScalarAbs(m.getScaleX())) *
-        user_additional_scale_x;
-    float scale_y = SkScalarToFloat(SkScalarAbs(m.getScaleY())) *
-        user_additional_scale_y;
-
-    float bitmap_scale = image_rep.scale();
-    if (scale_x < bitmap_scale || scale_y < bitmap_scale)
-      const_cast<SkBitmap&>(image_rep.sk_bitmap()).buildMipMap();
-  }
-
-  return image_rep;
-}
-
 void Canvas::DrawImageIntHelper(const ImageSkia& image,
                                 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 SkPaint& paint,
                                 float image_scale,
                                 bool pixel) {
   DLOG_ASSERT(src_x + src_w < std::numeric_limits<int16_t>::max() &&
               src_y + src_h < std::numeric_limits<int16_t>::max());
   if (src_w <= 0 || src_h <= 0) {
     NOTREACHED() << "Attempting to draw bitmap from an empty rect!";
     return;
   }
 
   if (!IntersectsClipRectInt(dest_x, dest_y, dest_w, dest_h))
     return;
 
   float user_scale_x = static_cast<float>(dest_w) / src_w;
   float user_scale_y = static_cast<float>(dest_h) / src_h;
 
-  const ImageSkiaRep& image_rep = GetImageRepToPaint(image,
-      image_scale, user_scale_x, user_scale_y);
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale);
   if (image_rep.is_null())
     return;
 
   SkRect dest_rect = { SkIntToScalar(dest_x),
                        SkIntToScalar(dest_y),
                        SkIntToScalar(dest_x + dest_w),
                        SkIntToScalar(dest_y + dest_h) };
 
   if (src_w == dest_w && src_h == dest_h &&
       user_scale_x == 1.0f && user_scale_y == 1.0f &&
@@ skipping 18 matching lines @@
 
   skia::RefPtr<SkShader> shader = CreateImageRepShaderForScale(
       image_rep,
       SkShader::kRepeat_TileMode,
       shader_scale,
       pixel ? 1.0f : image_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.setFilterLevel(filter ? SkPaint::kLow_FilterLevel
+                          : SkPaint::kNone_FilterLevel);
   p.setShader(shader.get());
 
   // The rect will be filled by the bitmap.
   canvas_->drawRect(dest_rect, p);
 }
 
 }  // namespace gfx