cc: 9patch: fix shadow scaling issue

cc/layers/nine_patch_layer_impl_unittest.cc

 // Copyright 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 <stddef.h>
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/nine_patch_layer_impl.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/ui_resource_bitmap.h"
@@ skipping 13 matching lines @@
 namespace cc {
 namespace {
 
 gfx::Rect ToRoundedIntRect(const gfx::RectF& rect_f) {
   return gfx::Rect(gfx::ToRoundedInt(rect_f.x()),
                    gfx::ToRoundedInt(rect_f.y()),
                    gfx::ToRoundedInt(rect_f.width()),
                    gfx::ToRoundedInt(rect_f.height()));
 }
 
+bool ShouldUseOcclusion(const gfx::Size& bitmap_size,

[aelias_OOO_until_Jul13, 2016/05/05 04:17:57]

It's a bad practice to copy-paste production code into a test.  This is moot if
you follow my suggestion above, but I would've suggested instead adding "bool
shouldUseOcclusion" argument to the helper method and have each caller pass it
in depending on the expected result.

[llandwerlin-old, 2016/05/06 16:26:48]

Done.

+                        const gfx::Rect& aperture_rect,
+                        const gfx::Size& layer_size,
+                        const gfx::Rect& border,
+                        const gfx::Rect& occlusion,
+                        bool fill_center) {
+  if (occlusion.IsEmpty())
+    return false;
+
+  if (fill_center)
+    return false;
+
+  if (border.x() == 0 || border.y() == 0 ||
+      (border.width() - border.x()) == 0 || (border.height() - border.y()) == 0)
+    return false;
+
+  if (occlusion.x() == 0 || occlusion.y() == 0 ||
+      occlusion.right() == layer_size.width() ||
+      occlusion.bottom() == layer_size.height())
+    return false;
+
+  return true;
+}
+
 void NinePatchLayerLayoutTest(const gfx::Size& bitmap_size,
                               const gfx::Rect& aperture_rect,
                               const gfx::Size& layer_size,
                               const gfx::Rect& border,
                               const gfx::Rect& occlusion,
                               bool fill_center,
                               size_t expected_quad_size) {
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   gfx::Rect visible_layer_rect(layer_size);
   gfx::Rect expected_layer_remaining;
   gfx::Rect expected_tex_remaining;
 
-  if (!occlusion.IsEmpty()) {
-    expected_layer_remaining = occlusion;
+  if (ShouldUseOcclusion(bitmap_size, aperture_rect, layer_size, border,
+                         occlusion, fill_center)) {
+    expected_layer_remaining.SetRect(

[aelias_OOO_until_Jul13, 2016/05/05 04:17:57]

All this is too much logic for a test, this makes it difficult to reason about
what the test is intending to check.  Please just write in literal values for
the output of this algorithm instead.  This probably calls for creating a new
helper method NinePatchLayerLayoutWithOcclusionTest() that takes more arguments.

[llandwerlin-old, 2016/05/06 16:26:48]

Done.

+        std::min(border.x(), occlusion.x()),
+        std::min(border.y(), occlusion.y()),
+        std::max(layer_size.width() - border.width(), occlusion.width()),
+        std::max(layer_size.height() - border.height(), occlusion.height()));
+    float ratio_left = aperture_rect.x() / border.x(),
+          ratio_top = aperture_rect.y() / border.y(),
+          ratio_right = (bitmap_size.width() - aperture_rect.right()) /
+                        (border.width() - border.x()),
+          ratio_bottom = (bitmap_size.height() - aperture_rect.bottom()) /
+                         (border.height() - border.y());
+    int image_remaining_left = expected_layer_remaining.x() * ratio_left,
+        image_remaining_top = expected_layer_remaining.y() * ratio_top,
+        image_remaining_right =
+            (layer_size.width() - expected_layer_remaining.right()) *
+            ratio_right,
+        image_remaining_bottom =
+            (layer_size.height() - expected_layer_remaining.bottom()) *
+            ratio_bottom;
     expected_tex_remaining.SetRect(
-        occlusion.x(), occlusion.y(),
-        (bitmap_size.width() - occlusion.x()) -
-            (layer_size.width() - occlusion.right()),
-        (bitmap_size.height() - occlusion.y()) -
-            (layer_size.height() - occlusion.bottom()));
+        image_remaining_left, image_remaining_top,
+        bitmap_size.width() - image_remaining_right - image_remaining_left,
+        bitmap_size.height() - image_remaining_bottom - image_remaining_top);
   } else {
     expected_layer_remaining.SetRect(border.x(), border.y(),
                                      layer_size.width() - border.width(),
                                      layer_size.height() - border.height());
     expected_tex_remaining = aperture_rect;
   }
 
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
@@ skipping 88 matching lines @@
   layer_size = gfx::Size(100, 100);
   aperture_rect = gfx::Rect(20, 30, 40, 50);
   border = gfx::Rect(20, 30, 40, 50);
   fill_center = true;
   expected_quad_size = 9;
   NinePatchLayerLayoutTest(bitmap_size, aperture_rect, layer_size, border,
                            gfx::Rect(), fill_center, expected_quad_size);
 }
 
 TEST(NinePatchLayerImplTest, VerifyDrawQuadsWithOcclusion) {
-  // Input is a 100x100 bitmap with a 40x50 aperture at x=20, y=30.
+  // Input is a 100x100 bitmap with a 40x40 aperture at x=30, y=30.
   // The bounds of the layer are set to 400x400.
   gfx::Size bitmap_size(100, 100);
   gfx::Rect aperture_rect(30, 30, 40, 40);
   gfx::Size layer_size(400, 400);
   gfx::Rect occlusion(20, 20, 360, 360);
+  gfx::Rect border(30, 30, 60, 60);
   bool fill_center = false;
   size_t expected_quad_size = 12;
-  NinePatchLayerLayoutTest(bitmap_size, aperture_rect, layer_size, gfx::Rect(),
+  NinePatchLayerLayoutTest(bitmap_size, aperture_rect, layer_size, border,
+                           occlusion, fill_center, expected_quad_size);
+
+  bitmap_size = gfx::Size(100, 100);
+  aperture_rect = gfx::Rect(0, 0, 100, 100);
+  layer_size = gfx::Size(400, 400);
+  occlusion = gfx::Rect(20, 20, 360, 360);
+  border = gfx::Rect(0, 0, 0, 0);
+  fill_center = false;
+  expected_quad_size = 0;
+  NinePatchLayerLayoutTest(bitmap_size, aperture_rect, layer_size, border,
+                           occlusion, fill_center, expected_quad_size);
+
+  bitmap_size = gfx::Size(100, 100);
+  aperture_rect = gfx::Rect(20, 30, 60, 40);
+  layer_size = gfx::Size(400, 400);
+  occlusion = gfx::Rect(10, 10, 380, 380);
+  border = gfx::Rect(20, 30, 360, 340);
+  fill_center = false;
+  expected_quad_size = 12;
+  NinePatchLayerLayoutTest(bitmap_size, aperture_rect, layer_size, border,
                            occlusion, fill_center, expected_quad_size);
 }
 
 TEST(NinePatchLayerImplTest, VerifyDrawQuadsWithEmptyPatches) {
   // The top component of the 9-patch is empty, so there should be no quads for
   // the top three components.
   gfx::Size bitmap_size(100, 100);
   gfx::Size layer_size(100, 100);
   gfx::Rect aperture_rect(10, 0, 80, 90);
   gfx::Rect border(10, 0, 20, 10);
@@ skipping 154 matching lines @@
 
     const QuadList &quad_list = impl.quad_list();
     for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
          it != quad_list.BackToFrontEnd(); ++it)
       EXPECT_TRUE(it->ShouldDrawWithBlending());
   }
 }
 
 }  // namespace
 }  // namespace cc