Respect window transparency when applying window shape.

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/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 829 matching lines @@
 
   // The CompositorDelegate (us) should have been told to draw for a move.
   WaitForDraw();
 
   l1->SetBounds(gfx::Rect(5, 5, 100, 100));
 
   // The CompositorDelegate (us) should have been told to draw for a resize.
   WaitForDraw();
 }
 
+void ExpectRgba(int x, int y, SkColor actual_color, SkColor expected_color) {

[danakj, 2014/09/03 19:39:05]

please pass expected first, to match EXPECT_EQ ordering

+  EXPECT_EQ(expected_color, actual_color)
+      << "Pixel error at x=" << x << " y=" << y << "; "
+      << "actual RGBA=("
+      << SkColorGetR(actual_color) << ","
+      << SkColorGetG(actual_color) << ","
+      << SkColorGetB(actual_color) << ","
+      << SkColorGetA(actual_color) << "); "
+      << "expected RGBA=("
+      << SkColorGetR(expected_color) << ","
+      << SkColorGetG(expected_color) << ","
+      << SkColorGetB(expected_color) << ","
+      << SkColorGetA(expected_color) << ")";
+}
+
 // Checks that pixels are actually drawn to the screen with a read back.
 TEST_F(LayerWithRealCompositorTest, DrawPixels) {
   gfx::Size viewport_size = GetCompositor()->size();
 
   // The window should be some non-trivial size but may not be exactly
   // 500x500 on all platforms/bots.
   EXPECT_GE(viewport_size.width(), 200);
   EXPECT_GE(viewport_size.height(), 200);
 
   int blue_height = 10;
@@ skipping 10 matching lines @@
 
   SkBitmap bitmap;
   ASSERT_TRUE(ReadPixels(&bitmap, gfx::Rect(viewport_size)));
   ASSERT_FALSE(bitmap.empty());
 
   SkAutoLockPixels lock(bitmap);
   for (int x = 0; x < viewport_size.width(); x++) {
     for (int y = 0; y < viewport_size.height(); y++) {
       SkColor actual_color = bitmap.getColor(x, y);
       SkColor expected_color = y < blue_height ? SK_ColorBLUE : SK_ColorRED;
-      EXPECT_EQ(expected_color, actual_color)
-          << "Pixel error at x=" << x << " y=" << y << "; "
-          << "actual RGBA=("
-          << SkColorGetR(actual_color) << ","
-          << SkColorGetG(actual_color) << ","
-          << SkColorGetB(actual_color) << ","
-          << SkColorGetA(actual_color) << "); "
-          << "expected RGBA=("
-          << SkColorGetR(expected_color) << ","
-          << SkColorGetG(expected_color) << ","
-          << SkColorGetB(expected_color) << ","
-          << SkColorGetA(expected_color) << ")";
+      ExpectRgba(x, y, actual_color, expected_color);
     }
   }
 }
+
+// Checks that drawing a layer with transparent pixels is blended correctly
+// with the lower layer.
+TEST_F(LayerWithRealCompositorTest, DrawAlphaBlendedPixels) {
+  gfx::Size viewport_size = GetCompositor()->size();
+
+  int test_size = 200;
+  EXPECT_GE(viewport_size.width(), test_size);
+  EXPECT_GE(viewport_size.height(), test_size);
+
+  // Blue with a wee bit of transparency.
+  SkColor blue_with_alpha = SkColorSetARGBInline(40, 10, 20, 200);
+  SkColor blend_color = SkColorSetARGBInline(255, 216, 3, 32);
+
+  scoped_ptr<Layer> background_layer(
+      CreateColorLayer(SK_ColorRED, gfx::Rect(viewport_size)));
+  scoped_ptr<Layer> foreground_layer(
+      CreateColorLayer(blue_with_alpha, gfx::Rect(viewport_size)));
+
+  // This must be set to false for layers with alpha to be blended correctly.
+  foreground_layer->SetFillsBoundsOpaquely(false);
+
+  background_layer->Add(foreground_layer.get());
+  DrawTree(background_layer.get());
+
+  SkBitmap bitmap;
+  ASSERT_TRUE(ReadPixels(&bitmap, gfx::Rect(viewport_size)));
+  ASSERT_FALSE(bitmap.empty());
+
+  SkAutoLockPixels lock(bitmap);
+  for (int x = 0; x < test_size; x++) {
+    for (int y = 0; y < test_size; y++) {
+      SkColor actual_color = bitmap.getColor(x, y);
+      ExpectRgba(x, y, actual_color, blend_color);
+    }
+  }
+}
+
+// Checks that using the AlphaShape filter applied to a layer with
+// transparency, alpha-blends properly with the layer below.
+TEST_F(LayerWithRealCompositorTest, DrawAlphaThresholdFilterPixels) {
+  gfx::Size viewport_size = GetCompositor()->size();
+
+  int test_size = 200;
+  EXPECT_GE(viewport_size.width(), test_size);
+  EXPECT_GE(viewport_size.height(), test_size);
+
+  int blue_height = 10;
+  SkColor blue_with_alpha = SkColorSetARGBInline(40, 0, 0, 255);
+  SkColor blend_color = SkColorSetARGBInline(255, 215, 0, 40);
+
+  scoped_ptr<Layer> background_layer(
+      CreateColorLayer(SK_ColorRED, gfx::Rect(viewport_size)));
+  scoped_ptr<Layer> foreground_layer(
+      CreateColorLayer(blue_with_alpha, gfx::Rect(viewport_size)));
+
+  // Add a shape to restrict the visible part of the layer.
+  SkRegion shape;
+  shape.setRect(0, 0, viewport_size.width(), blue_height);
+  foreground_layer->SetAlphaShape(make_scoped_ptr(new SkRegion(shape)));
+
+  foreground_layer->SetFillsBoundsOpaquely(false);
+
+  background_layer->Add(foreground_layer.get());
+  DrawTree(background_layer.get());
+
+  SkBitmap bitmap;
+  ASSERT_TRUE(ReadPixels(&bitmap, gfx::Rect(viewport_size)));
+  ASSERT_FALSE(bitmap.empty());
+
+  SkAutoLockPixels lock(bitmap);
+  for (int x = 0; x < test_size; x++) {
+    for (int y = 0; y < test_size; y++) {
+      SkColor actual_color = bitmap.getColor(x, y);
+      ExpectRgba(x, y, actual_color,
+                 y < blue_height ? blend_color : SK_ColorRED);
+    }
+  }
+}
 
 // Checks the logic around Compositor::SetRootLayer and Layer::SetCompositor.
 TEST_F(LayerWithRealCompositorTest, SetRootLayer) {
   Compositor* compositor = GetCompositor();
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(20, 20, 400, 400)));
   scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
                                         gfx::Rect(10, 10, 350, 350)));
 
   EXPECT_EQ(NULL, l1->GetCompositor());
@@ skipping 734 matching lines @@
                                      MakeFrameData(gfx::Size(10, 10))));
   layer->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
 
   EXPECT_FALSE(delegate.delegated_frame_damage_called());
   layer->OnDelegatedFrameDamage(damage_rect);
   EXPECT_TRUE(delegate.delegated_frame_damage_called());
   EXPECT_EQ(damage_rect, delegate.delegated_frame_damage_rect());
 }
 
 }  // namespace ui