Move DIP translation from ui/aura to ui/compositor

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/aura/dip_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/rect.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(aura::Window* window)
-    : window_(window),
-      layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)),
+ImageGrid::ImageGrid()
+    : layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)),
       top_image_height_(0),
       bottom_image_height_(0),
       left_image_width_(0),
       right_image_width_(0),
       base_top_row_height_(0),
       base_bottom_row_height_(0),
       base_left_column_width_(0),
       base_right_column_width_(0) {
 }
 
@@ skipping 80 matching lines @@
       transform.ConcatTranslate(
           left, size.height() - bottom_layer_->bounds().height());
       bottom_layer_->SetTransform(transform);
     }
     bottom_layer_->SetVisible(center_width > 0);
   }
   if (left_layer_.get()) {
     if (center_height > 0) {
       ui::Transform transform;
       transform.SetScaleY(
-          static_cast<float>(center_height) / left_layer_->bounds().height());
+          (static_cast<float>(center_height) / left_layer_->bounds().height()));
       transform.ConcatTranslate(0, top);
       left_layer_->SetTransform(transform);
     }
     left_layer_->SetVisible(center_height > 0);
   }
   if (right_layer_.get()) {
     if (center_height > 0) {
       ui::Transform transform;
       transform.SetScaleY(
           static_cast<float>(center_height) / right_layer_->bounds().height());
@@ skipping 55 matching lines @@
       ui::Transform transform;
       transform.SetScale(center_width / center_layer_->bounds().width(),
                          center_height / center_layer_->bounds().height());
       transform.ConcatTranslate(left, top);
       center_layer_->SetTransform(transform);
     }
     center_layer_->SetVisible(center_width > 0 && center_height > 0);
   }
 }
 
-void ImageGrid::SetContentBounds(const gfx::Rect& content_bounds_in_dip) {
-#if defined(ENABLE_DIP)
-  // TODO(oshma): Scale the size of the shadow.
-  const gfx::Rect content_bounds =
-      aura::ConvertRectToPixel(window_, content_bounds_in_dip);
-#else
-  const gfx::Rect& content_bounds = content_bounds_in_dip;
-#endif
+void ImageGrid::SetContentBounds(const gfx::Rect& content_bounds) {
   SetSize(gfx::Size(
       content_bounds.width() + left_image_width_ + right_image_width_,
-      content_bounds.height() + top_image_height_ + bottom_image_height_));
-  layer_->SetBounds(gfx::Rect(content_bounds.x() - left_image_width_,
-                              content_bounds.y() - top_image_height_,
-                              layer_->bounds().width(),
-                              layer_->bounds().height()));
+      content_bounds.height() + top_image_height_ +
+      bottom_image_height_));
+  layer_->SetBounds(
+      gfx::Rect(content_bounds.x() - left_image_width_,
+                content_bounds.y() - top_image_height_,
+                layer_->bounds().width(),
+                layer_->bounds().height()));
 }
 
 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());
   }
 }
 
@@ skipping 26 matching lines @@
   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_TEXTURED));
 
-#if defined(ENABLE_DIP)
-  const gfx::Size size =
-      aura::ConvertSizeToPixel(window_, GetImageSize(image));
-#else
   const gfx::Size size = GetImageSize(image);
-#endif
-
   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