Remove dependency on ui::ScaleFactor from ui/gfx

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_list.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 Size& size, ui::ScaleFactor scale_factor, bool is_opaque)
-    : scale_factor_(scale_factor),
+Canvas::Canvas(const Size& size, float scale, bool is_opaque)
+    : scale_(scale),
       canvas_(NULL) {
-  Size pixel_size = ToCeiledSize(
-      ScaleSize(size, ui::GetScaleFactorScale(scale_factor)));
+  Size pixel_size = ToCeiledSize(ScaleSize(size,scale));
   owned_canvas_ = skia::AdoptRef(skia::CreatePlatformCanvas(pixel_size.width(),
                                                             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);
+  SkScalar scale_scalar = SkFloatToScalar(scale);
+  canvas_->scale(scale_scalar, scale_scalar);
 }
 
 Canvas::Canvas(const ImageSkiaRep& image_rep, bool is_opaque)
-    : scale_factor_(image_rep.scale_factor()),
+    : scale_(image_rep.scale()),
       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);
+  SkScalar scale_scalar = SkFloatToScalar(scale_);
+  canvas_->scale(scale_scalar, scale_scalar);
   DrawImageInt(ImageSkia(image_rep), 0, 0);
 }
 
 Canvas::Canvas()
-    : scale_factor_(ui::SCALE_FACTOR_100P),
+    : scale_(1.0),
       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);
+Canvas* Canvas::CreateCanvasWithoutScaling(SkCanvas* canvas, float scale) {
+  return new Canvas(canvas, scale);
 }
 
 void Canvas::RecreateBackingCanvas(const Size& size,
-                                   ui::ScaleFactor scale_factor,
+                                   float scale,
                                    bool is_opaque) {
-  scale_factor_ = scale_factor;
-  Size pixel_size = ToFlooredSize(
-      ScaleSize(size, ui::GetScaleFactorScale(scale_factor)));
+  scale_ = scale;
+  Size pixel_size = ToFlooredSize(ScaleSize(size, scale));
   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);
+  SkScalar scale_scalar = SkFloatToScalar(scale);
+  canvas_->scale(scale_scalar, scale_scalar);
 }
 
 // static
 void Canvas::SizeStringInt(const base::string16& text,
                            const Font& font,
                            int* width,
                            int* height,
                            int line_height,
                            int flags) {
   SizeStringInt(text, FontList(font), width, height, line_height, flags);
@@ skipping 34 matching lines @@
 
 ImageSkiaRep Canvas::ExtractImageRep() const {
   const SkBitmap& device_bitmap = canvas_->getDevice()->accessBitmap(false);
 
   // Make a bitmap to return, and a canvas to draw into it. We don't just want
   // to call extractSubset or the copy constructor, since we want an actual copy
   // of the bitmap.
   SkBitmap result;
   device_bitmap.copyTo(&result, SkBitmap::kARGB_8888_Config);
 
-  return ImageSkiaRep(result, scale_factor_);
+  return ImageSkiaRep(result, scale_);
 }
 
 void Canvas::DrawDashedRect(const Rect& rect, SkColor color) {
   // Create a 2D bitmap containing alternating on/off pixels - we do this
   // so that you never get two pixels of the same color around the edges
   // of the focus rect (this may mean that opposing edges of the rect may
   // have a dot pattern out of phase to each other).
   static SkColor last_color;
   static SkBitmap* dots = NULL;
   if (!dots || last_color != color) {
@@ skipping 172 matching lines @@
 }
 
 void Canvas::DrawImageInt(const ImageSkia& image,
                           int x,
                           int y,
                           const SkPaint& paint) {
   const ImageSkiaRep& image_rep = GetImageRepToPaint(image);
   if (image_rep.is_null())
     return;
   const SkBitmap& bitmap = image_rep.sk_bitmap();
-  float bitmap_scale = image_rep.GetScale();
+  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),
                       SkFloatToScalar(y * bitmap_scale),
                       &paint);
   canvas_->restore();
 }
@@ skipping 42 matching lines @@
   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 &&
-      image_rep.scale_factor() == ui::SCALE_FACTOR_100P) {
+      image_rep.scale() == 1.0f) {
     // Workaround for apparent bug in Skia that causes image to occasionally
     // shift.
     SkIRect src_rect = { src_x, src_y, src_x + src_w, src_y + src_h };
     const SkBitmap& bitmap = image_rep.sk_bitmap();
     canvas_->drawBitmapRect(bitmap, &src_rect, dest_rect, &paint);
     return;
   }
 
   // Make a bitmap shader that contains the bitmap we want to draw. This is
   // basically what SkCanvas.drawBitmap does internally, but it gives us
@@ skipping 161 matching lines @@
 }
 
 void Canvas::EndPlatformPaint() {
   skia::EndPlatformPaint(canvas_);
 }
 
 void Canvas::Transform(const gfx::Transform& transform) {
   canvas_->concat(transform.matrix());
 }
 
-Canvas::Canvas(SkCanvas* canvas, ui::ScaleFactor scale_factor)
-    : scale_factor_(scale_factor),
+Canvas::Canvas(SkCanvas* canvas, float scale)
+    : scale_(scale),
       owned_canvas_(),
       canvas_(canvas) {
   DCHECK(canvas);
 }
 
 bool Canvas::IntersectsClipRectInt(int x, int y, int w, int h) {
   SkRect clip;
   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, 1.0f, 1.0f);
 }
 
 const ImageSkiaRep& Canvas::GetImageRepToPaint(
     const ImageSkia& image,
     float user_additional_scale_x,
     float user_additional_scale_y) const {
-  const ImageSkiaRep& image_rep = image.GetRepresentation(scale_factor_);
+  const ImageSkiaRep& image_rep = image.GetRepresentation(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.GetScale();
+    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;
 }
 
 }  // namespace gfx