Aura: New window shadows, desktop background debug toggle

ash/wm/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 "ash/wm/image_grid.h"
 
 #include <algorithm>
 
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/transform.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 
 using std::max;
 using std::min;
 
 namespace ash {
 namespace internal {
 
 gfx::Rect ImageGrid::TestAPI::GetTransformedLayerBounds(
     const ui::Layer& layer) {
   gfx::Rect bounds = layer.bounds();
   layer.transform().TransformRect(&bounds);
   return bounds;
 }
 
 ImageGrid::ImageGrid()
-    : top_image_height_(0),
+    : layer_(new ui::Layer(ui::Layer::LAYER_NOT_DRAWN)),
+      top_image_height_(0),
       bottom_image_height_(0),
       left_image_width_(0),
       right_image_width_(0),
       top_row_height_(0),
       bottom_row_height_(0),
       left_column_width_(0),
       right_column_width_(0) {
 }
 
 ImageGrid::~ImageGrid() {
 }
 
-void ImageGrid::Init(const gfx::Image* top_left_image,
-                     const gfx::Image* top_image,
-                     const gfx::Image* top_right_image,
-                     const gfx::Image* left_image,
-                     const gfx::Image* center_image,
-                     const gfx::Image* right_image,
-                     const gfx::Image* bottom_left_image,
-                     const gfx::Image* bottom_image,
-                     const gfx::Image* bottom_right_image) {
-  layer_.reset(new ui::Layer(ui::Layer::LAYER_NOT_DRAWN));
-
-  InitImage(top_left_image, &top_left_layer_, &top_left_painter_);
-  InitImage(top_image, &top_layer_, &top_painter_);
-  InitImage(top_right_image, &top_right_layer_, &top_right_painter_);
-  InitImage(left_image, &left_layer_, &left_painter_);
-  InitImage(center_image, &center_layer_, &center_painter_);
-  InitImage(right_image, &right_layer_, &right_painter_);
-  InitImage(bottom_left_image, &bottom_left_layer_, &bottom_left_painter_);
-  InitImage(bottom_image, &bottom_layer_, &bottom_painter_);
-  InitImage(bottom_right_image, &bottom_right_layer_, &bottom_right_painter_);
+void ImageGrid::SetImages(const gfx::Image* top_left_image,
+                          const gfx::Image* top_image,
+                          const gfx::Image* top_right_image,
+                          const gfx::Image* left_image,
+                          const gfx::Image* center_image,
+                          const gfx::Image* right_image,
+                          const gfx::Image* bottom_left_image,
+                          const gfx::Image* bottom_image,
+                          const gfx::Image* bottom_right_image) {
+  SetImage(top_left_image, &top_left_layer_, &top_left_painter_);
+  SetImage(top_image, &top_layer_, &top_painter_);
+  SetImage(top_right_image, &top_right_layer_, &top_right_painter_);
+  SetImage(left_image, &left_layer_, &left_painter_);
+  SetImage(center_image, &center_layer_, &center_painter_);
+  SetImage(right_image, &right_layer_, &right_painter_);
+  SetImage(bottom_left_image, &bottom_left_layer_, &bottom_left_painter_);
+  SetImage(bottom_image, &bottom_layer_, &bottom_painter_);
+  SetImage(bottom_right_image, &bottom_right_layer_, &bottom_right_painter_);
 
   top_image_height_ = GetImageSize(top_image).height();
   bottom_image_height_ = GetImageSize(bottom_image).height();
   left_image_width_ = GetImageSize(left_image).width();
   right_image_width_ = GetImageSize(right_image).width();
 
   top_row_height_ = max(GetImageSize(top_left_image).height(),
                         max(GetImageSize(top_image).height(),
                             GetImageSize(top_right_image).height()));
   bottom_row_height_ = max(GetImageSize(bottom_left_image).height(),
                            max(GetImageSize(bottom_image).height(),
                                GetImageSize(bottom_right_image).height()));
   left_column_width_ = max(GetImageSize(top_left_image).width(),
                            max(GetImageSize(left_image).width(),
                                GetImageSize(bottom_left_image).width()));
   right_column_width_ = max(GetImageSize(top_right_image).width(),
                             max(GetImageSize(right_image).width(),
                                 GetImageSize(bottom_right_image).width()));
+
+  // Invalidate previous |size_| so calls to SetSize() will recompute it.
+  size_.SetSize(0, 0);
 }
 
 void ImageGrid::SetSize(const gfx::Size& size) {
   if (size_ == size)
     return;
 
   size_ = size;
 
   gfx::Rect updated_bounds = layer_->bounds();
   updated_bounds.set_size(size);
@@ skipping 127 matching lines @@
       gfx::Size();
 }
 
 // static
 bool ImageGrid::LayerExceedsSize(const ui::Layer* layer,
                                  const gfx::Size& size) {
   return layer->bounds().width() > size.width() ||
       layer->bounds().height() > size.height();
 }
 
-void ImageGrid::InitImage(const gfx::Image* image,
-                          scoped_ptr<ui::Layer>* layer_ptr,
-                          scoped_ptr<ImagePainter>* painter_ptr) {
+void ImageGrid::SetImage(const gfx::Image* image,
+                         scoped_ptr<ui::Layer>* layer_ptr,
+                         scoped_ptr<ImagePainter>* painter_ptr) {
+  // 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;
 
+  // Set up the new layer and painter.
   layer_ptr->reset(new ui::Layer(ui::Layer::LAYER_TEXTURED));
 
   const gfx::Size size = GetImageSize(image);
   layer_ptr->get()->SetBounds(gfx::Rect(0, 0, size.width(), size.height()));
 
   painter_ptr->reset(new ImagePainter(image));
   layer_ptr->get()->set_delegate(painter_ptr->get());
   layer_ptr->get()->SetFillsBoundsOpaquely(false);
   layer_ptr->get()->SetVisible(true);
   layer_->Add(layer_ptr->get());
 }
 
 }  // namespace internal
 }  // namespace ash