MacViews: views_examples_with_content_exe working!

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"
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/effects/SkGradientShader.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, float image_scale, bool is_opaque)
     : image_scale_(image_scale),
       canvas_(NULL) {
+  DCHECK_NE(0.0, image_scale_);
   Size pixel_size = ToCeiledSize(ScaleSize(size, image_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_scalar = SkFloatToScalar(image_scale);
   canvas_->scale(scale_scalar, scale_scalar);
 }
 
 Canvas::Canvas(const ImageSkiaRep& image_rep, bool is_opaque)
     : image_scale_(image_rep.scale()),
       owned_canvas_(skia::AdoptRef(
           skia::CreatePlatformCanvas(image_rep.pixel_width(),
                                      image_rep.pixel_height(),
                                      is_opaque))),
       canvas_(owned_canvas_.get()) {
+  DCHECK_NE(0.0, image_scale_);
   SkScalar scale_scalar = SkFloatToScalar(image_scale_);
   canvas_->scale(scale_scalar, scale_scalar);
   DrawImageInt(ImageSkia(image_rep), 0, 0);
 }
 
 Canvas::Canvas()
     : image_scale_(1.0),
       owned_canvas_(skia::AdoptRef(skia::CreatePlatformCanvas(0, 0, false))),
       canvas_(owned_canvas_.get()) {
 }
 
 Canvas::~Canvas() {
 }
 
 // static
 Canvas* Canvas::CreateCanvasWithoutScaling(SkCanvas* canvas,
                                            float image_scale) {
   return new Canvas(canvas, image_scale);
 }
 
 void Canvas::RecreateBackingCanvas(const Size& size,
                                    float image_scale,
                                    bool is_opaque) {
   image_scale_ = image_scale;
+  DCHECK_NE(0.0, image_scale_);
   Size pixel_size = ToFlooredSize(ScaleSize(size, image_scale));
   owned_canvas_ = skia::AdoptRef(skia::CreatePlatformCanvas(pixel_size.width(),
                                                             pixel_size.height(),
                                                             is_opaque));
   canvas_ = owned_canvas_.get();
   SkScalar scale_scalar = SkFloatToScalar(image_scale);
   canvas_->scale(scale_scalar, scale_scalar);
 }
 
 // static
@@ skipping 242 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) {
+  if (image_scale_ == 0)
+    DLOG(ERROR) << "0 image scale??";
+  image_scale_ = 1;
   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,
@@ skipping 280 matching lines @@
   SkPaint p(paint);
   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