Remove unittests based on wrong assumption of 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/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 492 matching lines @@
   EXPECT_EQ(point1_in_l1_coords, point1_in_l3_coords);
 
   gfx::Point point2_in_l1_coords(5, 5);
   Layer::ConvertPointToLayer(l1.get(), l3.get(), &point2_in_l1_coords);
   gfx::Point point2_in_l3_coords(-15, -15);
   EXPECT_EQ(point2_in_l3_coords, point2_in_l1_coords);
 }
 
 TEST_F(LayerWithRealCompositorTest, Delegate) {
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorBLACK,
-                                        gfx::Rect(20, 20, 400, 400)));
+                                        gfx::Rect(20, 20, 1000, 1000)));
   GetCompositor()->SetRootLayer(l1.get());
   WaitForDraw();
 
   TestLayerDelegate delegate;
   l1->set_delegate(&delegate);
   delegate.AddColor(SK_ColorWHITE);
   delegate.AddColor(SK_ColorYELLOW);
   delegate.AddColor(SK_ColorGREEN);
 
-  l1->SchedulePaint(gfx::Rect(0, 0, 400, 400));
+  l1->SchedulePaint(gfx::Rect(0, 0, 1000, 1000));
   WaitForDraw();
 
   EXPECT_EQ(delegate.color_index(), 1);
-  EXPECT_EQ(delegate.paint_size(), l1->bounds().size());
+  EXPECT_EQ(delegate.paint_size(), gfx::Size(1030, 1030));

[danakj, 2015/03/03 17:57:05]

This bakes in cc internal knowledge into these numbers, I think it's enough to
say that this on the paint Contains the layer, and the other ones, the paints do
not Contain the layer.

Also btw this was wrong here, but EXPECT(expected, actual), this is backward.

[weiliangc, 2015/03/04 01:23:57]

paint_size() still used here.

(also time to test my regex power)

[weiliangc, 2015/03/06 20:42:46]

paint_size still needed here, since canvas rect won't have information for
(top,left) position, the paint rect won't contain layer bounds w/o impl-side.

 
-  l1->SchedulePaint(gfx::Rect(10, 10, 200, 200));
+  l1->SchedulePaint(gfx::Rect(10, 10, 600, 600));
   WaitForDraw();
   EXPECT_EQ(delegate.color_index(), 2);
-  EXPECT_EQ(delegate.paint_size(), gfx::Size(200, 200));
+  EXPECT_EQ(delegate.paint_size(), gfx::Size(1009, 1009));
 
   l1->SchedulePaint(gfx::Rect(5, 5, 50, 50));
   WaitForDraw();
   EXPECT_EQ(delegate.color_index(), 0);
-  EXPECT_EQ(delegate.paint_size(), gfx::Size(50, 50));
+  EXPECT_EQ(delegate.paint_size(), gfx::Size(527, 527));
 }
 
 TEST_F(LayerWithRealCompositorTest, DrawTree) {
   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)));
   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
                                         gfx::Rect(10, 10, 100, 100)));
   l1->Add(l2.get());
@@ skipping 753 matching lines @@
   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   gfx::Size cc_bounds_size = root->cc_layer()->bounds();
   EXPECT_EQ("200x220", cc_bounds_size.ToString());
   cc_bounds_size = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", cc_bounds_size.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());
 
-  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());
   // CC layer should still match the UI layer bounds.
   cc_bounds_size = root->cc_layer()->bounds();
   EXPECT_EQ("200x220", cc_bounds_size.ToString());
   cc_bounds_size = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", cc_bounds_size.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.
   WaitForDraw();
-  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());
   // CC layer should still match the UI layer bounds.
   cc_bounds_size = root->cc_layer()->bounds();
   EXPECT_EQ("200x220", cc_bounds_size.ToString());
   cc_bounds_size = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", cc_bounds_size.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.
   WaitForDraw();
-  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 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());
@@ skipping 17 matching lines @@
   GetCompositor()->SetRootLayer(root.get());
   WaitForDraw();
 
   root->Add(l1.get());
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   gfx::Size cc_bounds_size = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", cc_bounds_size.ToString());
   EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
 
   WaitForDraw();
-  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());
   cc_bounds_size = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", cc_bounds_size.ToString());
 
   root->Add(l1.get());
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   cc_bounds_size = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", cc_bounds_size.ToString());
   EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
   WaitForDraw();
-  EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
-  EXPECT_EQ("2.0 2.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) {
   scoped_ptr<Layer> root(CreateNoTextureLayer(gfx::Rect(0, 0, 1000, 1000)));
 
   scoped_ptr<Layer> child(CreateLayer(LAYER_TEXTURED));
@@ skipping 346 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