Makes ImageGrid work again

ui/wm/core/image_grid.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/wm/core/image_grid.h"
 
 #include <algorithm>
 
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkXfermode.h"
@@ skipping 11 matching lines @@
 using std::max;
 using std::min;
 
 namespace wm {
 namespace {
 
 // Sets the scaling for the transform applied to a layer.  The left, top,
 // right and bottom layers are stretched to the height or width of the
 // center image.
 
-void ScaleWidth(gfx::Size center, ui::Layer* layer, gfx::Transform& transform) {
+void ScaleWidth(const gfx::Size& center,
+                ui::Layer* layer,
+                gfx::Transform* transform) {
   float layer_width = layer->bounds().width() * layer->device_scale_factor();
   float scale = static_cast<float>(center.width()) / layer_width;
-  transform.Scale(scale, 1.0);
+  transform->Scale(scale, 1.0);
 }
 
-void ScaleHeight(gfx::Size center,
+void ScaleHeight(const gfx::Size& center,
                  ui::Layer* layer,
-                 gfx::Transform& transform) {
+                 gfx::Transform* transform) {
   float layer_height = layer->bounds().height() * layer->device_scale_factor();
   float scale = static_cast<float>(center.height()) / layer_height;
-  transform.Scale(1.0, scale);
+  transform->Scale(1.0, scale);
 }
 
 // Returns the dimensions of |image| if non-NULL or gfx::Size(0, 0) otherwise.
 gfx::Size GetImageSize(const gfx::Image* image) {
   return image ? gfx::Size(image->ToImageSkia()->width(),
                            image->ToImageSkia()->height())
                : gfx::Size();
 }
 
 // Returns true if |layer|'s bounds don't fit within |size|.
@@ skipping 92 matching lines @@
   // At non-integer scale factors, the ratio of dimensions in DIP is not
   // necessarily the same as the ratio in physical pixels due to rounding.  Set
   // the transform on each of the layers based on dimensions in pixels.
   gfx::Size center_size_in_pixels = gfx::ScaleToFlooredSize(
       gfx::Size(center_width, center_height), layer_->device_scale_factor());
 
   if (top_layer_.get()) {
     if (center_width > 0) {
       gfx::Transform transform;
       transform.Translate(left, 0);
-      ScaleWidth(center_size_in_pixels, top_layer_.get(), transform);
+      ScaleWidth(center_size_in_pixels, top_layer_.get(), &transform);
       top_layer_->SetTransform(transform);
     }
     top_layer_->SetVisible(center_width > 0);
   }
   if (bottom_layer_.get()) {
     if (center_width > 0) {
       gfx::Transform transform;
       transform.Translate(
           left, size.height() - bottom_layer_->bounds().height());
-      ScaleWidth(center_size_in_pixels, bottom_layer_.get(), transform);
+      ScaleWidth(center_size_in_pixels, bottom_layer_.get(), &transform);
       bottom_layer_->SetTransform(transform);
     }
     bottom_layer_->SetVisible(center_width > 0);
   }
   if (left_layer_.get()) {
     if (center_height > 0) {
       gfx::Transform transform;
       transform.Translate(0, top);
-      ScaleHeight(center_size_in_pixels, left_layer_.get(), transform);
+      ScaleHeight(center_size_in_pixels, left_layer_.get(), &transform);
       left_layer_->SetTransform(transform);
     }
     left_layer_->SetVisible(center_height > 0);
   }
   if (right_layer_.get()) {
     if (center_height > 0) {
       gfx::Transform transform;
       transform.Translate(
           size.width() - right_layer_->bounds().width(), top);
-      ScaleHeight(center_size_in_pixels, right_layer_.get(), transform);
+      ScaleHeight(center_size_in_pixels, right_layer_.get(), &transform);
       right_layer_->SetTransform(transform);
     }
     right_layer_->SetVisible(center_height > 0);
   }
 
   if (top_left_layer_.get()) {
     // No transformation needed; it should be at (0, 0) and unscaled.
     top_left_painter_->SetClipRect(
         LayerExceedsSize(top_left_layer_.get(), gfx::Size(left, top)) ?
             gfx::Rect(gfx::Rect(0, 0, left, top)) :
@@ skipping 65 matching lines @@
 
 void ImageGrid::ImagePainter::SetClipRect(const gfx::Rect& clip_rect,
                                           ui::Layer* layer) {
   if (clip_rect != clip_rect_) {
     clip_rect_ = clip_rect;
     layer->SchedulePaint(layer->bounds());
   }
 }
 
 void ImageGrid::ImagePainter::OnPaintLayer(const ui::PaintContext& context) {
-  gfx::Size bounding_size(clip_rect_.right(), clip_rect_.bottom());
+  gfx::Size bounding_size(image_.width(), image_.height());

[sky, 2016/04/01 23:11:56]

This is the important change. The rest are just random changes I happened upon
while looking at this class. 301-302 (old) isn't needed as ~Layer implicitly
removes from the parent.

   ui::PaintRecorder recorder(context, bounding_size);
   if (!clip_rect_.IsEmpty())
     recorder.canvas()->ClipRect(clip_rect_);
   recorder.canvas()->DrawImageInt(image_, 0, 0);
 }
 
 void ImageGrid::ImagePainter::OnDelegatedFrameDamage(
     const gfx::Rect& damage_rect_in_dip) {
 }
 
 void ImageGrid::ImagePainter::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   // Redrawing will take care of scale factor change.
 }
 
 base::Closure ImageGrid::ImagePainter::PrepareForLayerBoundsChange() {
   return base::Closure();
 }
 
 void ImageGrid::SetImage(const gfx::Image* image,
                          scoped_ptr<ui::Layer>* layer_ptr,
                          scoped_ptr<ImagePainter>* painter_ptr,
                          ImageType type) {
   // Minimum width (for HORIZONTAL) or height (for VERTICAL) of the
   // |image| so that layers are scaled property if the device scale
   // factor is non integral.
   const int kMinimumSize = 20;
 
   // Clean out old layers and painters.
-  if (layer_ptr->get())
-    layer_->Remove(layer_ptr->get());
   layer_ptr->reset();
   painter_ptr->reset();
 
   // If we're not using an image, we're done.
   if (!image)
     return;
 
   gfx::ImageSkia image_skia = image->AsImageSkia();
   switch (type) {
     case HORIZONTAL:
@@ skipping 23 matching lines @@
   layer_ptr->get()->SetBounds(gfx::Rect(0, 0, size.width(), size.height()));
 
   painter_ptr->reset(new ImagePainter(image_skia));
   layer_ptr->get()->set_delegate(painter_ptr->get());
   layer_ptr->get()->SetFillsBoundsOpaquely(false);
   layer_ptr->get()->SetVisible(true);
   layer_->Add(layer_ptr->get());
 }
 
 }  // namespace wm