Add SurfaceWillDraw notification

cc/surfaces/surface_aggregator_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/surfaces/surface_aggregator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/local_surface_id_allocator.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/test/compositor_frame_helpers.h"
 #include "cc/test/fake_compositor_frame_sink_support_client.h"
 #include "cc/test/fake_resource_provider.h"
+#include "cc/test/fake_surface_observer.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/test/surface_aggregator_test_helpers.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace cc {
 namespace {
 
@@ skipping 16 matching lines @@
 }
 
 gfx::Size SurfaceSize() {
   static gfx::Size size(100, 100);
   return size;
 }
 
 class SurfaceAggregatorTest : public testing::Test {
  public:
   explicit SurfaceAggregatorTest(bool use_damage_rect)
-      : support_(
+      : observer_(false),
+        support_(
             CompositorFrameSinkSupport::Create(&fake_client_,
                                                &manager_,
                                                kArbitraryRootFrameSinkId,
                                                kRootIsRoot,
                                                kHandlesFrameSinkIdInvalidation,
                                                kNeedsSyncPoints)),
-        aggregator_(&manager_, NULL, use_damage_rect) {}
+        aggregator_(&manager_, NULL, use_damage_rect) {
+    manager_.AddObserver(&observer_);
+  }
 
   SurfaceAggregatorTest() : SurfaceAggregatorTest(false) {}
 
   void TearDown() override {
+    observer_.Reset();
     support_->EvictCurrentSurface();
     testing::Test::TearDown();
   }
 
  protected:
   SurfaceManager manager_;
+  FakeSurfaceObserver observer_;
   FakeCompositorFrameSinkSupportClient fake_client_;
   std::unique_ptr<CompositorFrameSinkSupport> support_;
   SurfaceAggregator aggregator_;
 };
 
 class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {
  public:
   explicit SurfaceAggregatorValidSurfaceTest(bool use_damage_rect)
       : SurfaceAggregatorTest(use_damage_rect),
         child_support_(
@@ skipping 89 matching lines @@
                         root_local_surface_id_);
 
   SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
   SurfaceId ids[] = {root_surface_id};
 
   AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids));
 
   // Check that WillDrawSurface was called.
   EXPECT_EQ(gfx::Rect(SurfaceSize()), fake_client_.last_damage_rect());
   EXPECT_EQ(root_local_surface_id_, fake_client_.last_local_surface_id());
+
+  // Check that SurfaceObserver::OnSurfaceWillDraw was called.
+  EXPECT_TRUE(observer_.SurfaceWillDrawCalled(root_surface_id));
 }
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) {
   std::unique_ptr<CompositorFrameSinkSupport> embedded_support(
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId1, kRootIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
   LocalSurfaceId embedded_local_surface_id = allocator_.GenerateId();
   SurfaceId embedded_surface_id(embedded_support->frame_sink_id(),
                                 embedded_local_surface_id);
@@ skipping 187 matching lines @@
   test::Quad expected_quads1[] = {test::Quad::SolidColorQuad(SK_ColorRED)};
   test::Pass expected_passes1[] = {
       test::Pass(expected_quads1, arraysize(expected_quads1))};
 
   SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
   SurfaceId ids[] = {root_surface_id, primary_child_surface_id,
                      fallback_child_surface_id};
   AggregateAndVerify(expected_passes1, arraysize(expected_passes1), ids,
                      arraysize(ids));
 
+  // Check that SurfaceObserver::OnSurfaceWillDraw was called only
+  // for the fallback surface.
+  EXPECT_FALSE(observer_.SurfaceWillDrawCalled(primary_child_surface_id));
+  EXPECT_TRUE(observer_.SurfaceWillDrawCalled(fallback_child_surface_id));
+
+  observer_.Reset();
+
   test::Quad primary_child_quads[] = {
       test::Quad::SolidColorQuad(SK_ColorGREEN)};
   test::Pass primary_child_passes[] = {
       test::Pass(primary_child_quads, arraysize(primary_child_quads))};
 
   // Submit a CompositorFrame to the primary Surface containing a green
   // SolidColorDrawQuad.
   SubmitCompositorFrame(primary_child_support.get(), primary_child_passes,
                         arraysize(primary_child_passes),
                         primary_child_local_surface_id);
 
   // Now that the primary Surface has a CompositorFrame, we expect
   // SurfaceAggregator to embed the primary Surface, and drop the fallback
   // Surface.
   test::Quad expected_quads2[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
   test::Pass expected_passes2[] = {
       test::Pass(expected_quads2, arraysize(expected_quads2))};
   AggregateAndVerify(expected_passes2, arraysize(expected_passes2), ids,
                      arraysize(ids));
 
+  // Check that SurfaceObserver::OnSurfaceWillDraw was called only
+  // for the primary surface.
+  EXPECT_TRUE(observer_.SurfaceWillDrawCalled(primary_child_surface_id));
+  EXPECT_FALSE(observer_.SurfaceWillDrawCalled(fallback_child_surface_id));
+
   primary_child_support->EvictCurrentSurface();
   fallback_child_support->EvictCurrentSurface();
 }
 
 // This test verifies that in the presence of both primary Surface and fallback
 // Surface, the fallback will not be used.
 TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReferenceWithPrimary) {
   std::unique_ptr<CompositorFrameSinkSupport> primary_child_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId1, kChildIsRoot,
@@ skipping 1842 matching lines @@
   aggregated_frame = aggregator_.Aggregate(surface_id);
   EXPECT_EQ(3u, aggregated_frame.render_pass_list.size());
   EXPECT_EQ(color_space1, aggregated_frame.render_pass_list[0]->color_space);
   EXPECT_EQ(color_space1, aggregated_frame.render_pass_list[1]->color_space);
   EXPECT_EQ(color_space3, aggregated_frame.render_pass_list[2]->color_space);
 }
 
 }  // namespace
 }  // namespace cc