cc: Plumbing for BeginFrameSource based on Surfaces

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/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.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"
@@ skipping 25 matching lines @@
 }
 
 gfx::Size SurfaceSize() {
   static gfx::Size size(5, 5);
   return size;
 }
 
 class EmptySurfaceFactoryClient : public SurfaceFactoryClient {
  public:
   void ReturnResources(const ReturnedResourceArray& resources) override {}
+  void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {}
+};
+
+class FakeSurfaceAggregatorClient : public SurfaceAggregatorClient {
+ public:
+  void AddSurface(Surface* surface) override {
+    EXPECT_FALSE(HasSurface(surface));
+    surfaces_.insert(surface);
+  }
+
+  void RemoveSurface(Surface* surface) override {
+    EXPECT_TRUE(HasSurface(surface));
+    surfaces_.erase(surface);
+  }
+
+  bool HasSurface(Surface* surface) const {
+    return surfaces_.count(surface) != 0;
+  }
+
+ private:
+  std::set<Surface*> surfaces_;
 };
 
 class SurfaceAggregatorTest : public testing::Test {
  public:
   explicit SurfaceAggregatorTest(bool use_damage_rect)
       : factory_(&manager_, &empty_client_),
-        aggregator_(&manager_, NULL, use_damage_rect) {}
+        aggregator_(&surface_aggregator_client_,
+                    &manager_,
+                    NULL,
+                    use_damage_rect) {}
 
   SurfaceAggregatorTest() : SurfaceAggregatorTest(false) {}
 
  protected:
   SurfaceManager manager_;
   EmptySurfaceFactoryClient empty_client_;
   SurfaceFactory factory_;
+  FakeSurfaceAggregatorClient surface_aggregator_client_;
   SurfaceAggregator aggregator_;
 };
 
 TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {
   SurfaceId one_id(7);
   factory_.Create(one_id);
+  Surface* surface = manager_.GetSurfaceForId(one_id);
+
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface));
   scoped_ptr<CompositorFrame> frame = aggregator_.Aggregate(one_id);
   EXPECT_FALSE(frame);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface));
+
   factory_.Destroy(one_id);
 }
 
 class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {
  public:
   explicit SurfaceAggregatorValidSurfaceTest(bool use_damage_rect)
       : SurfaceAggregatorTest(use_damage_rect),
         allocator_(1u),
         child_allocator_(2u) {}
   SurfaceAggregatorValidSurfaceTest()
       : SurfaceAggregatorValidSurfaceTest(false) {}
 
   void SetUp() override {
     SurfaceAggregatorTest::SetUp();
     root_surface_id_ = allocator_.GenerateId();
     factory_.Create(root_surface_id_);
+    root_surface_ = manager_.GetSurfaceForId(root_surface_id_);
   }
 
   void TearDown() override {
     factory_.Destroy(root_surface_id_);
     SurfaceAggregatorTest::TearDown();
   }
 
   void AggregateAndVerify(test::Pass* expected_passes,
                           size_t expected_pass_count,
                           SurfaceId* surface_ids,
@@ skipping 50 matching lines @@
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
     child_frame->delegated_frame_data = delegated_frame_data.Pass();
 
     factory_.SubmitCompositorFrame(surface_id, child_frame.Pass(),
                                    SurfaceFactory::DrawCallback());
   }
 
  protected:
   SurfaceId root_surface_id_;
+  Surface* root_surface_;
   SurfaceIdAllocator allocator_;
   SurfaceIdAllocator child_allocator_;
 };
 
 // Tests that a very simple frame containing only two solid color quads makes it
 // through the aggregator correctly.
 TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleFrame) {
   test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorRED),
                         test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 
   SubmitCompositorFrame(passes, arraysize(passes), root_surface_id_);
 
   SurfaceId ids[] = {root_surface_id_};
+
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
 }
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) {
   SurfaceId embedded_surface_id = allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
+  Surface* embedded_surface = manager_.GetSurfaceForId(embedded_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
 
   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
                                  test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass embedded_passes[] = {
       test::Pass(embedded_quads, arraysize(embedded_quads))};
 
   SubmitCompositorFrame(embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
 
   test::Quad quads[] = {test::Quad::SurfaceQuad(embedded_surface_id, .5f)};
   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 
   SubmitCompositorFrame(passes, arraysize(passes), root_surface_id_);
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));

[mithro-old, 2015/10/01 03:00:24]

Thanks for adding these!

I wonder if would be a good idea to have some type of macro here? It doesn't
seem worth it for two EXPECT_FALSE / EXPECT_TRUE but might be if there are more
in the future?

[brianderson, 2015/10/07 20:54:48]

Might do it as a followup patch since I can't think of a good macro that isn't
overly complicated right now.

+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   RenderPassList& render_pass_list(frame_data->render_pass_list);
   ASSERT_EQ(2u, render_pass_list.size());
   SharedQuadStateList& shared_quad_state_list(
       render_pass_list[0]->shared_quad_state_list);
   ASSERT_EQ(2u, shared_quad_state_list.size());
@@ skipping 13 matching lines @@
                             test::Quad::SolidColorQuad(SK_ColorLTGRAY)},
                            {test::Quad::SolidColorQuad(SK_ColorGRAY),
                             test::Quad::SolidColorQuad(SK_ColorDKGRAY)}};
   test::Pass passes[] = {
       test::Pass(quads[0], arraysize(quads[0]), RenderPassId(1, 1)),
       test::Pass(quads[1], arraysize(quads[1]), RenderPassId(1, 2))};
 
   SubmitCompositorFrame(passes, arraysize(passes), root_surface_id_);
 
   SurfaceId ids[] = {root_surface_id_};
+
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
 }
 
 // This tests very simple embedding. root_surface has a frame containing a few
 // solid color quads and a surface quad referencing embedded_surface.
 // embedded_surface has a frame containing only a solid color quad. The solid
 // color quad should be aggregated into the final frame.
 TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleSurfaceReference) {
   SurfaceId embedded_surface_id = allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
+  Surface* embedded_surface = manager_.GetSurfaceForId(embedded_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
 
   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
   test::Pass embedded_passes[] = {
       test::Pass(embedded_quads, arraysize(embedded_quads))};
 
   SubmitCompositorFrame(embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
 
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
   SubmitCompositorFrame(root_passes, arraysize(root_passes), root_surface_id_);
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                                  test::Quad::SolidColorQuad(SK_ColorGREEN),
                                  test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass expected_passes[] = {
       test::Pass(expected_quads, arraysize(expected_quads))};
   SurfaceId ids[] = {root_surface_id_, embedded_surface_id};
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   factory_.Destroy(embedded_surface_id);
 }
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) {
   SurfaceId embedded_surface_id = allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
+  Surface* embedded_surface = manager_.GetSurfaceForId(embedded_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
 
   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
   test::Pass embedded_passes[] = {
       test::Pass(embedded_quads, arraysize(embedded_quads))};
 
   SubmitCompositorFrame(embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
   scoped_ptr<CopyOutputRequest> copy_request(
       CopyOutputRequest::CreateEmptyRequest());
   CopyOutputRequest* copy_request_ptr = copy_request.get();
   factory_.RequestCopyOfSurface(embedded_surface_id, copy_request.Pass());
 
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
   SubmitCompositorFrame(root_passes, arraysize(root_passes), root_surface_id_);
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   test::Quad expected_quads[] = {
       test::Quad::SolidColorQuad(SK_ColorWHITE),
       test::Quad::RenderPassQuad(frame_data->render_pass_list[0]->id),
       test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass expected_passes[] = {
@@ skipping 16 matching lines @@
         aggregator_.previous_contained_surfaces().end());
   }
 
   factory_.Destroy(embedded_surface_id);
 }
 
 // Root surface may contain copy requests.
 TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {
   SurfaceId embedded_surface_id = allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
+  Surface* embedded_surface = manager_.GetSurfaceForId(embedded_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
 
   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
   test::Pass embedded_passes[] = {
       test::Pass(embedded_quads, arraysize(embedded_quads))};
 
   SubmitCompositorFrame(embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
   scoped_ptr<CopyOutputRequest> copy_request(
       CopyOutputRequest::CreateEmptyRequest());
   CopyOutputRequest* copy_request_ptr = copy_request.get();
@@ skipping 20 matching lines @@
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list.swap(frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
     frame->delegated_frame_data = frame_data.Pass();
 
     factory_.SubmitCompositorFrame(root_surface_id_, frame.Pass(),
                                    SurfaceFactory::DrawCallback());
   }
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                                  test::Quad::SolidColorQuad(SK_ColorGREEN),
                                  test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass expected_passes[] = {
       test::Pass(expected_quads, arraysize(expected_quads)),
@@ skipping 27 matching lines @@
   DCHECK(original_pass_list[0]->copy_requests.empty());
   DCHECK(original_pass_list[1]->copy_requests.empty());
 
   factory_.Destroy(embedded_surface_id);
 }
 
 // This tests referencing a surface that has multiple render passes.
 TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) {
   SurfaceId embedded_surface_id = child_allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
+  Surface* embedded_surface = manager_.GetSurfaceForId(embedded_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
 
   RenderPassId pass_ids[] = {RenderPassId(1, 1), RenderPassId(1, 2),
                              RenderPassId(1, 3)};
 
   test::Quad embedded_quads[][2] = {
       {test::Quad::SolidColorQuad(1), test::Quad::SolidColorQuad(2)},
       {test::Quad::SolidColorQuad(3), test::Quad::RenderPassQuad(pass_ids[0])},
       {test::Quad::SolidColorQuad(4), test::Quad::RenderPassQuad(pass_ids[1])}};
   test::Pass embedded_passes[] = {
       test::Pass(embedded_quads[0], arraysize(embedded_quads[0]), pass_ids[0]),
       test::Pass(embedded_quads[1], arraysize(embedded_quads[1]), pass_ids[1]),
       test::Pass(embedded_quads[2], arraysize(embedded_quads[2]), pass_ids[2])};
 
   SubmitCompositorFrame(embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
 
   test::Quad root_quads[][2] = {
       {test::Quad::SolidColorQuad(5), test::Quad::SolidColorQuad(6)},
       {test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
        test::Quad::RenderPassQuad(pass_ids[0])},
       {test::Quad::SolidColorQuad(7), test::Quad::RenderPassQuad(pass_ids[1])}};
   test::Pass root_passes[] = {
       test::Pass(root_quads[0], arraysize(root_quads[0]), pass_ids[0]),
       test::Pass(root_quads[1], arraysize(root_quads[1]), pass_ids[1]),
       test::Pass(root_quads[2], arraysize(root_quads[2]), pass_ids[2])};
 
   SubmitCompositorFrame(root_passes, arraysize(root_passes), root_surface_id_);
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(embedded_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(5u, aggregated_pass_list.size());
   RenderPassId actual_pass_ids[] = {
       aggregated_pass_list[0]->id, aggregated_pass_list[1]->id,
@@ skipping 99 matching lines @@
                         test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 
   SubmitCompositorFrame(passes, arraysize(passes), root_surface_id_);
 
   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
                                  test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass expected_passes[] = {
       test::Pass(expected_quads, arraysize(expected_quads))};
   SurfaceId ids[] = {root_surface_id_, InvalidSurfaceId()};
+
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
 }
 
 // Tests a reference to a valid surface with no submitted frame. This quad
 // should also just be dropped.
 TEST_F(SurfaceAggregatorValidSurfaceTest, ValidSurfaceReferenceWithNoFrame) {
   SurfaceId surface_with_no_frame_id = allocator_.GenerateId();
   factory_.Create(surface_with_no_frame_id);
+  Surface* surface_with_no_frame =
+      manager_.GetSurfaceForId(surface_with_no_frame_id);
+
   test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
                         test::Quad::SurfaceQuad(surface_with_no_frame_id, 1.f),
                         test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 
   SubmitCompositorFrame(passes, arraysize(passes), root_surface_id_);
 
   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
                                  test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass expected_passes[] = {
       test::Pass(expected_quads, arraysize(expected_quads))};
   SurfaceId ids[] = {root_surface_id_, surface_with_no_frame_id};
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface_with_no_frame));
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface_with_no_frame));
   factory_.Destroy(surface_with_no_frame_id);
 }
 
 // Tests a surface quad referencing itself, generating a trivial cycle.
 // The quad creating the cycle should be dropped from the final frame.
 TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleCyclicalReference) {
   test::Quad quads[] = {test::Quad::SurfaceQuad(root_surface_id_, 1.f),
                         test::Quad::SolidColorQuad(SK_ColorYELLOW)};
   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 
   SubmitCompositorFrame(passes, arraysize(passes), root_surface_id_);
 
   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorYELLOW)};
   test::Pass expected_passes[] = {
       test::Pass(expected_quads, arraysize(expected_quads))};
   SurfaceId ids[] = {root_surface_id_};
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
 }
 
 // Tests a more complex cycle with one intermediate surface.
 TEST_F(SurfaceAggregatorValidSurfaceTest, TwoSurfaceCyclicalReference) {
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
+  Surface* child_surface = manager_.GetSurfaceForId(child_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
 
   test::Quad parent_quads[] = {test::Quad::SolidColorQuad(SK_ColorBLUE),
                                test::Quad::SurfaceQuad(child_surface_id, 1.f),
                                test::Quad::SolidColorQuad(SK_ColorCYAN)};
   test::Pass parent_passes[] = {
       test::Pass(parent_quads, arraysize(parent_quads))};
 
   SubmitCompositorFrame(parent_passes, arraysize(parent_passes),
                         root_surface_id_);
 
@@ skipping 11 matching lines @@
   //   SK_ColorGREEN from the child
   //   SK_ColorMAGENTA from the child
   //   SK_ColorCYAN from the parent
   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorBLUE),
                                  test::Quad::SolidColorQuad(SK_ColorGREEN),
                                  test::Quad::SolidColorQuad(SK_ColorMAGENTA),
                                  test::Quad::SolidColorQuad(SK_ColorCYAN)};
   test::Pass expected_passes[] = {
       test::Pass(expected_quads, arraysize(expected_quads))};
   SurfaceId ids[] = {root_surface_id_, child_surface_id};
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
   factory_.Destroy(child_surface_id);
 }
 
 // Tests that we map render pass IDs from different surfaces into a unified
 // namespace and update RenderPassDrawQuad's id references to match.
 TEST_F(SurfaceAggregatorValidSurfaceTest, RenderPassIdMapping) {
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
+  Surface* child_surface = manager_.GetSurfaceForId(child_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
 
   RenderPassId child_pass_id[] = {RenderPassId(1, 1), RenderPassId(1, 2)};
   test::Quad child_quad[][1] = {{test::Quad::SolidColorQuad(SK_ColorGREEN)},
                                 {test::Quad::RenderPassQuad(child_pass_id[0])}};
   test::Pass surface_passes[] = {
       test::Pass(child_quad[0], arraysize(child_quad[0]), child_pass_id[0]),
       test::Pass(child_quad[1], arraysize(child_quad[1]), child_pass_id[1])};
 
   SubmitCompositorFrame(surface_passes, arraysize(surface_passes),
                         child_surface_id);
 
   // Pass IDs from the parent surface may collide with ones from the child.
   RenderPassId parent_pass_id[] = {RenderPassId(2, 1), RenderPassId(1, 2)};
   test::Quad parent_quad[][1] = {
       {test::Quad::SurfaceQuad(child_surface_id, 1.f)},
       {test::Quad::RenderPassQuad(parent_pass_id[0])}};
   test::Pass parent_passes[] = {
       test::Pass(parent_quad[0], arraysize(parent_quad[0]), parent_pass_id[0]),
       test::Pass(parent_quad[1], arraysize(parent_quad[1]), parent_pass_id[1])};
 
   SubmitCompositorFrame(parent_passes, arraysize(parent_passes),
                         root_surface_id_);
+
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(3u, aggregated_pass_list.size());
   RenderPassId actual_pass_ids[] = {aggregated_pass_list[0]->id,
                                     aggregated_pass_list[1]->id,
@@ skipping 77 matching lines @@
                                           SkXfermode::kDst_Mode,      // 2
                                           SkXfermode::kSrcOver_Mode,  // 3
                                           SkXfermode::kDstOver_Mode,  // 4
                                           SkXfermode::kSrcIn_Mode,    // 5
                                           SkXfermode::kDstIn_Mode,    // 6
   };
 
   RenderPassId pass_id(1, 1);
   SurfaceId grandchild_surface_id = allocator_.GenerateId();
   factory_.Create(grandchild_surface_id);
+  Surface* grandchild_surface = manager_.GetSurfaceForId(grandchild_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(grandchild_surface));
   scoped_ptr<RenderPass> grandchild_pass = RenderPass::Create();
   gfx::Rect output_rect(SurfaceSize());
   gfx::Rect damage_rect(SurfaceSize());
   gfx::Transform transform_to_root_target;
   grandchild_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), grandchild_pass.get(), blend_modes[2]);
   QueuePassAsFrame(grandchild_pass.Pass(), grandchild_surface_id);
 
   SurfaceId child_one_surface_id = allocator_.GenerateId();
   factory_.Create(child_one_surface_id);
+  Surface* child_one_surface = manager_.GetSurfaceForId(child_one_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_one_surface));
 
   scoped_ptr<RenderPass> child_one_pass = RenderPass::Create();
   child_one_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[1]);
   SurfaceDrawQuad* grandchild_surface_quad =
       child_one_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   grandchild_surface_quad->SetNew(child_one_pass->shared_quad_state_list.back(),
                                   gfx::Rect(SurfaceSize()),
                                   gfx::Rect(SurfaceSize()),
                                   grandchild_surface_id);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[3]);
   QueuePassAsFrame(child_one_pass.Pass(), child_one_surface_id);
 
   SurfaceId child_two_surface_id = allocator_.GenerateId();
   factory_.Create(child_two_surface_id);
+  Surface* child_two_surface = manager_.GetSurfaceForId(child_two_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_two_surface));
 
   scoped_ptr<RenderPass> child_two_pass = RenderPass::Create();
   child_two_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_two_pass.get(), blend_modes[5]);
   QueuePassAsFrame(child_two_pass.Pass(), child_two_surface_id);
 
   scoped_ptr<RenderPass> root_pass = RenderPass::Create();
   root_pass->SetNew(
@@ skipping 13 matching lines @@
       root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   child_two_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
                                  gfx::Rect(SurfaceSize()),
                                  gfx::Rect(SurfaceSize()),
                                  child_two_surface_id);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[6]);
 
   QueuePassAsFrame(root_pass.Pass(), root_surface_id_);
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(grandchild_surface));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_one_surface));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_two_surface));
+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(grandchild_surface));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_one_surface));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_two_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(1u, aggregated_pass_list.size());
 
   const QuadList& aggregated_quad_list = aggregated_pass_list[0]->quad_list;
@@ skipping 25 matching lines @@
 // of +5 in the x direction. The second pass has a reference to the first pass'
 // pass id and a transform of +8 in the x direction.
 //
 // After aggregation, the child surface's root pass quad should have all
 // transforms concatenated for a total transform of +23 x, +10 y. The
 // contributing render pass' transform in the aggregate frame should not be
 // affected.
 TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
   // Innermost child surface.
   SurfaceId child_surface_id = allocator_.GenerateId();
+  factory_.Create(child_surface_id);
+  Surface* child_surface = manager_.GetSurfaceForId(child_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
   {
-    factory_.Create(child_surface_id);
     RenderPassId child_pass_id[] = {RenderPassId(1, 1), RenderPassId(1, 2)};
     test::Quad child_quads[][1] = {
         {test::Quad::SolidColorQuad(SK_ColorGREEN)},
         {test::Quad::RenderPassQuad(child_pass_id[0])},
     };
     test::Pass child_passes[] = {
         test::Pass(child_quads[0], arraysize(child_quads[0]), child_pass_id[0]),
         test::Pass(child_quads[1], arraysize(child_quads[1]),
                    child_pass_id[1])};
 
@@ skipping 19 matching lines @@
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
     child_frame->delegated_frame_data = child_frame_data.Pass();
 
     factory_.SubmitCompositorFrame(child_surface_id, child_frame.Pass(),
                                    SurfaceFactory::DrawCallback());
   }
 
   // Middle child surface.
   SurfaceId middle_surface_id = allocator_.GenerateId();
+  factory_.Create(middle_surface_id);
+  Surface* middle_surface = manager_.GetSurfaceForId(middle_surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(middle_surface));
   {
-    factory_.Create(middle_surface_id);
     test::Quad middle_quads[] = {
         test::Quad::SurfaceQuad(child_surface_id, 1.f)};
     test::Pass middle_passes[] = {
         test::Pass(middle_quads, arraysize(middle_quads)),
     };
 
     RenderPassList middle_pass_list;
     AddPasses(&middle_pass_list, gfx::Rect(SurfaceSize()), middle_passes,
               arraysize(middle_passes));
 
@@ skipping 42 matching lines @@
 
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
   root_frame->delegated_frame_data = root_frame_data.Pass();
 
   factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
                                  SurfaceFactory::DrawCallback());
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(middle_surface));
+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(middle_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(3u, aggregated_pass_list.size());
 
   ASSERT_EQ(1u, aggregated_pass_list[0]->shared_quad_state_list.size());
@@ skipping 83 matching lines @@
   child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
 
   scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
   child_pass_list.swap(child_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
   child_frame->delegated_frame_data = child_frame_data.Pass();
 
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
+  Surface* child_surface = manager_.GetSurfaceForId(child_surface_id);
   factory_.SubmitCompositorFrame(child_surface_id, child_frame.Pass(),
                                  SurfaceFactory::DrawCallback());
 
   test::Quad parent_surface_quads[] = {
       test::Quad::SurfaceQuad(child_surface_id, 1.f)};
   test::Pass parent_surface_passes[] = {
       test::Pass(parent_surface_quads, arraysize(parent_surface_quads),
                  RenderPassId(1, 1))};
 
   RenderPassList parent_surface_pass_list;
   AddPasses(&parent_surface_pass_list,
             gfx::Rect(SurfaceSize()),
             parent_surface_passes,
             arraysize(parent_surface_passes));
 
   // Parent surface is only used to test if the transform is applied correctly
   // to the child surface's damage.
   scoped_ptr<DelegatedFrameData> parent_surface_frame_data(
       new DelegatedFrameData);
   parent_surface_pass_list.swap(parent_surface_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> parent_surface_frame(new CompositorFrame);
   parent_surface_frame->delegated_frame_data = parent_surface_frame_data.Pass();
 
   SurfaceId parent_surface_id = allocator_.GenerateId();
   factory_.Create(parent_surface_id);
+  Surface* parent_surface = manager_.GetSurfaceForId(parent_surface_id);
   factory_.SubmitCompositorFrame(parent_surface_id, parent_surface_frame.Pass(),
                                  SurfaceFactory::DrawCallback());
 
   test::Quad root_surface_quads[] = {
       test::Quad::SurfaceQuad(parent_surface_id, 1.f)};
   test::Quad root_render_pass_quads[] = {
       test::Quad::RenderPassQuad(RenderPassId(1, 1))};
 
   test::Pass root_passes[] = {
       test::Pass(root_surface_quads, arraysize(root_surface_quads),
@@ skipping 15 matching lines @@
 
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
   root_frame->delegated_frame_data = root_frame_data.Pass();
 
   factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
                                  SurfaceFactory::DrawCallback());
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(parent_surface));
+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(2u, aggregated_pass_list.size());
 
   // Damage rect for first aggregation should contain entire root surface.
@@ skipping 14 matching lines @@
 
     scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
     child_pass_list.swap(child_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
     child_frame->delegated_frame_data = child_frame_data.Pass();
 
     factory_.SubmitCompositorFrame(child_surface_id, child_frame.Pass(),
                                    SurfaceFactory::DrawCallback());
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
@@ skipping 39 matching lines @@
 
     scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
     root_pass_list.swap(root_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
     root_frame->delegated_frame_data = root_frame_data.Pass();
 
     factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
                                    SurfaceFactory::DrawCallback());
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
     // The root surface was enqueued without being aggregated once, so it should
     // be treated as completely damaged.
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.Contains(
         gfx::Rect(SurfaceSize())));
   }
 
   // No Surface changed, so no damage should be given.
   {
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.IsEmpty());
   }
 
   // SetFullDamageRectForSurface should cause the entire output to be
   // marked as damaged.
   {
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
     aggregator_.SetFullDamageForSurface(root_surface_id_);
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
+
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.Contains(
         gfx::Rect(SurfaceSize())));
   }
 
   factory_.Destroy(child_surface_id);
 }
 
 class SurfaceAggregatorPartialSwapTest
     : public SurfaceAggregatorValidSurfaceTest {
  public:
   SurfaceAggregatorPartialSwapTest()
       : SurfaceAggregatorValidSurfaceTest(true) {}
 };
 
 // Tests that quads outside the damage rect are ignored.
 TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) {
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
+  Surface* child_surface = manager_.GetSurfaceForId(child_surface_id);
   // The child surface has two quads, one with a visible rect of 13,13 4x4 and
   // the other other with a visible rect of 10,10 2x2 (relative to root target
   // space).
   {
     RenderPassId child_pass_id = RenderPassId(1, 1);
     test::Quad child_quads1[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Quad child_quads2[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Pass child_passes[] = {
         test::Pass(child_quads1, arraysize(child_quads1), child_pass_id),
         test::Pass(child_quads2, arraysize(child_quads2), child_pass_id)};
@@ skipping 25 matching lines @@
               arraysize(root_passes));
 
     RenderPass* root_pass = root_pass_list.at(0u);
     root_pass->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(10, 10);
     root_pass->damage_rect = gfx::Rect(0, 0, 1, 1);
 
     SubmitPassListAsFrame(root_surface_id_, &root_pass_list);
   }
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
+
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(2u, aggregated_pass_list.size());
 
   // Damage rect for first aggregation should contain entire root surface.
@@ skipping 12 matching lines @@
               arraysize(root_passes));
 
     RenderPass* root_pass = root_pass_list.at(0u);
     root_pass->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(10, 10);
     root_pass->damage_rect = gfx::Rect(10, 10, 2, 2);
     SubmitPassListAsFrame(root_surface_id_, &root_pass_list);
   }
 
   {
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
@@ skipping 32 matching lines @@
 
     RenderPass* child_root_pass = child_pass_list.at(1u);
 
     child_root_pass->copy_requests.push_back(
         CopyOutputRequest::CreateEmptyRequest());
     child_root_pass->damage_rect = gfx::Rect();
     SubmitPassListAsFrame(child_surface_id, &child_pass_list);
   }
 
   {
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     // Output frame should have no damage, but all quads included.
     ASSERT_EQ(3u, aggregated_pass_list.size());
 
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.IsEmpty());
     ASSERT_EQ(1u, aggregated_pass_list[0]->quad_list.size());
     ASSERT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
     EXPECT_EQ(gfx::Rect(1, 1, 2, 2),
               aggregated_pass_list[0]->quad_list.ElementAt(0)->visible_rect);
     EXPECT_EQ(gfx::Rect(0, 0, 2, 2),
               aggregated_pass_list[1]->quad_list.ElementAt(0)->visible_rect);
   }
 
   {
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
+    EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
     // There were no changes since last aggregation, so output should be empty
     // and have no damage.
     ASSERT_EQ(1u, aggregated_pass_list.size());
     EXPECT_TRUE(aggregated_pass_list[0]->damage_rect.IsEmpty());
     ASSERT_EQ(0u, aggregated_pass_list[0]->quad_list.size());
   }
 
   factory_.Destroy(child_surface_id);
 }
 
 class SurfaceAggregatorWithResourcesTest : public testing::Test {
  public:
   void SetUp() override {
     output_surface_ = FakeOutputSurface::CreateSoftware(
         make_scoped_ptr(new SoftwareOutputDevice));
     output_surface_->BindToClient(&output_surface_client_);
     shared_bitmap_manager_.reset(new TestSharedBitmapManager);
 
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get());
 
-    aggregator_.reset(
-        new SurfaceAggregator(&manager_, resource_provider_.get(), false));
+    aggregator_.reset(new SurfaceAggregator(&surface_aggregator_client_,
+                                            &manager_, resource_provider_.get(),
+                                            false));
   }
 
  protected:
   SurfaceManager manager_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<OutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<SurfaceAggregator> aggregator_;
+  FakeSurfaceAggregatorClient surface_aggregator_client_;
 };
 
 class ResourceTrackingSurfaceFactoryClient : public SurfaceFactoryClient {
  public:
   ResourceTrackingSurfaceFactoryClient() {}
   ~ResourceTrackingSurfaceFactoryClient() override {}
 
   void ReturnResources(const ReturnedResourceArray& resources) override {
     returned_resources_ = resources;
   }
 
   ReturnedResourceArray returned_resources() const {
     return returned_resources_;
   }
 
+  void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {}
+
  private:
   ReturnedResourceArray returned_resources_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceTrackingSurfaceFactoryClient);
 };
 
 void SubmitCompositorFrameWithResources(ResourceId* resource_ids,
                                         size_t num_resource_ids,
                                         bool valid,
                                         SurfaceId child_id,
@@ skipping 39 matching lines @@
   frame->delegated_frame_data = frame_data.Pass();
   factory->SubmitCompositorFrame(surface_id, frame.Pass(),
                                  SurfaceFactory::DrawCallback());
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
   SurfaceId surface_id(7u);
   factory.Create(surface_id);
+  Surface* surface = manager_.GetSurfaceForId(surface_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface_id);
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface));
+
   scoped_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface_id);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface));
+
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
 
   SubmitCompositorFrameWithResources(NULL, 0u, true, SurfaceId(), &factory,
                                      surface_id);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface));
+
   frame = aggregator_->Aggregate(surface_id);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface));
+
   ASSERT_EQ(3u, client.returned_resources().size());
   ResourceId returned_ids[3];
   for (size_t i = 0; i < 3; ++i) {
     returned_ids[i] = client.returned_resources()[i].id;
   }
   EXPECT_THAT(returned_ids,
               testing::WhenSorted(testing::ElementsAreArray(ids)));
   factory.Destroy(surface_id);
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
   SurfaceId surface_id(7u);
   factory.Create(surface_id);
+  Surface* surface = manager_.GetSurfaceForId(surface_id);
 
   scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
   scoped_ptr<RenderPass> pass = RenderPass::Create();
   pass->id = RenderPassId(1, 1);
   TransferableResource resource;
   resource.id = 11;
   // ResourceProvider is software but resource is not, so it should be
   // ignored.
   resource.is_software = false;
   frame_data->resource_list.push_back(resource);
   frame_data->render_pass_list.push_back(pass.Pass());
   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
   frame->delegated_frame_data = frame_data.Pass();
   factory.SubmitCompositorFrame(surface_id, frame.Pass(),
                                 SurfaceFactory::DrawCallback());
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface));
+
   scoped_ptr<CompositorFrame> returned_frame =
       aggregator_->Aggregate(surface_id);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface));
+
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
 
   SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), &factory,
                                      surface_id);
   ASSERT_EQ(1u, client.returned_resources().size());
   EXPECT_EQ(11u, client.returned_resources()[0].id);
 
   factory.Destroy(surface_id);
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TwoSurfaces) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
-  SurfaceId surface_id(7u);
-  factory.Create(surface_id);
-  SurfaceId surface_id2(8u);
-  factory.Create(surface_id2);
+  SurfaceId surface1_id(7u);
+  factory.Create(surface1_id);
+  Surface* surface1 = manager_.GetSurfaceForId(surface1_id);
+
+  SurfaceId surface2_id(8u);
+  factory.Create(surface2_id);
+  Surface* surface2 = manager_.GetSurfaceForId(surface2_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
-                                     &factory, surface_id);
+                                     &factory, surface1_id);
   ResourceId ids2[] = {14, 15, 16};
   SubmitCompositorFrameWithResources(ids2, arraysize(ids2), true, SurfaceId(),
-                                     &factory, surface_id2);
+                                     &factory, surface2_id);
 
-  scoped_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface_id);
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface1));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface2));
+
+  scoped_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface1_id);
+
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface1));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface2));
 
   SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), &factory,
-                                     surface_id);
+                                     surface1_id);
 
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
 
-  frame = aggregator_->Aggregate(surface_id2);
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface1));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface2));
 
-  // surface_id wasn't referenced, so its resources should be returned.
+  frame = aggregator_->Aggregate(surface2_id);
+
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface1));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface2));
+
+  // surface1_id wasn't referenced, so its resources should be returned.
   ASSERT_EQ(3u, client.returned_resources().size());
   ResourceId returned_ids[3];
   for (size_t i = 0; i < 3; ++i) {
     returned_ids[i] = client.returned_resources()[i].id;
   }
   EXPECT_THAT(returned_ids,
               testing::WhenSorted(testing::ElementsAreArray(ids)));
   EXPECT_EQ(3u, resource_provider_->num_resources());
-  factory.Destroy(surface_id);
-  factory.Destroy(surface_id2);
+  factory.Destroy(surface1_id);
+  factory.Destroy(surface2_id);
 }
 
 // Ensure that aggregator completely ignores Surfaces that reference invalid
 // resources.
 TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
   SurfaceId root_surface_id(7u);
   factory.Create(root_surface_id);
+  Surface* root_surface = manager_.GetSurfaceForId(root_surface_id);
   SurfaceId middle_surface_id(8u);
   factory.Create(middle_surface_id);
+  Surface* middle_surface = manager_.GetSurfaceForId(middle_surface_id);
   SurfaceId child_surface_id(9u);
   factory.Create(child_surface_id);
+  Surface* child_surface = manager_.GetSurfaceForId(child_surface_id);
 
   ResourceId ids[] = {14, 15, 16};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, child_surface_id);
 
   ResourceId ids2[] = {17, 18, 19};
   SubmitCompositorFrameWithResources(ids2, arraysize(ids2), false,
                                      child_surface_id, &factory,
                                      middle_surface_id);
 
   ResourceId ids3[] = {20, 21, 22};
   SubmitCompositorFrameWithResources(ids3, arraysize(ids3), true,
                                      middle_surface_id, &factory,
                                      root_surface_id);
 
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(middle_surface));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
+
   scoped_ptr<CompositorFrame> frame;
   frame = aggregator_->Aggregate(root_surface_id);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(middle_surface));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
+
   RenderPassList* pass_list = &frame->delegated_frame_data->render_pass_list;
   ASSERT_EQ(1u, pass_list->size());
   EXPECT_EQ(1u, pass_list->back()->shared_quad_state_list.size());
   EXPECT_EQ(3u, pass_list->back()->quad_list.size());
 
   SubmitCompositorFrameWithResources(ids2, arraysize(ids), true,
                                      child_surface_id, &factory,
                                      middle_surface_id);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(middle_surface));
+  EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
+
   frame = aggregator_->Aggregate(root_surface_id);
 
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(middle_surface));
+  EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
+
   pass_list = &frame->delegated_frame_data->render_pass_list;
   ASSERT_EQ(1u, pass_list->size());
   EXPECT_EQ(3u, pass_list->back()->shared_quad_state_list.size());
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
   factory.Destroy(root_surface_id);
   factory.Destroy(child_surface_id);
   factory.Destroy(middle_surface_id);
 }
 
 }  // namespace
 }  // namespace cc