Notification for device scale factor change

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"
@@ skipping 114 matching lines @@
     set_delegate(this);
   }
 
   virtual ~ColoredLayer() { }
 
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     canvas->DrawColor(color_);
   }
 
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+  }
+
  private:
   SkColor color_;
 };
 
 class LayerWithRealCompositorTest : public testing::Test {
  public:
   LayerWithRealCompositorTest() {
     if (PathService::Get(gfx::DIR_TEST_DATA, &test_data_directory_)) {
       test_data_directory_ = test_data_directory_.AppendASCII("compositor");
     } else {
@@ skipping 60 matching lines @@
 
   // The root directory for test files.
   FilePath test_data_directory_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerWithRealCompositorTest);
 };
 
 // LayerDelegate that paints colors to the layer.
 class TestLayerDelegate : public LayerDelegate {
  public:
-  explicit TestLayerDelegate() : color_index_(0) {}
+  explicit TestLayerDelegate() { reset(); }
   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_);
   }
 
+  float device_scale_factor() const {
+    return device_scale_factor_;
+  }
+
   // 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();
   }
 
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+    device_scale_factor_ = device_scale_factor;
+  }
+
   void reset() {
     color_index_ = 0;
     paint_size_.SetSize(0, 0);
     scale_x_ = scale_y_ = 0.0f;
+    device_scale_factor_ = 0.0f;
   }
 
  private:
   std::vector<SkColor> colors_;
   int color_index_;
   gfx::Size paint_size_;
   float scale_x_;
   float scale_y_;
+  float device_scale_factor_;
 
   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() {}
 
   void Reset() {
     painted_ = false;
   }
 
   bool painted() const { return painted_; }
 
  private:
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     painted_ = true;
   }
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+  }
 
   bool painted_;
 
   DISALLOW_COPY_AND_ASSIGN(DrawTreeLayerDelegate);
 };
 
 // The simplest possible layer delegate. Does nothing.
 class NullLayerDelegate : public LayerDelegate {
  public:
   NullLayerDelegate() {}
   virtual ~NullLayerDelegate() {}
 
  private:
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
   }
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+  }
 
   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 };
 
 // Remembers if it has been notified.
 class TestCompositorObserver : public CompositorObserver {
  public:
   TestCompositorObserver() : started_(false), ended_(false) {}
 
   bool notified() const { return started_ && ended_; }
@@ skipping 694 matching lines @@
     paint_count_++;
     if (!schedule_paint_rect_.IsEmpty()) {
       layer_->SchedulePaint(schedule_paint_rect_);
       schedule_paint_rect_ = gfx::Rect();
     }
     SkRect sk_clip_rect;
     if (canvas->sk_canvas()->getClipBounds(&sk_clip_rect))
       last_clip_rect_ = gfx::SkRectToRect(sk_clip_rect);
   }
 
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
+  }
+
   int paint_count_;
   Layer* layer_;
   gfx::Rect schedule_paint_rect_;
   gfx::Rect last_clip_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulePaintLayerDelegate);
 };
 
 }  // namespace
 
@@ skipping 51 matching lines @@
   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());
+  // No scale change, so no scale notification.
+  EXPECT_EQ(0.0f, root_delegate.device_scale_factor());
+  EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
 
   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());
+  // New scale factor must have been notified.
+  EXPECT_EQ(2.0f, root_delegate.device_scale_factor());
+  EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
 
   // Canvas size must have been scaled down up.
   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());
+  // New scale factor must have been notified.
+  EXPECT_EQ(1.0f, root_delegate.device_scale_factor());
+  EXPECT_EQ(1.0f, l1_delegate.device_scale_factor());
 
   // Canvas size must have been scaled down too.
   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());
 
   root_delegate.reset();
   l1_delegate.reset();
-  // Just changing the size shouldn't trigger repaint.
+  // Just changing the size shouldn't notify the scale change nor
+  // trigger repaint.
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(1000, 1000));
+  // No scale change, so no scale notification.
+  EXPECT_EQ(0.0f, root_delegate.device_scale_factor());
+  EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
   RunPendingMessages();
   EXPECT_EQ("0x0", root_delegate.paint_size().ToString());
   EXPECT_EQ("0.0 0.0", root_delegate.ToScaleString());
   EXPECT_EQ("0x0", l1_delegate.paint_size().ToString());
   EXPECT_EQ("0.0 0.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());
+  EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
 
   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());
+  EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
   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());
+  // Scale factor change is notified regardless of scale_canvas flag.
+  EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
+
   RunPendingMessages();
   EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
   EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
 }
 
 // Verifies that when changing bounds on a layer that is invisible, and then
 // made visible, the right thing happens:
 // - if just a move, then no painting should happen.
 // - if a resize, the layer should be repainted.
 TEST_F(LayerWithDelegateTest, SetBoundsWhenInvisible) {
@@ skipping 30 matching lines @@
 
   // Resize layer.
   child->SetBounds(gfx::Rect(200, 200, 400, 400));
   child->SetVisible(true);
   EXPECT_TRUE(schedule_draw_invoked_);
   DrawTree(root.get());
   EXPECT_TRUE(delegate.painted());
 }
 
 } // namespace ui