Reduce SurfaceIdAllocator usage and tie SurfaceFactory to a single FrameSinkId

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>
@@ skipping 18 matching lines @@
 #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 {
 
 static constexpr FrameSinkId kArbitraryFrameSinkId(1, 1);
+static constexpr FrameSinkId kArbitraryChildFrameSinkId(2, 2);
 
 SurfaceId InvalidSurfaceId() {
   static SurfaceId invalid(kArbitraryFrameSinkId, 0xdeadbeef, 0);
   return invalid;
 }
 
 gfx::Size SurfaceSize() {
   static gfx::Size size(100, 100);
   return size;
 }
@@ skipping 10 matching lines @@
 
   void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {}
 
   gfx::Rect last_damage_rect_;
   SurfaceId last_surface_id_;
 };
 
 class SurfaceAggregatorTest : public testing::Test {
  public:
   explicit SurfaceAggregatorTest(bool use_damage_rect)
-      : factory_(&manager_, &empty_client_),
+      : factory_(kArbitraryFrameSinkId, &manager_, &empty_client_),
         aggregator_(&manager_, NULL, use_damage_rect) {}
 
   SurfaceAggregatorTest() : SurfaceAggregatorTest(false) {}
 
  protected:
   SurfaceManager manager_;
   EmptySurfaceFactoryClient empty_client_;
   SurfaceFactory factory_;
   SurfaceAggregator aggregator_;
 };
 
 TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {
   SurfaceId one_id(kArbitraryFrameSinkId, 7, 0);
   factory_.Create(one_id);
 
   CompositorFrame frame = aggregator_.Aggregate(one_id);
   EXPECT_FALSE(frame.delegated_frame_data);
 
   factory_.Destroy(one_id);
 }
 
 class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {
  public:
   explicit SurfaceAggregatorValidSurfaceTest(bool use_damage_rect)
       : SurfaceAggregatorTest(use_damage_rect),
-        allocator_(FrameSinkId(1, 1)),
-        child_allocator_(FrameSinkId(2, 2)) {}
+        allocator_(kArbitraryFrameSinkId),
+        child_factory_(kArbitraryChildFrameSinkId,
+                       &manager_,
+                       &empty_child_client_),
+        child_allocator_(kArbitraryChildFrameSinkId) {}
   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_);
   }
 
@@ skipping 24 matching lines @@
 
     EXPECT_EQ(expected_surface_count,
               aggregator_.previous_contained_surfaces().size());
     for (size_t i = 0; i < expected_surface_count; i++) {
       EXPECT_TRUE(
           aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
           aggregator_.previous_contained_surfaces().end());
     }
   }
 
-  void SubmitPassListAsFrame(const SurfaceId& surface_id,
+  void SubmitPassListAsFrame(SurfaceFactory* factory,
+                             const SurfaceId& surface_id,
                              RenderPassList* pass_list) {
     std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list->swap(frame_data->render_pass_list);
 
     CompositorFrame frame;
     frame.delegated_frame_data = std::move(frame_data);
 
-    factory_.SubmitCompositorFrame(surface_id, std::move(frame),
+    factory->SubmitCompositorFrame(surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
-  void SubmitCompositorFrame(test::Pass* passes,
+  void SubmitCompositorFrame(SurfaceFactory* factory,
+                             test::Pass* passes,
                              size_t pass_count,
                              const SurfaceId& surface_id) {
     RenderPassList pass_list;
     AddPasses(&pass_list, gfx::Rect(SurfaceSize()), passes, pass_count);
-    SubmitPassListAsFrame(surface_id, &pass_list);
+    SubmitPassListAsFrame(factory, surface_id, &pass_list);
   }
 
   void QueuePassAsFrame(std::unique_ptr<RenderPass> pass,
                         const SurfaceId& surface_id) {
     std::unique_ptr<DelegatedFrameData> delegated_frame_data(
         new DelegatedFrameData);
     delegated_frame_data->render_pass_list.push_back(std::move(pass));
 
     CompositorFrame child_frame;
     child_frame.delegated_frame_data = std::move(delegated_frame_data);
 
     factory_.SubmitCompositorFrame(surface_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
  protected:
   SurfaceId root_surface_id_;
   Surface* root_surface_;
   SurfaceIdAllocator allocator_;
+  EmptySurfaceFactoryClient empty_child_client_;
+  SurfaceFactory child_factory_;
   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_);
+  SubmitCompositorFrame(&factory_, passes, arraysize(passes), root_surface_id_);
 
   SurfaceId ids[] = {root_surface_id_};
 
   AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids));
 
   // Check that WillDrawSurface was called.
   EXPECT_EQ(gfx::Rect(SurfaceSize()), empty_client_.last_damage_rect_);
   EXPECT_EQ(root_surface_id_, empty_client_.last_surface_id_);
 }
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) {
   SurfaceId embedded_surface_id = allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
 
   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),
+  SubmitCompositorFrame(&factory_, 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_);
+  SubmitCompositorFrame(&factory_, passes, arraysize(passes), root_surface_id_);
 
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
   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(
@@ skipping 12 matching lines @@
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSimpleFrame) {
   test::Quad quads[][2] = {{test::Quad::SolidColorQuad(SK_ColorWHITE),
                             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_);
+  SubmitCompositorFrame(&factory_, passes, arraysize(passes), root_surface_id_);
 
   SurfaceId ids[] = {root_surface_id_};
 
   AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids));
 }
 
 // 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);
 
   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),
+  SubmitCompositorFrame(&factory_, 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_);
+  SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes),
+                        root_surface_id_);
 
   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));
 
   factory_.Destroy(embedded_surface_id);
 }
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) {
   SurfaceId embedded_surface_id = allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
 
   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),
+  SubmitCompositorFrame(&factory_, embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
   std::unique_ptr<CopyOutputRequest> copy_request(
       CopyOutputRequest::CreateEmptyRequest());
   CopyOutputRequest* copy_request_ptr = copy_request.get();
   factory_.RequestCopyOfSurface(embedded_surface_id, std::move(copy_request));
 
   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_);
+  SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes),
+                        root_surface_id_);
 
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
   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),
@@ skipping 23 matching lines @@
 
 // Root surface may contain copy requests.
 TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {
   SurfaceId embedded_surface_id = allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
 
   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),
+  SubmitCompositorFrame(&factory_, embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
   std::unique_ptr<CopyOutputRequest> copy_request(
       CopyOutputRequest::CreateEmptyRequest());
   CopyOutputRequest* copy_request_ptr = copy_request.get();
   std::unique_ptr<CopyOutputRequest> copy_request2(
       CopyOutputRequest::CreateEmptyRequest());
   CopyOutputRequest* copy_request2_ptr = copy_request2.get();
 
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
@@ skipping 67 matching lines @@
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) {
   SurfaceId embedded_surface_id = allocator_.GenerateId();
   SurfaceId nonexistent_surface_id = allocator_.GenerateId();
   factory_.Create(embedded_surface_id);
 
   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),
+  SubmitCompositorFrame(&factory_, embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
   std::unique_ptr<CopyOutputRequest> copy_request(
       CopyOutputRequest::CreateEmptyRequest());
   CopyOutputRequest* copy_request_ptr = copy_request.get();
   factory_.RequestCopyOfSurface(embedded_surface_id, std::move(copy_request));
 
   SurfaceId parent_surface_id = allocator_.GenerateId();
   factory_.Create(parent_surface_id);
 
   test::Quad parent_quads[] = {
@@ skipping 66 matching lines @@
         aggregator_.previous_contained_surfaces().end());
   }
 
   factory_.Destroy(parent_surface_id);
   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);
+  child_factory_.Create(embedded_surface_id);
 
   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);
+  SubmitCompositorFrame(&child_factory_, 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_);
+  SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes),
+                        root_surface_id_);
 
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
   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());
@@ skipping 84 matching lines @@
     // The last quad in the last pass will reference the second pass from the
     // root surface, which after aggregating is the fourth pass in the overall
     // list.
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               fifth_pass_quad_list.ElementAt(1)->material);
     const RenderPassDrawQuad* fifth_pass_render_pass_draw_quad =
         RenderPassDrawQuad::MaterialCast(fifth_pass_quad_list.ElementAt(1));
     EXPECT_EQ(actual_pass_ids[3],
               fifth_pass_render_pass_draw_quad->render_pass_id);
   }
-  factory_.Destroy(embedded_surface_id);
+  child_factory_.Destroy(embedded_surface_id);
 }
 
 // Tests an invalid surface reference in a frame. The surface quad should just
 // be dropped.
 TEST_F(SurfaceAggregatorValidSurfaceTest, InvalidSurfaceReference) {
   test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
                         test::Quad::SurfaceQuad(InvalidSurfaceId(), 1.f),
                         test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 
-  SubmitCompositorFrame(passes, arraysize(passes), root_surface_id_);
+  SubmitCompositorFrame(&factory_, 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()};
 
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 }
 
 // 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);
 
   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_);
+  SubmitCompositorFrame(&factory_, 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};
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
   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_);
+  SubmitCompositorFrame(&factory_, 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_};
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 }
 
 // Tests a more complex cycle with one intermediate surface.
 TEST_F(SurfaceAggregatorValidSurfaceTest, TwoSurfaceCyclicalReference) {
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
 
   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),
+  SubmitCompositorFrame(&factory_, parent_passes, arraysize(parent_passes),
                         root_surface_id_);
 
   test::Quad child_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
                               test::Quad::SurfaceQuad(root_surface_id_, 1.f),
                               test::Quad::SolidColorQuad(SK_ColorMAGENTA)};
   test::Pass child_passes[] = {test::Pass(child_quads, arraysize(child_quads))};
 
-  SubmitCompositorFrame(child_passes, arraysize(child_passes),
+  SubmitCompositorFrame(&factory_, child_passes, arraysize(child_passes),
                         child_surface_id);
 
   // The child surface's reference to the root_surface_ will be dropped, so
   // we'll end up with:
   //   SK_ColorBLUE from the parent
   //   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),
@@ skipping 13 matching lines @@
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
 
   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),
+  SubmitCompositorFrame(&factory_, 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),
+  SubmitCompositorFrame(&factory_, parent_passes, arraysize(parent_passes),
                         root_surface_id_);
 
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
   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;
 
@@ skipping 764 matching lines @@
 
     SharedQuadState* child_noninvertible_sqs =
         child_pass_list[2]->shared_quad_state_list.ElementAt(0u);
     child_noninvertible_sqs->quad_to_target_transform.matrix().setDouble(0, 0,
                                                                          0.0);
     EXPECT_FALSE(
         child_noninvertible_sqs->quad_to_target_transform.IsInvertible());
     child_pass_list[2]->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(0, 0, 2, 2);
 
-    SubmitPassListAsFrame(child_surface_id, &child_pass_list);
+    SubmitPassListAsFrame(&factory_, child_surface_id, &child_pass_list);
   }
 
   {
     test::Quad root_quads[] = {test::Quad::SurfaceQuad(child_surface_id, 1.f)};
 
     test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
               arraysize(root_passes));
 
     RenderPass* root_pass = root_pass_list[0].get();
     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);
+    SubmitPassListAsFrame(&factory_, root_surface_id_, &root_pass_list);
   }
 
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
   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;
 
@@ skipping 12 matching lines @@
     test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
               arraysize(root_passes));
 
     RenderPass* root_pass = root_pass_list[0].get();
     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);
+    SubmitPassListAsFrame(&factory_, root_surface_id_, &root_pass_list);
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
     ASSERT_TRUE(aggregated_frame.delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame.delegated_frame_data.get();
 
@@ skipping 33 matching lines @@
     child_sqs->quad_to_target_transform.Scale(2, 2);
 
     child_pass_list[1]->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(0, 0, 2, 2);
 
     RenderPass* child_root_pass = child_pass_list[1].get();
 
     child_root_pass->copy_requests.push_back(
         CopyOutputRequest::CreateEmptyRequest());
     child_root_pass->damage_rect = gfx::Rect();
-    SubmitPassListAsFrame(child_surface_id, &child_pass_list);
+    SubmitPassListAsFrame(&factory_, child_surface_id, &child_pass_list);
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
     ASSERT_TRUE(aggregated_frame.delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame.delegated_frame_data.get();
 
@@ skipping 45 matching lines @@
               arraysize(root_passes));
 
     RenderPass* pass = root_pass_list[0].get();
     pass->shared_quad_state_list.front()->quad_to_target_transform.Translate(
         10, 10);
     RenderPass* root_pass = root_pass_list[1].get();
     RenderPassDrawQuad* quad =
         static_cast<RenderPassDrawQuad*>(root_pass->quad_list.front());
     quad->filters.Append(FilterOperation::CreateBlurFilter(2));
     root_pass->damage_rect = gfx::Rect(10, 10, 2, 2);
-    SubmitPassListAsFrame(root_surface_id_, &root_pass_list);
+    SubmitPassListAsFrame(&factory_, root_surface_id_, &root_pass_list);
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
     ASSERT_TRUE(aggregated_frame.delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame.delegated_frame_data.get();
 
@@ skipping 29 matching lines @@
     AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
               arraysize(root_passes));
 
     RenderPass* root_pass = root_pass_list[1].get();
     root_pass->shared_quad_state_list.ElementAt(1)
         ->quad_to_target_transform.Translate(10, 10);
     RenderPassDrawQuad* quad =
         static_cast<RenderPassDrawQuad*>(root_pass->quad_list.front());
     quad->background_filters.Append(FilterOperation::CreateBlurFilter(2));
     root_pass->damage_rect = gfx::Rect(10, 10, 2, 2);
-    SubmitPassListAsFrame(root_surface_id_, &root_pass_list);
+    SubmitPassListAsFrame(&factory_, root_surface_id_, &root_pass_list);
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
 
     ASSERT_TRUE(aggregated_frame.delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame.delegated_frame_data.get();
 
@@ skipping 101 matching lines @@
   }
   frame_data->render_pass_list.push_back(std::move(pass));
   CompositorFrame frame;
   frame.delegated_frame_data = std::move(frame_data);
   factory->SubmitCompositorFrame(surface_id, std::move(frame),
                                  SurfaceFactory::DrawCallback());
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   ResourceTrackingSurfaceFactoryClient client;
-  SurfaceFactory factory(&manager_, &client);
+  SurfaceFactory factory(kArbitraryFrameSinkId, &manager_, &client);
   SurfaceId surface_id(kArbitraryFrameSinkId, 7u, 0);
   factory.Create(surface_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface_id);
 
   CompositorFrame frame = aggregator_->Aggregate(surface_id);
 
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
 
   SubmitCompositorFrameWithResources(NULL, 0u, true, SurfaceId(), &factory,
                                      surface_id);
 
   frame = aggregator_->Aggregate(surface_id);
 
   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);
+  SurfaceFactory factory(kArbitraryFrameSinkId, &manager_, &client);
   SurfaceId surface_id(kArbitraryFrameSinkId, 7u, 0);
   factory.Create(surface_id);
 
   std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
   std::unique_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.
@@ skipping 13 matching lines @@
   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);
+  SurfaceFactory factory(kArbitraryFrameSinkId, &manager_, &client);
   SurfaceId surface1_id(kArbitraryFrameSinkId, 7u, 0);
   factory.Create(surface1_id);
 
   SurfaceId surface2_id(kArbitraryFrameSinkId, 8u, 0);
   factory.Create(surface2_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface1_id);
   ResourceId ids2[] = {14, 15, 16};
@@ skipping 20 matching lines @@
               testing::WhenSorted(testing::ElementsAreArray(ids)));
   EXPECT_EQ(3u, resource_provider_->num_resources());
   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);
+  SurfaceFactory factory(kArbitraryFrameSinkId, &manager_, &client);
   SurfaceId root_surface_id(kArbitraryFrameSinkId, 7u, 0);
   factory.Create(root_surface_id);
   SurfaceId middle_surface_id(kArbitraryFrameSinkId, 8u, 0);
   factory.Create(middle_surface_id);
   SurfaceId child_surface_id(kArbitraryFrameSinkId, 9u, 0);
   factory.Create(child_surface_id);
 
   ResourceId ids[] = {14, 15, 16};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, child_surface_id);
@@ skipping 27 matching lines @@
   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);
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) {
   ResourceTrackingSurfaceFactoryClient client;
-  SurfaceFactory factory(&manager_, &client);
+  SurfaceFactory factory(kArbitraryFrameSinkId, &manager_, &client);
   SurfaceId surface1_id(kArbitraryFrameSinkId, 7u, 0);
   factory.Create(surface1_id);
 
   SurfaceId surface2_id(kArbitraryFrameSinkId, 8u, 0);
   factory.Create(surface2_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface1_id);
 
@@ skipping 46 matching lines @@
   // Output is insecure, so texture should be drawn.
   EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
 
   factory.Destroy(surface1_id);
   factory.Destroy(surface2_id);
 }
 
 }  // namespace
 }  // namespace cc