Implement HiDPI and pinch-zoom scaling of filter params

cc/layers/render_surface_impl_unittest.cc

 // Copyright 2014 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 "cc/layers/render_surface_impl.h"
 
+#include "cc/layers/append_quads_data.h"
+#include "cc/layers/content_layer.h"
 #include "cc/test/layer_test_common.h"
+#include "cc/test/layer_tree_pixel_test.h"
+#include "cc/test/solid_color_content_layer_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 TEST(RenderSurfaceLayerImplTest, Occlusion) {
   gfx::Size layer_size(1000, 1000);
   gfx::Size viewport_size(1000, 1000);
 
   LayerTestCommon::LayerImplTest impl;
@@ skipping 38 matching lines @@
         impl.quad_list(),
         gfx::Rect(layer_size),
         occluded,
         &partially_occluded_count);
     // The layer outputs one quad, which is partially occluded.
     EXPECT_EQ(1u, impl.quad_list().size());
     EXPECT_EQ(1u, partially_occluded_count);
   }
 }
 
+class RenderSurfaceImplHiDpiTest : public LayerTreePixelTest {
+ protected:
+  RenderSurfaceImplHiDpiTest()
+      : device_scale_factor_(1.f),
+        content_size_(100),
+        background_client_(SK_ColorWHITE),
+        green_client_(SK_ColorGREEN),
+        blue_client_(SK_ColorBLUE) {}
+
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    // Required so that device scale is inherited by content scale.
+    settings->layer_transforms_should_scale_layer_contents = true;
+  }
+
+  virtual void SetupTree() OVERRIDE {
+    layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
+    LayerTreePixelTest::SetupTree();
+  }
+
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
+
+    LayerImpl* layer_impl = root_impl->children()[0];
+    layer_impl->CreateRenderSurface();
+    layer_impl->draw_properties().render_target = layer_impl;
+
+    RenderSurfaceImpl* render_surface = layer_impl->render_surface();
+    render_surface->SetContentRect(layer_impl->visible_content_rect());
+    render_surface->SetClipRect(layer_impl->clip_rect());
+    render_surface->SetDrawOpacity(1.f);
+
+    MockOcclusionTracker<LayerImpl> occlusion_tracker;
+    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+    AppendQuadsData append_quads_data;
+    render_surface->AppendQuads(render_pass.get(),
+                                occlusion_tracker,
+                                &append_quads_data,
+                                false,
+                                RenderPass::Id(2, 0));
+
+    ASSERT_EQ(1u, render_pass->shared_quad_state_list.size());
+    SharedQuadState* quad_state = render_pass->shared_quad_state_list[0];
+
+    int expected_size = content_size_ * device_scale_factor_;
+    ASSERT_EQ(expected_size, quad_state->content_bounds.width());
+    ASSERT_EQ(expected_size, quad_state->content_bounds.height());
+  }
+
+  void RunDpiTest(int content_size, float device_scale_factor) {
+    content_size_ = content_size;
+    int half_content = content_size / 2;
+
+    scoped_refptr<ContentLayer> background =
+        ContentLayer::Create(&background_client_);
+    background->SetBounds(gfx::Size(content_size, content_size));
+    background->SetIsDrawable(true);
+
+    scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
+    green->SetBounds(gfx::Size(content_size, content_size));
+    green->SetIsDrawable(true);
+    background->AddChild(green);
+
+    scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
+    blue->SetBounds(gfx::Size(half_content, half_content));
+    blue->SetPosition(gfx::Point(half_content, half_content));
+    blue->SetIsDrawable(true);
+    green->AddChild(blue);
+
+    device_scale_factor_ = device_scale_factor;
+
+    this->impl_side_painting_ = false;
+    RunPixelTest(
+        SOFTWARE_WITH_DEFAULT,
+        background,
+        base::FilePath(FILE_PATH_LITERAL("green_small_with_blue_corner.png")));
+  }
+
+  float device_scale_factor_;
+  int content_size_;
+  SolidColorContentLayerClient background_client_;
+  SolidColorContentLayerClient green_client_;
+  SolidColorContentLayerClient blue_client_;
+};
+
+TEST_F(RenderSurfaceImplHiDpiTest, TestStandardDpi) {
+  RunDpiTest(100, 1.f);
+}
+
+TEST_F(RenderSurfaceImplHiDpiTest, TestHiDpi) {
+  RunDpiTest(50, 2.f);
+}
+
 }  // namespace
 }  // namespace cc