(Not ready for review!) Toolbar and views high dpi support.

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/base/win/dpi.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
@@ skipping 27 matching lines @@
       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);
 }
 
+ui::ScaleFactor GetScaleFactor() {
+#if defined(ENABLE_HIDPI)
+  float scale = ui::GetDPIScale();
+  if (scale > 1.6)
+    return ui::SCALE_FACTOR_180P;
+  else if (scale > 1.2)
+    return ui::SCALE_FACTOR_140P;
+#endif
+  return ui::SCALE_FACTOR_100P;
+}
+
 Canvas::Canvas()
-    : scale_factor_(ui::SCALE_FACTOR_100P),
+    : scale_factor_(GetScaleFactor()),
       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_ = skia::AdoptRef(skia::CreatePlatformCanvas(pixel_size.width(),
                                                             pixel_size.height(),
                                                             is_opaque));
   canvas_ = owned_canvas_.get();
   SkScalar scale = SkFloatToScalar(ui::GetScaleFactorScale(scale_factor_));
+  scale = 1;
   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 91 matching lines @@
   SkRect out;
   bool has_non_empty_clip = canvas_->getClipBounds(&out);
   bounds->SetRect(out.left(), out.top(), out.width(), out.height());
   return has_non_empty_clip;
 }
 
 void Canvas::Translate(const gfx::Vector2d& offset) {
   canvas_->translate(SkIntToScalar(offset.x()), SkIntToScalar(offset.y()));
 }
 
+#include "/gtools.h"
+#if defined(ENABLE_HIDPI)
+void Canvas::Scale(double x_scale, double y_scale) {
+  canvas_->scale(x_scale, y_scale);
+//  Debug(L"Scaling %p to %f", this, x_scale);
+}
+#else
 void Canvas::Scale(int x_scale, int y_scale) {
   canvas_->scale(SkIntToScalar(x_scale), SkIntToScalar(y_scale));
 }
+#endif
 
 void Canvas::DrawColor(SkColor color) {
   DrawColor(color, SkXfermode::kSrcOver_Mode);
 }
 
 void Canvas::DrawColor(SkColor color, SkXfermode::Mode mode) {
   canvas_->drawColor(color, mode);
 }
 
 void Canvas::FillRect(const gfx::Rect& rect, SkColor color) {
@@ skipping 89 matching lines @@
 void Canvas::DrawImageInt(const gfx::ImageSkia& image,
                           int x, int y,
                           const SkPaint& paint) {
   const gfx::ImageSkiaRep& image_rep = GetImageRepToPaint(image);
   if (image_rep.is_null())
     return;
   const SkBitmap& bitmap = image_rep.sk_bitmap();
   float bitmap_scale = image_rep.GetScale();
 
   canvas_->save();
-  canvas_->scale(SkFloatToScalar(1.0f / bitmap_scale),
-                 SkFloatToScalar(1.0f / bitmap_scale));
+//  canvas_->scale(SkFloatToScalar(1.0f / bitmap_scale),
+//                 SkFloatToScalar(1.0f / bitmap_scale));
   canvas_->drawBitmap(bitmap,
-                      SkFloatToScalar(x * bitmap_scale),
-                      SkFloatToScalar(y * bitmap_scale),
+                      SkFloatToScalar(x),// * bitmap_scale),
+                      SkFloatToScalar(y),// * bitmap_scale),
                       &paint);
   canvas_->restore();
 }
 
 void Canvas::DrawImageInt(const gfx::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) {
   SkPaint p;
   DrawImageInt(image, src_x, src_y, src_w, src_h, dest_x, dest_y,
@@ skipping 209 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