Move DIP translation from ui/aura to ui/compositor

ui/compositor/layer_unittest.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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "ui/compositor/compositor_observer.h"
+#include "ui/compositor/compositor_setup.h"
+#include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/test/test_compositor_host.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/gfx_paths.h"
 #include "ui/gfx/skia_util.h"
 
-#include "ui/compositor/compositor_setup.h"
-
 namespace ui {
 
 namespace {
 
 // Encodes a bitmap into a PNG and write to disk. Returns true on success. The
 // parent directory does not have to exist.
 bool WritePNGFile(const SkBitmap& bitmap, const FilePath& file_path) {
   std::vector<unsigned char> png_data;
   if (gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, true, &png_data) &&
       file_util::CreateDirectory(file_path.DirName())) {
@@ skipping 179 matching lines @@
   explicit TestLayerDelegate() : color_index_(0) {}
   virtual ~TestLayerDelegate() {}
 
   void AddColor(SkColor color) {
     colors_.push_back(color);
   }
 
   const gfx::Size& paint_size() const { return paint_size_; }
   int color_index() const { return color_index_; }
 
+  std::string ToScaleString() const {
+    return StringPrintf("%.1f %.1f", scale_x_, scale_y_);
+  }
+
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     SkBitmap contents = canvas->ExtractBitmap();
     paint_size_ = gfx::Size(contents.width(), contents.height());
     canvas->FillRect(gfx::Rect(paint_size_), colors_[color_index_]);
     color_index_ = (color_index_ + 1) % static_cast<int>(colors_.size());
+    const SkMatrix& matrix = canvas->sk_canvas()->getTotalMatrix();
+    scale_x_ = matrix.getScaleX();
+    scale_y_ = matrix.getScaleY();
   }
 
  private:
   std::vector<SkColor> colors_;
   int color_index_;
   gfx::Size paint_size_;
+  float scale_x_;
+  float scale_y_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerDelegate);
 };
 
 // LayerDelegate that verifies that a layer was asked to update its canvas.
 class DrawTreeLayerDelegate : public LayerDelegate {
  public:
   DrawTreeLayerDelegate() : painted_(false) {}
   virtual ~DrawTreeLayerDelegate() {}
 
@@ skipping 63 matching lines @@
 #define MAYBE_Delegate DISABLED_Delegate
 #define MAYBE_Draw DISABLED_Draw
 #define MAYBE_DrawTree DISABLED_DrawTree
 #define MAYBE_Hierarchy DISABLED_Hierarchy
 #define MAYBE_HierarchyNoTexture DISABLED_HierarchyNoTexture
 #define MAYBE_DrawPixels DISABLED_DrawPixels
 #define MAYBE_SetRootLayer DISABLED_SetRootLayer
 #define MAYBE_CompositorObservers DISABLED_CompositorObservers
 #define MAYBE_ModifyHierarchy DISABLED_ModifyHierarchy
 #define MAYBE_Opacity DISABLED_Opacity
+#define MAYBE_ScaleUpDown DISABLED_ScaleUpDown
+#define MAYBE_ScaleReparent DISABLED_ScaleReparent
+#define MAYBE_NoScaleCanvas DISABLED_NoScaleCanvas
 #else
 #define MAYBE_Delegate DISABLED_Delegate
 #define MAYBE_Draw Draw
 #define MAYBE_DrawTree DISABLED_DrawTree
 #define MAYBE_Hierarchy Hierarchy
 #define MAYBE_HierarchyNoTexture DISABLED_HierarchyNoTexture
 #define MAYBE_DrawPixels DrawPixels
 #define MAYBE_SetRootLayer SetRootLayer
 #define MAYBE_CompositorObservers DISABLED_CompositorObservers
 #define MAYBE_ModifyHierarchy ModifyHierarchy
 #define MAYBE_Opacity Opacity
+#define MAYBE_ScaleUpDown ScaleUpDown
+#define MAYBE_ScaleReparent ScaleReparent
+#define MAYBE_NoScaleCanvas NoScaleCanvas
 #endif
 
 TEST_F(LayerWithRealCompositorTest, MAYBE_Draw) {
   scoped_ptr<Layer> layer(CreateColorLayer(SK_ColorRED,
                                            gfx::Rect(20, 20, 50, 50)));
   DrawTree(layer.get());
 }
 
 // Create this hierarchy:
 // L1 - red
@@ skipping 20 matching lines @@
 
 class LayerWithDelegateTest : public testing::Test, public CompositorDelegate {
  public:
   LayerWithDelegateTest() : schedule_draw_invoked_(false) {}
   virtual ~LayerWithDelegateTest() {}
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     ui::SetupTestCompositor();
     compositor_.reset(new Compositor(
-          this, gfx::kNullAcceleratedWidget, gfx::Size(1000, 1000)));
+        this, gfx::kNullAcceleratedWidget));
+    compositor_->SetScaleAndSize(1.0f, gfx::Size(1000, 1000));
   }
 
   virtual void TearDown() OVERRIDE {
   }
 
   Compositor* compositor() { return compositor_.get(); }
 
   virtual Layer* CreateLayer(LayerType type) {
     return new Layer(type);
   }
@@ skipping 470 matching lines @@
 
   // Opacity changes should no longer alert the removed observer.
   observer.Reset();
   l2->SetOpacity(0.5f);
   RunPendingMessages();
   EXPECT_FALSE(observer.notified());
 }
 
 // Checks that modifying the hierarchy correctly affects final composite.
 TEST_F(LayerWithRealCompositorTest, MAYBE_ModifyHierarchy) {
-  GetCompositor()->WidgetSizeChanged(gfx::Size(50, 50));
+  GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
   //  | +-l21
   //  +-l12
   scoped_ptr<Layer> l0(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(0, 0, 50, 50)));
   scoped_ptr<Layer> l11(CreateColorLayer(SK_ColorGREEN,
                                          gfx::Rect(0, 0, 25, 25)));
   scoped_ptr<Layer> l21(CreateColorLayer(SK_ColorMAGENTA,
@@ skipping 39 matching lines @@
   l0->StackAbove(l12.get(), l11.get());
   DrawTree(l0.get());
   ASSERT_TRUE(ReadPixels(&bitmap));
   ASSERT_FALSE(bitmap.empty());
   EXPECT_TRUE(IsSameAsPNGFile(bitmap, ref_img1));
 }
 
 // Opacity is rendered correctly.
 // Checks that modifying the hierarchy correctly affects final composite.
 TEST_F(LayerWithRealCompositorTest, MAYBE_Opacity) {
-  GetCompositor()->WidgetSizeChanged(gfx::Size(50, 50));
+  GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
   scoped_ptr<Layer> l0(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(0, 0, 50, 50)));
   scoped_ptr<Layer> l11(CreateColorLayer(SK_ColorGREEN,
                                          gfx::Rect(0, 0, 25, 25)));
 
   FilePath ref_img = test_data_directory().AppendASCII("Opacity.png");
 
@@ skipping 83 matching lines @@
   // ScheduleDraw() should have been invoked.
   EXPECT_TRUE(schedule_draw_invoked_);
   // Because SchedulePaint() was invoked from OnPaintLayer() |child| should
   // still need to be painted.
   DrawTree(root.get());
   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
   EXPECT_TRUE(child_delegate.last_clip_rect().Contains(
                   gfx::Rect(10, 10, 30, 30)));
 }
 
+TEST_F(LayerWithRealCompositorTest, MAYBE_ScaleUpDown) {
+  test::ScopedDIPEnablerForTest enable;
+
+  scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
+                                          gfx::Rect(10, 20, 200, 220)));
+  TestLayerDelegate root_delegate;
+  root_delegate.AddColor(SK_ColorWHITE);
+  root->set_delegate(&root_delegate);
+
+  scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
+                                        gfx::Rect(10, 20, 140, 180)));
+  TestLayerDelegate l1_delegate;
+  l1_delegate.AddColor(SK_ColorWHITE);
+  l1->set_delegate(&l1_delegate);
+
+  GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
+  GetCompositor()->SetRootLayer(root.get());
+  root->Add(l1.get());
+  RunPendingMessages();
+
+  EXPECT_EQ("10,20 200x220", root->bounds().ToString());
+  EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
+  gfx::Size size_in_pixel = root->web_layer().bounds();
+  EXPECT_EQ("200x220", size_in_pixel.ToString());
+  size_in_pixel = l1->web_layer().bounds();
+  EXPECT_EQ("140x180", size_in_pixel.ToString());
+
+  SchedulePaintForLayer(root.get());
+  SchedulePaintForLayer(l1.get());
+  RunPendingMessages();
+
+  EXPECT_EQ("200x220", root_delegate.paint_size().ToString());
+  EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
+
+  // Scale up to 2.0. Changing scale doesn't change the bounds in DIP.
+  GetCompositor()->SetScaleAndSize(2.0f, gfx::Size(500, 500));
+  EXPECT_EQ("10,20 200x220", root->bounds().ToString());
+  EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
+  // Pixel size must have been scaled up.
+  size_in_pixel = root->web_layer().bounds();
+  EXPECT_EQ("400x440", size_in_pixel.ToString());
+  size_in_pixel = l1->web_layer().bounds();
+  EXPECT_EQ("280x360", size_in_pixel.ToString());
+
+  // Canvas size must have been scaled down up.
+  SchedulePaintForLayer(root.get());
+  SchedulePaintForLayer(l1.get());
+  RunPendingMessages();
+  EXPECT_EQ("400x440", root_delegate.paint_size().ToString());
+  EXPECT_EQ("2.0 2.0", root_delegate.ToScaleString());
+  EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
+  EXPECT_EQ("2.0 2.0", l1_delegate.ToScaleString());
+
+  // Scale down back to 1.0f.
+  GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
+  EXPECT_EQ("10,20 200x220", root->bounds().ToString());
+  EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
+  // Pixel size must have been scaled down.
+  size_in_pixel = root->web_layer().bounds();
+  EXPECT_EQ("200x220", size_in_pixel.ToString());
+  size_in_pixel = l1->web_layer().bounds();
+  EXPECT_EQ("140x180", size_in_pixel.ToString());
+
+  // Canvas size must have been scaled down too.
+  SchedulePaintForLayer(root.get());
+  SchedulePaintForLayer(l1.get());
+  RunPendingMessages();
+  EXPECT_EQ("200x220", root_delegate.paint_size().ToString());
+  EXPECT_EQ("1.0 1.0", root_delegate.ToScaleString());
+  EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
+  EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
+}
+
+TEST_F(LayerWithRealCompositorTest, MAYBE_ScaleReparent) {
+  test::ScopedDIPEnablerForTest enable;
+  scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
+                                          gfx::Rect(10, 20, 200, 220)));
+  scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
+                                        gfx::Rect(10, 20, 140, 180)));
+  TestLayerDelegate l1_delegate;
+  l1_delegate.AddColor(SK_ColorWHITE);
+  l1->set_delegate(&l1_delegate);
+
+  GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
+  GetCompositor()->SetRootLayer(root.get());
+  RunPendingMessages();
+
+  root->Add(l1.get());
+  EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
+  gfx::Size size_in_pixel = l1->web_layer().bounds();
+  EXPECT_EQ("140x180", size_in_pixel.ToString());
+
+  SchedulePaintForLayer(l1.get());
+  RunPendingMessages();
+  EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
+  EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
+
+  // Remove l1 from root and change the scale.
+  root->Remove(l1.get());
+  EXPECT_EQ(NULL, l1->parent());
+  EXPECT_EQ(NULL, l1->GetCompositor());
+  GetCompositor()->SetScaleAndSize(2.0f, gfx::Size(500, 500));
+  // Sanity check on root and l1.
+  EXPECT_EQ("10,20 200x220", root->bounds().ToString());
+  size_in_pixel = l1->web_layer().bounds();
+  EXPECT_EQ("140x180", size_in_pixel.ToString());
+
+
+  root->Add(l1.get());
+  EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
+  size_in_pixel = l1->web_layer().bounds();
+  EXPECT_EQ("280x360", size_in_pixel.ToString());
+  SchedulePaintForLayer(l1.get());
+  RunPendingMessages();
+  EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
+  EXPECT_EQ("2.0 2.0", l1_delegate.ToScaleString());
+}
+
+// Tests layer::set_scale_canvas(false).
+TEST_F(LayerWithRealCompositorTest, MAYBE_NoScaleCanvas) {
+  test::ScopedDIPEnablerForTest enable;
+  scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
+                                          gfx::Rect(10, 20, 200, 220)));
+  scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
+                                        gfx::Rect(10, 20, 140, 180)));
+  l1->set_scale_canvas(false);
+  root->Add(l1.get());
+  TestLayerDelegate l1_delegate;
+  l1_delegate.AddColor(SK_ColorWHITE);
+  l1->set_delegate(&l1_delegate);
+
+  GetCompositor()->SetScaleAndSize(2.0f, gfx::Size(500, 500));
+  GetCompositor()->SetRootLayer(root.get());
+
+  SchedulePaintForLayer(l1.get());
+  RunPendingMessages();
+  EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
+  EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
+}
+
 } // namespace ui