cc/surfaces/surface_aggregator_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/output/compositor_frame.h"
   6 #include "cc/output/delegated_frame_data.h"
   7 #include "cc/quads/render_pass.h"
   8 #include "cc/quads/render_pass_draw_quad.h"
   9 #include "cc/quads/solid_color_draw_quad.h"
  10 #include "cc/quads/surface_draw_quad.h"
  11 #include "cc/quads/texture_draw_quad.h"
  12 #include "cc/resources/shared_bitmap_manager.h"
  13 #include "cc/surfaces/surface.h"
  14 #include "cc/surfaces/surface_aggregator.h"
  15 #include "cc/surfaces/surface_aggregator_test_helpers.h"
  16 #include "cc/surfaces/surface_factory.h"
  17 #include "cc/surfaces/surface_factory_client.h"
  18 #include "cc/surfaces/surface_id_allocator.h"
  19 #include "cc/surfaces/surface_manager.h"
  20 #include "cc/test/fake_output_surface.h"
  21 #include "cc/test/fake_output_surface_client.h"
  22 #include "cc/test/render_pass_test_common.h"
  23 #include "cc/test/render_pass_test_utils.h"
  24 #include "cc/test/test_shared_bitmap_manager.h"
  25 #include "testing/gmock/include/gmock/gmock.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "third_party/skia/include/core/SkColor.h"
  28
  29 namespace cc {
  30 namespace {
  31
  32 SurfaceId InvalidSurfaceId() {
  33   static SurfaceId invalid;
  34   invalid.id = static_cast<uint64_t>(-1);
  35   return invalid;
  36 }
  37
  38 gfx::Size SurfaceSize() {
  39   static gfx::Size size(5, 5);
  40   return size;
  41 }
  42
  43 class EmptySurfaceFactoryClient : public SurfaceFactoryClient {
  44  public:
  45   void ReturnResources(const ReturnedResourceArray& resources) override {}
  46 };
  47
  48 class SurfaceAggregatorTest : public testing::Test {
  49  public:
  50   SurfaceAggregatorTest()
  51       : factory_(&manager_, &empty_client_), aggregator_(&manager_, NULL) {}
  52
  53  protected:
  54   SurfaceManager manager_;
  55   EmptySurfaceFactoryClient empty_client_;
  56   SurfaceFactory factory_;
  57   SurfaceAggregator aggregator_;
  58 };
  59
  60 TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {
  61   SurfaceId one_id(7);
  62   factory_.Create(one_id);
  63   scoped_ptr<CompositorFrame> frame = aggregator_.Aggregate(one_id);
  64   EXPECT_FALSE(frame);
  65   factory_.Destroy(one_id);
  66 }
  67
  68 class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {
  69  public:
  70   SurfaceAggregatorValidSurfaceTest() : allocator_(1u), child_allocator_(2u) {}
  71
  72   void SetUp() override {
  73     SurfaceAggregatorTest::SetUp();
  74     root_surface_id_ = allocator_.GenerateId();
  75     factory_.Create(root_surface_id_);
  76   }
  77
  78   void TearDown() override {
  79     factory_.Destroy(root_surface_id_);
  80     SurfaceAggregatorTest::TearDown();
  81   }
  82
  83   void AggregateAndVerify(test::Pass* expected_passes,
  84                           size_t expected_pass_count,
  85                           SurfaceId* surface_ids,
  86                           size_t expected_surface_count) {
  87     scoped_ptr<CompositorFrame> aggregated_frame =
  88         aggregator_.Aggregate(root_surface_id_);
  89
  90     ASSERT_TRUE(aggregated_frame);
  91     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
  92
  93     DelegatedFrameData* frame_data =
  94         aggregated_frame->delegated_frame_data.get();
  95
  96     TestPassesMatchExpectations(
  97         expected_passes, expected_pass_count, &frame_data->render_pass_list);
  98
  99     // Ensure no duplicate pass ids output.
 100     std::set<RenderPassId> used_passes;
 101     for (auto* pass : frame_data->render_pass_list) {
 102       EXPECT_TRUE(used_passes.insert(pass->id).second);
 103     }
 104
 105     EXPECT_EQ(expected_surface_count,
 106               aggregator_.previous_contained_surfaces().size());
 107     for (size_t i = 0; i < expected_surface_count; i++) {
 108       EXPECT_TRUE(
 109           aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
 110           aggregator_.previous_contained_surfaces().end());
 111     }
 112   }
 113
 114   void SubmitFrame(test::Pass* passes,
 115                    size_t pass_count,
 116                    SurfaceId surface_id) {
 117     RenderPassList pass_list;
 118     AddPasses(&pass_list, gfx::Rect(SurfaceSize()), passes, pass_count);
 119
 120     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
 121     pass_list.swap(frame_data->render_pass_list);
 122
 123     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
 124     frame->delegated_frame_data = frame_data.Pass();
 125
 126     factory_.SubmitFrame(surface_id, frame.Pass(),
 127                          SurfaceFactory::DrawCallback());
 128   }
 129
 130   void QueuePassAsFrame(scoped_ptr<RenderPass> pass, SurfaceId surface_id) {
 131     scoped_ptr<DelegatedFrameData> delegated_frame_data(new DelegatedFrameData);
 132     delegated_frame_data->render_pass_list.push_back(pass.Pass());
 133
 134     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
 135     child_frame->delegated_frame_data = delegated_frame_data.Pass();
 136
 137     factory_.SubmitFrame(surface_id, child_frame.Pass(),
 138                          SurfaceFactory::DrawCallback());
 139   }
 140
 141  protected:
 142   SurfaceId root_surface_id_;
 143   SurfaceIdAllocator allocator_;
 144   SurfaceIdAllocator child_allocator_;
 145 };
 146
 147 // Tests that a very simple frame containing only two solid color quads makes it
 148 // through the aggregator correctly.
 149 TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleFrame) {
 150   test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorRED),
 151                         test::Quad::SolidColorQuad(SK_ColorBLUE)};
 152   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 153
 154   SubmitFrame(passes, arraysize(passes), root_surface_id_);
 155
 156   SurfaceId ids[] = {root_surface_id_};
 157   AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids));
 158 }
 159
 160 TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) {
 161   SurfaceId embedded_surface_id = allocator_.GenerateId();
 162   factory_.Create(embedded_surface_id);
 163
 164   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
 165                                  test::Quad::SolidColorQuad(SK_ColorBLUE)};
 166   test::Pass embedded_passes[] = {
 167       test::Pass(embedded_quads, arraysize(embedded_quads))};
 168
 169   SubmitFrame(embedded_passes, arraysize(embedded_passes), embedded_surface_id);
 170
 171   test::Quad quads[] = {test::Quad::SurfaceQuad(embedded_surface_id, .5f)};
 172   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 173
 174   SubmitFrame(passes, arraysize(passes), root_surface_id_);
 175
 176   scoped_ptr<CompositorFrame> aggregated_frame =
 177       aggregator_.Aggregate(root_surface_id_);
 178
 179   ASSERT_TRUE(aggregated_frame);
 180   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 181
 182   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 183
 184   RenderPassList& render_pass_list(frame_data->render_pass_list);
 185   ASSERT_EQ(2u, render_pass_list.size());
 186   SharedQuadStateList& shared_quad_state_list(
 187       render_pass_list[0]->shared_quad_state_list);
 188   ASSERT_EQ(2u, shared_quad_state_list.size());
 189   EXPECT_EQ(1.f, shared_quad_state_list.ElementAt(0)->opacity);
 190   EXPECT_EQ(1.f, shared_quad_state_list.ElementAt(1)->opacity);
 191
 192   SharedQuadStateList& shared_quad_state_list2(
 193       render_pass_list[1]->shared_quad_state_list);
 194   ASSERT_EQ(1u, shared_quad_state_list2.size());
 195   EXPECT_EQ(.5f, shared_quad_state_list2.ElementAt(0)->opacity);
 196
 197   factory_.Destroy(embedded_surface_id);
 198 }
 199
 200 TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSimpleFrame) {
 201   test::Quad quads[][2] = {{test::Quad::SolidColorQuad(SK_ColorWHITE),
 202                             test::Quad::SolidColorQuad(SK_ColorLTGRAY)},
 203                            {test::Quad::SolidColorQuad(SK_ColorGRAY),
 204                             test::Quad::SolidColorQuad(SK_ColorDKGRAY)}};
 205   test::Pass passes[] = {
 206       test::Pass(quads[0], arraysize(quads[0]), RenderPassId(1, 1)),
 207       test::Pass(quads[1], arraysize(quads[1]), RenderPassId(1, 2))};
 208
 209   SubmitFrame(passes, arraysize(passes), root_surface_id_);
 210
 211   SurfaceId ids[] = {root_surface_id_};
 212   AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids));
 213 }
 214
 215 // This tests very simple embedding. root_surface has a frame containing a few
 216 // solid color quads and a surface quad referencing embedded_surface.
 217 // embedded_surface has a frame containing only a solid color quad. The solid
 218 // color quad should be aggregated into the final frame.
 219 TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleSurfaceReference) {
 220   SurfaceId embedded_surface_id = allocator_.GenerateId();
 221   factory_.Create(embedded_surface_id);
 222
 223   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
 224   test::Pass embedded_passes[] = {
 225       test::Pass(embedded_quads, arraysize(embedded_quads))};
 226
 227   SubmitFrame(embedded_passes, arraysize(embedded_passes), embedded_surface_id);
 228
 229   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
 230                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
 231                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
 232   test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 233
 234   SubmitFrame(root_passes, arraysize(root_passes), root_surface_id_);
 235
 236   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
 237                                  test::Quad::SolidColorQuad(SK_ColorGREEN),
 238                                  test::Quad::SolidColorQuad(SK_ColorBLACK)};
 239   test::Pass expected_passes[] = {
 240       test::Pass(expected_quads, arraysize(expected_quads))};
 241   SurfaceId ids[] = {root_surface_id_, embedded_surface_id};
 242   AggregateAndVerify(
 243       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 244
 245   factory_.Destroy(embedded_surface_id);
 246 }
 247
 248 TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) {
 249   SurfaceId embedded_surface_id = allocator_.GenerateId();
 250   factory_.Create(embedded_surface_id);
 251
 252   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
 253   test::Pass embedded_passes[] = {
 254       test::Pass(embedded_quads, arraysize(embedded_quads))};
 255
 256   SubmitFrame(embedded_passes, arraysize(embedded_passes), embedded_surface_id);
 257   scoped_ptr<CopyOutputRequest> copy_request(
 258       CopyOutputRequest::CreateEmptyRequest());
 259   CopyOutputRequest* copy_request_ptr = copy_request.get();
 260   factory_.RequestCopyOfSurface(embedded_surface_id, copy_request.Pass());
 261
 262   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
 263                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
 264                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
 265   test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 266
 267   SubmitFrame(root_passes, arraysize(root_passes), root_surface_id_);
 268
 269   scoped_ptr<CompositorFrame> aggregated_frame =
 270       aggregator_.Aggregate(root_surface_id_);
 271
 272   ASSERT_TRUE(aggregated_frame);
 273   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 274
 275   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 276
 277   test::Quad expected_quads[] = {
 278       test::Quad::SolidColorQuad(SK_ColorWHITE),
 279       test::Quad::RenderPassQuad(frame_data->render_pass_list[0]->id),
 280       test::Quad::SolidColorQuad(SK_ColorBLACK)};
 281   test::Pass expected_passes[] = {
 282       test::Pass(embedded_quads, arraysize(embedded_quads)),
 283       test::Pass(expected_quads, arraysize(expected_quads))};
 284   TestPassesMatchExpectations(expected_passes,
 285                               arraysize(expected_passes),
 286                               &frame_data->render_pass_list);
 287   ASSERT_EQ(2u, frame_data->render_pass_list.size());
 288   ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());
 289   DCHECK_EQ(copy_request_ptr,
 290             frame_data->render_pass_list[0]->copy_requests[0]);
 291
 292   SurfaceId surface_ids[] = {root_surface_id_, embedded_surface_id};
 293   EXPECT_EQ(arraysize(surface_ids),
 294             aggregator_.previous_contained_surfaces().size());
 295   for (size_t i = 0; i < arraysize(surface_ids); i++) {
 296     EXPECT_TRUE(
 297         aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
 298         aggregator_.previous_contained_surfaces().end());
 299   }
 300
 301   factory_.Destroy(embedded_surface_id);
 302 }
 303
 304 // Root surface may contain copy requests.
 305 TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {
 306   SurfaceId embedded_surface_id = allocator_.GenerateId();
 307   factory_.Create(embedded_surface_id);
 308
 309   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
 310   test::Pass embedded_passes[] = {
 311       test::Pass(embedded_quads, arraysize(embedded_quads))};
 312
 313   SubmitFrame(embedded_passes, arraysize(embedded_passes), embedded_surface_id);
 314   scoped_ptr<CopyOutputRequest> copy_request(
 315       CopyOutputRequest::CreateEmptyRequest());
 316   CopyOutputRequest* copy_request_ptr = copy_request.get();
 317   scoped_ptr<CopyOutputRequest> copy_request2(
 318       CopyOutputRequest::CreateEmptyRequest());
 319   CopyOutputRequest* copy_request2_ptr = copy_request2.get();
 320
 321   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
 322                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
 323                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
 324   test::Quad root_quads2[] = {test::Quad::SolidColorQuad(SK_ColorRED)};
 325   test::Pass root_passes[] = {
 326       test::Pass(root_quads, arraysize(root_quads), RenderPassId(1, 1)),
 327       test::Pass(root_quads2, arraysize(root_quads2), RenderPassId(1, 2))};
 328   {
 329     RenderPassList pass_list;
 330     AddPasses(&pass_list,
 331               gfx::Rect(SurfaceSize()),
 332               root_passes,
 333               arraysize(root_passes));
 334     pass_list[0]->copy_requests.push_back(copy_request.Pass());
 335     pass_list[1]->copy_requests.push_back(copy_request2.Pass());
 336
 337     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
 338     pass_list.swap(frame_data->render_pass_list);
 339
 340     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
 341     frame->delegated_frame_data = frame_data.Pass();
 342
 343     factory_.SubmitFrame(root_surface_id_, frame.Pass(),
 344                          SurfaceFactory::DrawCallback());
 345   }
 346
 347   scoped_ptr<CompositorFrame> aggregated_frame =
 348       aggregator_.Aggregate(root_surface_id_);
 349
 350   ASSERT_TRUE(aggregated_frame);
 351   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 352
 353   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 354
 355   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
 356                                  test::Quad::SolidColorQuad(SK_ColorGREEN),
 357                                  test::Quad::SolidColorQuad(SK_ColorBLACK)};
 358   test::Pass expected_passes[] = {
 359       test::Pass(expected_quads, arraysize(expected_quads)),
 360       test::Pass(root_quads2, arraysize(root_quads2))};
 361   TestPassesMatchExpectations(expected_passes,
 362                               arraysize(expected_passes),
 363                               &frame_data->render_pass_list);
 364   ASSERT_EQ(2u, frame_data->render_pass_list.size());
 365   ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());
 366   DCHECK_EQ(copy_request_ptr,
 367             frame_data->render_pass_list[0]->copy_requests[0]);
 368   ASSERT_EQ(1u, frame_data->render_pass_list[1]->copy_requests.size());
 369   DCHECK_EQ(copy_request2_ptr,
 370             frame_data->render_pass_list[1]->copy_requests[0]);
 371
 372   SurfaceId surface_ids[] = {root_surface_id_, embedded_surface_id};
 373   EXPECT_EQ(arraysize(surface_ids),
 374             aggregator_.previous_contained_surfaces().size());
 375   for (size_t i = 0; i < arraysize(surface_ids); i++) {
 376     EXPECT_TRUE(
 377         aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
 378         aggregator_.previous_contained_surfaces().end());
 379   }
 380
 381   // Ensure copy requests have been removed from root surface.
 382   const CompositorFrame* original_frame =
 383       manager_.GetSurfaceForId(root_surface_id_)->GetEligibleFrame();
 384   RenderPassList& original_pass_list =
 385       original_frame->delegated_frame_data->render_pass_list;
 386   ASSERT_EQ(2u, original_pass_list.size());
 387   DCHECK(original_pass_list[0]->copy_requests.empty());
 388   DCHECK(original_pass_list[1]->copy_requests.empty());
 389
 390   factory_.Destroy(embedded_surface_id);
 391 }
 392
 393 // This tests referencing a surface that has multiple render passes.
 394 TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) {
 395   SurfaceId embedded_surface_id = child_allocator_.GenerateId();
 396   factory_.Create(embedded_surface_id);
 397
 398   RenderPassId pass_ids[] = {RenderPassId(1, 1), RenderPassId(1, 2),
 399                              RenderPassId(1, 3)};
 400
 401   test::Quad embedded_quads[][2] = {
 402       {test::Quad::SolidColorQuad(1), test::Quad::SolidColorQuad(2)},
 403       {test::Quad::SolidColorQuad(3), test::Quad::RenderPassQuad(pass_ids[0])},
 404       {test::Quad::SolidColorQuad(4), test::Quad::RenderPassQuad(pass_ids[1])}};
 405   test::Pass embedded_passes[] = {
 406       test::Pass(embedded_quads[0], arraysize(embedded_quads[0]), pass_ids[0]),
 407       test::Pass(embedded_quads[1], arraysize(embedded_quads[1]), pass_ids[1]),
 408       test::Pass(embedded_quads[2], arraysize(embedded_quads[2]), pass_ids[2])};
 409
 410   SubmitFrame(embedded_passes, arraysize(embedded_passes), embedded_surface_id);
 411
 412   test::Quad root_quads[][2] = {
 413       {test::Quad::SolidColorQuad(5), test::Quad::SolidColorQuad(6)},
 414       {test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
 415        test::Quad::RenderPassQuad(pass_ids[0])},
 416       {test::Quad::SolidColorQuad(7), test::Quad::RenderPassQuad(pass_ids[1])}};
 417   test::Pass root_passes[] = {
 418       test::Pass(root_quads[0], arraysize(root_quads[0]), pass_ids[0]),
 419       test::Pass(root_quads[1], arraysize(root_quads[1]), pass_ids[1]),
 420       test::Pass(root_quads[2], arraysize(root_quads[2]), pass_ids[2])};
 421
 422   SubmitFrame(root_passes, arraysize(root_passes), root_surface_id_);
 423
 424   scoped_ptr<CompositorFrame> aggregated_frame =
 425       aggregator_.Aggregate(root_surface_id_);
 426
 427   ASSERT_TRUE(aggregated_frame);
 428   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 429
 430   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 431
 432   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 433
 434   ASSERT_EQ(5u, aggregated_pass_list.size());
 435   RenderPassId actual_pass_ids[] = {
 436       aggregated_pass_list[0]->id, aggregated_pass_list[1]->id,
 437       aggregated_pass_list[2]->id, aggregated_pass_list[3]->id,
 438       aggregated_pass_list[4]->id};
 439   for (size_t i = 0; i < 5; ++i) {
 440     for (size_t j = 0; j < i; ++j) {
 441       EXPECT_NE(actual_pass_ids[i], actual_pass_ids[j]);
 442     }
 443   }
 444
 445   {
 446     SCOPED_TRACE("First pass");
 447     // The first pass will just be the first pass from the root surfaces quad
 448     // with no render pass quads to remap.
 449     TestPassMatchesExpectations(root_passes[0], aggregated_pass_list[0]);
 450   }
 451
 452   {
 453     SCOPED_TRACE("Second pass");
 454     // The next two passes will be from the embedded surface since we have to
 455     // draw those passes before they are referenced from the render pass draw
 456     // quad embedded into the root surface's second pass.
 457     // First, there's the first embedded pass which doesn't reference anything
 458     // else.
 459     TestPassMatchesExpectations(embedded_passes[0], aggregated_pass_list[1]);
 460   }
 461
 462   {
 463     SCOPED_TRACE("Third pass");
 464     const QuadList& third_pass_quad_list = aggregated_pass_list[2]->quad_list;
 465     ASSERT_EQ(2u, third_pass_quad_list.size());
 466     TestQuadMatchesExpectations(embedded_quads[1][0],
 467                                 third_pass_quad_list.ElementAt(0));
 468
 469     // This render pass pass quad will reference the first pass from the
 470     // embedded surface, which is the second pass in the aggregated frame.
 471     ASSERT_EQ(DrawQuad::RENDER_PASS,
 472               third_pass_quad_list.ElementAt(1)->material);
 473     const RenderPassDrawQuad* third_pass_render_pass_draw_quad =
 474         RenderPassDrawQuad::MaterialCast(third_pass_quad_list.ElementAt(1));
 475     EXPECT_EQ(actual_pass_ids[1],
 476               third_pass_render_pass_draw_quad->render_pass_id);
 477   }
 478
 479   {
 480     SCOPED_TRACE("Fourth pass");
 481     // The fourth pass will have aggregated quads from the root surface's second
 482     // pass and the embedded surface's first pass.
 483     const QuadList& fourth_pass_quad_list = aggregated_pass_list[3]->quad_list;
 484     ASSERT_EQ(3u, fourth_pass_quad_list.size());
 485
 486     // The first quad will be the yellow quad from the embedded surface's last
 487     // pass.
 488     TestQuadMatchesExpectations(embedded_quads[2][0],
 489                                 fourth_pass_quad_list.ElementAt(0));
 490
 491     // The next quad will be a render pass quad referencing the second pass from
 492     // the embedded surface, which is the third pass in the aggregated frame.
 493     ASSERT_EQ(DrawQuad::RENDER_PASS,
 494               fourth_pass_quad_list.ElementAt(1)->material);
 495     const RenderPassDrawQuad* fourth_pass_first_render_pass_draw_quad =
 496         RenderPassDrawQuad::MaterialCast(fourth_pass_quad_list.ElementAt(1));
 497     EXPECT_EQ(actual_pass_ids[2],
 498               fourth_pass_first_render_pass_draw_quad->render_pass_id);
 499
 500     // The last quad will be a render pass quad referencing the first pass from
 501     // the root surface, which is the first pass overall.
 502     ASSERT_EQ(DrawQuad::RENDER_PASS,
 503               fourth_pass_quad_list.ElementAt(2)->material);
 504     const RenderPassDrawQuad* fourth_pass_second_render_pass_draw_quad =
 505         RenderPassDrawQuad::MaterialCast(fourth_pass_quad_list.ElementAt(2));
 506     EXPECT_EQ(actual_pass_ids[0],
 507               fourth_pass_second_render_pass_draw_quad->render_pass_id);
 508   }
 509
 510   {
 511     SCOPED_TRACE("Fifth pass");
 512     const QuadList& fifth_pass_quad_list = aggregated_pass_list[4]->quad_list;
 513     ASSERT_EQ(2u, fifth_pass_quad_list.size());
 514
 515     TestQuadMatchesExpectations(root_quads[2][0],
 516                                 fifth_pass_quad_list.ElementAt(0));
 517
 518     // The last quad in the last pass will reference the second pass from the
 519     // root surface, which after aggregating is the fourth pass in the overall
 520     // list.
 521     ASSERT_EQ(DrawQuad::RENDER_PASS,
 522               fifth_pass_quad_list.ElementAt(1)->material);
 523     const RenderPassDrawQuad* fifth_pass_render_pass_draw_quad =
 524         RenderPassDrawQuad::MaterialCast(fifth_pass_quad_list.ElementAt(1));
 525     EXPECT_EQ(actual_pass_ids[3],
 526               fifth_pass_render_pass_draw_quad->render_pass_id);
 527   }
 528   factory_.Destroy(embedded_surface_id);
 529 }
 530
 531 // Tests an invalid surface reference in a frame. The surface quad should just
 532 // be dropped.
 533 TEST_F(SurfaceAggregatorValidSurfaceTest, InvalidSurfaceReference) {
 534   test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
 535                         test::Quad::SurfaceQuad(InvalidSurfaceId(), 1.f),
 536                         test::Quad::SolidColorQuad(SK_ColorBLUE)};
 537   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 538
 539   SubmitFrame(passes, arraysize(passes), root_surface_id_);
 540
 541   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
 542                                  test::Quad::SolidColorQuad(SK_ColorBLUE)};
 543   test::Pass expected_passes[] = {
 544       test::Pass(expected_quads, arraysize(expected_quads))};
 545   SurfaceId ids[] = {root_surface_id_, InvalidSurfaceId()};
 546   AggregateAndVerify(
 547       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 548 }
 549
 550 // Tests a reference to a valid surface with no submitted frame. This quad
 551 // should also just be dropped.
 552 TEST_F(SurfaceAggregatorValidSurfaceTest, ValidSurfaceReferenceWithNoFrame) {
 553   SurfaceId surface_with_no_frame_id = allocator_.GenerateId();
 554   factory_.Create(surface_with_no_frame_id);
 555   test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
 556                         test::Quad::SurfaceQuad(surface_with_no_frame_id, 1.f),
 557                         test::Quad::SolidColorQuad(SK_ColorBLUE)};
 558   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 559
 560   SubmitFrame(passes, arraysize(passes), root_surface_id_);
 561
 562   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
 563                                  test::Quad::SolidColorQuad(SK_ColorBLUE)};
 564   test::Pass expected_passes[] = {
 565       test::Pass(expected_quads, arraysize(expected_quads))};
 566   SurfaceId ids[] = {root_surface_id_, surface_with_no_frame_id};
 567   AggregateAndVerify(
 568       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 569   factory_.Destroy(surface_with_no_frame_id);
 570 }
 571
 572 // Tests a surface quad referencing itself, generating a trivial cycle.
 573 // The quad creating the cycle should be dropped from the final frame.
 574 TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleCyclicalReference) {
 575   test::Quad quads[] = {test::Quad::SurfaceQuad(root_surface_id_, 1.f),
 576                         test::Quad::SolidColorQuad(SK_ColorYELLOW)};
 577   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 578
 579   SubmitFrame(passes, arraysize(passes), root_surface_id_);
 580
 581   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorYELLOW)};
 582   test::Pass expected_passes[] = {
 583       test::Pass(expected_quads, arraysize(expected_quads))};
 584   SurfaceId ids[] = {root_surface_id_};
 585   AggregateAndVerify(
 586       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 587 }
 588
 589 // Tests a more complex cycle with one intermediate surface.
 590 TEST_F(SurfaceAggregatorValidSurfaceTest, TwoSurfaceCyclicalReference) {
 591   SurfaceId child_surface_id = allocator_.GenerateId();
 592   factory_.Create(child_surface_id);
 593
 594   test::Quad parent_quads[] = {test::Quad::SolidColorQuad(SK_ColorBLUE),
 595                                test::Quad::SurfaceQuad(child_surface_id, 1.f),
 596                                test::Quad::SolidColorQuad(SK_ColorCYAN)};
 597   test::Pass parent_passes[] = {
 598       test::Pass(parent_quads, arraysize(parent_quads))};
 599
 600   SubmitFrame(parent_passes, arraysize(parent_passes), root_surface_id_);
 601
 602   test::Quad child_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
 603                               test::Quad::SurfaceQuad(root_surface_id_, 1.f),
 604                               test::Quad::SolidColorQuad(SK_ColorMAGENTA)};
 605   test::Pass child_passes[] = {test::Pass(child_quads, arraysize(child_quads))};
 606
 607   SubmitFrame(child_passes, arraysize(child_passes), child_surface_id);
 608
 609   // The child surface's reference to the root_surface_ will be dropped, so
 610   // we'll end up with:
 611   //   SK_ColorBLUE from the parent
 612   //   SK_ColorGREEN from the child
 613   //   SK_ColorMAGENTA from the child
 614   //   SK_ColorCYAN from the parent
 615   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorBLUE),
 616                                  test::Quad::SolidColorQuad(SK_ColorGREEN),
 617                                  test::Quad::SolidColorQuad(SK_ColorMAGENTA),
 618                                  test::Quad::SolidColorQuad(SK_ColorCYAN)};
 619   test::Pass expected_passes[] = {
 620       test::Pass(expected_quads, arraysize(expected_quads))};
 621   SurfaceId ids[] = {root_surface_id_, child_surface_id};
 622   AggregateAndVerify(
 623       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 624   factory_.Destroy(child_surface_id);
 625 }
 626
 627 // Tests that we map render pass IDs from different surfaces into a unified
 628 // namespace and update RenderPassDrawQuad's id references to match.
 629 TEST_F(SurfaceAggregatorValidSurfaceTest, RenderPassIdMapping) {
 630   SurfaceId child_surface_id = allocator_.GenerateId();
 631   factory_.Create(child_surface_id);
 632
 633   RenderPassId child_pass_id[] = {RenderPassId(1, 1), RenderPassId(1, 2)};
 634   test::Quad child_quad[][1] = {{test::Quad::SolidColorQuad(SK_ColorGREEN)},
 635                                 {test::Quad::RenderPassQuad(child_pass_id[0])}};
 636   test::Pass surface_passes[] = {
 637       test::Pass(child_quad[0], arraysize(child_quad[0]), child_pass_id[0]),
 638       test::Pass(child_quad[1], arraysize(child_quad[1]), child_pass_id[1])};
 639
 640   SubmitFrame(surface_passes, arraysize(surface_passes), child_surface_id);
 641
 642   // Pass IDs from the parent surface may collide with ones from the child.
 643   RenderPassId parent_pass_id[] = {RenderPassId(2, 1), RenderPassId(1, 2)};
 644   test::Quad parent_quad[][1] = {
 645       {test::Quad::SurfaceQuad(child_surface_id, 1.f)},
 646       {test::Quad::RenderPassQuad(parent_pass_id[0])}};
 647   test::Pass parent_passes[] = {
 648       test::Pass(parent_quad[0], arraysize(parent_quad[0]), parent_pass_id[0]),
 649       test::Pass(parent_quad[1], arraysize(parent_quad[1]), parent_pass_id[1])};
 650
 651   SubmitFrame(parent_passes, arraysize(parent_passes), root_surface_id_);
 652   scoped_ptr<CompositorFrame> aggregated_frame =
 653       aggregator_.Aggregate(root_surface_id_);
 654
 655   ASSERT_TRUE(aggregated_frame);
 656   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 657
 658   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 659
 660   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 661
 662   ASSERT_EQ(3u, aggregated_pass_list.size());
 663   RenderPassId actual_pass_ids[] = {aggregated_pass_list[0]->id,
 664                                     aggregated_pass_list[1]->id,
 665                                     aggregated_pass_list[2]->id};
 666   // Make sure the aggregated frame's pass IDs are all unique.
 667   for (size_t i = 0; i < 3; ++i) {
 668     for (size_t j = 0; j < i; ++j) {
 669       EXPECT_NE(actual_pass_ids[j], actual_pass_ids[i]) << "pass ids " << i
 670                                                         << " and " << j;
 671     }
 672   }
 673
 674   // Make sure the render pass quads reference the remapped pass IDs.
 675   DrawQuad* render_pass_quads[] = {aggregated_pass_list[1]->quad_list.front(),
 676                                    aggregated_pass_list[2]->quad_list.front()};
 677   ASSERT_EQ(render_pass_quads[0]->material, DrawQuad::RENDER_PASS);
 678   EXPECT_EQ(
 679       actual_pass_ids[0],
 680       RenderPassDrawQuad::MaterialCast(render_pass_quads[0])->render_pass_id);
 681
 682   ASSERT_EQ(render_pass_quads[1]->material, DrawQuad::RENDER_PASS);
 683   EXPECT_EQ(
 684       actual_pass_ids[1],
 685       RenderPassDrawQuad::MaterialCast(render_pass_quads[1])->render_pass_id);
 686   factory_.Destroy(child_surface_id);
 687 }
 688
 689 void AddSolidColorQuadWithBlendMode(const gfx::Size& size,
 690                                     RenderPass* pass,
 691                                     const SkXfermode::Mode blend_mode) {
 692   const gfx::Transform content_to_target_transform;
 693   const gfx::Size content_bounds(size);
 694   const gfx::Rect visible_content_rect(size);
 695   const gfx::Rect clip_rect(size);
 696
 697   bool is_clipped = false;
 698   float opacity = 1.f;
 699
 700   bool force_anti_aliasing_off = false;
 701   SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
 702   sqs->SetAll(content_to_target_transform,
 703               content_bounds,
 704               visible_content_rect,
 705               clip_rect,
 706               is_clipped,
 707               opacity,
 708               blend_mode,
 709               0);
 710
 711   SolidColorDrawQuad* color_quad =
 712       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 713   color_quad->SetNew(pass->shared_quad_state_list.back(),
 714                      visible_content_rect,
 715                      visible_content_rect,
 716                      SK_ColorGREEN,
 717                      force_anti_aliasing_off);
 718 }
 719
 720 // This tests that we update shared quad state pointers correctly within
 721 // aggregated passes.  The shared quad state list on the aggregated pass will
 722 // include the shared quad states from each pass in one list so the quads will
 723 // end up pointed to shared quad state objects at different offsets. This test
 724 // uses the blend_mode value stored on the shared quad state to track the shared
 725 // quad state, but anything saved on the shared quad state would work.
 726 //
 727 // This test has 4 surfaces in the following structure:
 728 // root_surface -> quad with kClear_Mode,
 729 //                 [child_one_surface],
 730 //                 quad with kDstOver_Mode,
 731 //                 [child_two_surface],
 732 //                 quad with kDstIn_Mode
 733 // child_one_surface -> quad with kSrc_Mode,
 734 //                      [grandchild_surface],
 735 //                      quad with kSrcOver_Mode
 736 // child_two_surface -> quad with kSrcIn_Mode
 737 // grandchild_surface -> quad with kDst_Mode
 738 //
 739 // Resulting in the following aggregated pass:
 740 //  quad_root_0       - blend_mode kClear_Mode
 741 //  quad_child_one_0  - blend_mode kSrc_Mode
 742 //  quad_grandchild_0 - blend_mode kDst_Mode
 743 //  quad_child_one_1  - blend_mode kSrcOver_Mode
 744 //  quad_root_1       - blend_mode kDstOver_Mode
 745 //  quad_child_two_0  - blend_mode kSrcIn_Mode
 746 //  quad_root_2       - blend_mode kDstIn_Mode
 747 TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) {
 748   const SkXfermode::Mode blend_modes[] = {SkXfermode::kClear_Mode,    // 0
 749                                           SkXfermode::kSrc_Mode,      // 1
 750                                           SkXfermode::kDst_Mode,      // 2
 751                                           SkXfermode::kSrcOver_Mode,  // 3
 752                                           SkXfermode::kDstOver_Mode,  // 4
 753                                           SkXfermode::kSrcIn_Mode,    // 5
 754                                           SkXfermode::kDstIn_Mode,    // 6
 755   };
 756
 757   RenderPassId pass_id(1, 1);
 758   SurfaceId grandchild_surface_id = allocator_.GenerateId();
 759   factory_.Create(grandchild_surface_id);
 760   scoped_ptr<RenderPass> grandchild_pass = RenderPass::Create();
 761   gfx::Rect output_rect(SurfaceSize());
 762   gfx::Rect damage_rect(SurfaceSize());
 763   gfx::Transform transform_to_root_target;
 764   grandchild_pass->SetNew(
 765       pass_id, output_rect, damage_rect, transform_to_root_target);
 766   AddSolidColorQuadWithBlendMode(
 767       SurfaceSize(), grandchild_pass.get(), blend_modes[2]);
 768   QueuePassAsFrame(grandchild_pass.Pass(), grandchild_surface_id);
 769
 770   SurfaceId child_one_surface_id = allocator_.GenerateId();
 771   factory_.Create(child_one_surface_id);
 772
 773   scoped_ptr<RenderPass> child_one_pass = RenderPass::Create();
 774   child_one_pass->SetNew(
 775       pass_id, output_rect, damage_rect, transform_to_root_target);
 776   AddSolidColorQuadWithBlendMode(
 777       SurfaceSize(), child_one_pass.get(), blend_modes[1]);
 778   SurfaceDrawQuad* grandchild_surface_quad =
 779       child_one_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
 780   grandchild_surface_quad->SetNew(child_one_pass->shared_quad_state_list.back(),
 781                                   gfx::Rect(SurfaceSize()),
 782                                   gfx::Rect(SurfaceSize()),
 783                                   grandchild_surface_id);
 784   AddSolidColorQuadWithBlendMode(
 785       SurfaceSize(), child_one_pass.get(), blend_modes[3]);
 786   QueuePassAsFrame(child_one_pass.Pass(), child_one_surface_id);
 787
 788   SurfaceId child_two_surface_id = allocator_.GenerateId();
 789   factory_.Create(child_two_surface_id);
 790
 791   scoped_ptr<RenderPass> child_two_pass = RenderPass::Create();
 792   child_two_pass->SetNew(
 793       pass_id, output_rect, damage_rect, transform_to_root_target);
 794   AddSolidColorQuadWithBlendMode(
 795       SurfaceSize(), child_two_pass.get(), blend_modes[5]);
 796   QueuePassAsFrame(child_two_pass.Pass(), child_two_surface_id);
 797
 798   scoped_ptr<RenderPass> root_pass = RenderPass::Create();
 799   root_pass->SetNew(
 800       pass_id, output_rect, damage_rect, transform_to_root_target);
 801
 802   AddSolidColorQuadWithBlendMode(
 803       SurfaceSize(), root_pass.get(), blend_modes[0]);
 804   SurfaceDrawQuad* child_one_surface_quad =
 805       root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
 806   child_one_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
 807                                  gfx::Rect(SurfaceSize()),
 808                                  gfx::Rect(SurfaceSize()),
 809                                  child_one_surface_id);
 810   AddSolidColorQuadWithBlendMode(
 811       SurfaceSize(), root_pass.get(), blend_modes[4]);
 812   SurfaceDrawQuad* child_two_surface_quad =
 813       root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
 814   child_two_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
 815                                  gfx::Rect(SurfaceSize()),
 816                                  gfx::Rect(SurfaceSize()),
 817                                  child_two_surface_id);
 818   AddSolidColorQuadWithBlendMode(
 819       SurfaceSize(), root_pass.get(), blend_modes[6]);
 820
 821   QueuePassAsFrame(root_pass.Pass(), root_surface_id_);
 822
 823   scoped_ptr<CompositorFrame> aggregated_frame =
 824       aggregator_.Aggregate(root_surface_id_);
 825
 826   ASSERT_TRUE(aggregated_frame);
 827   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 828
 829   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 830
 831   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 832
 833   ASSERT_EQ(1u, aggregated_pass_list.size());
 834
 835   const QuadList& aggregated_quad_list = aggregated_pass_list[0]->quad_list;
 836
 837   ASSERT_EQ(7u, aggregated_quad_list.size());
 838
 839   for (auto iter = aggregated_quad_list.cbegin();
 840        iter != aggregated_quad_list.cend();
 841        ++iter) {
 842     EXPECT_EQ(blend_modes[iter.index()], iter->shared_quad_state->blend_mode)
 843         << iter.index();
 844   }
 845   factory_.Destroy(child_one_surface_id);
 846   factory_.Destroy(child_two_surface_id);
 847   factory_.Destroy(grandchild_surface_id);
 848 }
 849
 850 // This tests that when aggregating a frame with multiple render passes that we
 851 // map the transforms for the root pass but do not modify the transform on child
 852 // passes.
 853 //
 854 // The root surface has one pass with a surface quad transformed by +10 in the y
 855 // direction.
 856 //
 857 // The middle surface has one pass with a surface quad scaled by 2 in the x
 858 // and 3 in the y directions.
 859 //
 860 // The child surface has two passes. The first pass has a quad with a transform
 861 // of +5 in the x direction. The second pass has a reference to the first pass'
 862 // pass id and a transform of +8 in the x direction.
 863 //
 864 // After aggregation, the child surface's root pass quad should have all
 865 // transforms concatenated for a total transform of +23 x, +10 y. The
 866 // contributing render pass' transform in the aggregate frame should not be
 867 // affected.
 868 TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {
 869   // Innermost child surface.
 870   SurfaceId child_surface_id = allocator_.GenerateId();
 871   {
 872     factory_.Create(child_surface_id);
 873     RenderPassId child_pass_id[] = {RenderPassId(1, 1), RenderPassId(1, 2)};
 874     test::Quad child_quads[][1] = {
 875         {test::Quad::SolidColorQuad(SK_ColorGREEN)},
 876         {test::Quad::RenderPassQuad(child_pass_id[0])},
 877     };
 878     test::Pass child_passes[] = {
 879         test::Pass(child_quads[0], arraysize(child_quads[0]), child_pass_id[0]),
 880         test::Pass(child_quads[1], arraysize(child_quads[1]),
 881                    child_pass_id[1])};
 882
 883     RenderPassList child_pass_list;
 884     AddPasses(&child_pass_list, gfx::Rect(SurfaceSize()), child_passes,
 885               arraysize(child_passes));
 886
 887     RenderPass* child_nonroot_pass = child_pass_list.at(0u);
 888     child_nonroot_pass->transform_to_root_target.Translate(8, 0);
 889     SharedQuadState* child_nonroot_pass_sqs =
 890         child_nonroot_pass->shared_quad_state_list.front();
 891     child_nonroot_pass_sqs->content_to_target_transform.Translate(5, 0);
 892
 893     RenderPass* child_root_pass = child_pass_list.at(1u);
 894     SharedQuadState* child_root_pass_sqs =
 895         child_root_pass->shared_quad_state_list.front();
 896     child_root_pass_sqs->content_to_target_transform.Translate(8, 0);
 897     child_root_pass_sqs->is_clipped = true;
 898     child_root_pass_sqs->clip_rect = gfx::Rect(0, 0, 5, 5);
 899
 900     scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
 901     child_pass_list.swap(child_frame_data->render_pass_list);
 902
 903     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
 904     child_frame->delegated_frame_data = child_frame_data.Pass();
 905
 906     factory_.SubmitFrame(child_surface_id, child_frame.Pass(),
 907                          SurfaceFactory::DrawCallback());
 908   }
 909
 910   // Middle child surface.
 911   SurfaceId middle_surface_id = allocator_.GenerateId();
 912   {
 913     factory_.Create(middle_surface_id);
 914     test::Quad middle_quads[] = {
 915         test::Quad::SurfaceQuad(child_surface_id, 1.f)};
 916     test::Pass middle_passes[] = {
 917         test::Pass(middle_quads, arraysize(middle_quads)),
 918     };
 919
 920     RenderPassList middle_pass_list;
 921     AddPasses(&middle_pass_list, gfx::Rect(SurfaceSize()), middle_passes,
 922               arraysize(middle_passes));
 923
 924     RenderPass* middle_root_pass = middle_pass_list.at(0u);
 925     middle_root_pass->quad_list.ElementAt(0)->visible_rect =
 926         gfx::Rect(0, 1, 100, 7);
 927     SharedQuadState* middle_root_pass_sqs =
 928         middle_root_pass->shared_quad_state_list.front();
 929     middle_root_pass_sqs->content_to_target_transform.Scale(2, 3);
 930
 931     scoped_ptr<DelegatedFrameData> middle_frame_data(new DelegatedFrameData);
 932     middle_pass_list.swap(middle_frame_data->render_pass_list);
 933
 934     scoped_ptr<CompositorFrame> middle_frame(new CompositorFrame);
 935     middle_frame->delegated_frame_data = middle_frame_data.Pass();
 936
 937     factory_.SubmitFrame(middle_surface_id, middle_frame.Pass(),
 938                          SurfaceFactory::DrawCallback());
 939   }
 940
 941   // Root surface.
 942   test::Quad secondary_quads[] = {
 943       test::Quad::SolidColorQuad(1),
 944       test::Quad::SurfaceQuad(middle_surface_id, 1.f)};
 945   test::Quad root_quads[] = {test::Quad::SolidColorQuad(1)};
 946   test::Pass root_passes[] = {
 947       test::Pass(secondary_quads, arraysize(secondary_quads)),
 948       test::Pass(root_quads, arraysize(root_quads))};
 949
 950   RenderPassList root_pass_list;
 951   AddPasses(&root_pass_list,
 952             gfx::Rect(SurfaceSize()),
 953             root_passes,
 954             arraysize(root_passes));
 955
 956   root_pass_list.at(0)
 957       ->shared_quad_state_list.front()
 958       ->content_to_target_transform.Translate(0, 7);
 959   root_pass_list.at(0)
 960       ->shared_quad_state_list.ElementAt(1)
 961       ->content_to_target_transform.Translate(0, 10);
 962   root_pass_list.at(0)->quad_list.ElementAt(1)->visible_rect =
 963       gfx::Rect(0, 0, 8, 100);
 964
 965   root_pass_list[0]->transform_to_root_target.Translate(10, 5);
 966
 967   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
 968   root_pass_list.swap(root_frame_data->render_pass_list);
 969
 970   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
 971   root_frame->delegated_frame_data = root_frame_data.Pass();
 972
 973   factory_.SubmitFrame(root_surface_id_, root_frame.Pass(),
 974                        SurfaceFactory::DrawCallback());
 975
 976   scoped_ptr<CompositorFrame> aggregated_frame =
 977       aggregator_.Aggregate(root_surface_id_);
 978
 979   ASSERT_TRUE(aggregated_frame);
 980   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 981
 982   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 983
 984   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 985
 986   ASSERT_EQ(3u, aggregated_pass_list.size());
 987
 988   ASSERT_EQ(1u, aggregated_pass_list[0]->shared_quad_state_list.size());
 989
 990   // The first pass should have one shared quad state for the one solid color
 991   // quad.
 992   EXPECT_EQ(1u, aggregated_pass_list[0]->shared_quad_state_list.size());
 993   // The second pass should have just two shared quad states. We'll
 994   // verify the properties through the quads.
 995   EXPECT_EQ(2u, aggregated_pass_list[1]->shared_quad_state_list.size());
 996
 997   EXPECT_EQ(1u, aggregated_pass_list[2]->shared_quad_state_list.size());
 998
 999   SharedQuadState* aggregated_first_pass_sqs =
1000       aggregated_pass_list[0]->shared_quad_state_list.front();
1001
1002   // The first pass's transform should be unaffected by the embedding and still
1003   // be a translation by +5 in the x direction.
1004   gfx::Transform expected_aggregated_first_pass_sqs_transform;
1005   expected_aggregated_first_pass_sqs_transform.Translate(5, 0);
1006   EXPECT_EQ(expected_aggregated_first_pass_sqs_transform.ToString(),
1007             aggregated_first_pass_sqs->content_to_target_transform.ToString());
1008
1009   // The first pass's transform to the root target should include the aggregated
1010   // transform, including the transform from the child pass to the root.
1011   gfx::Transform expected_first_pass_transform_to_root_target;
1012   expected_first_pass_transform_to_root_target.Translate(10, 5);
1013   expected_first_pass_transform_to_root_target.Translate(0, 10);
1014   expected_first_pass_transform_to_root_target.Scale(2, 3);
1015   expected_first_pass_transform_to_root_target.Translate(8, 0);
1016   EXPECT_EQ(expected_first_pass_transform_to_root_target.ToString(),
1017             aggregated_pass_list[0]->transform_to_root_target.ToString());
1018
1019   ASSERT_EQ(2u, aggregated_pass_list[1]->quad_list.size());
1020
1021   gfx::Transform expected_root_pass_quad_transforms[2];
1022   // The first quad in the root pass is the solid color quad from the original
1023   // root surface. Its transform should be unaffected by the aggregation and
1024   // still be +7 in the y direction.
1025   expected_root_pass_quad_transforms[0].Translate(0, 7);
1026   // The second quad in the root pass is aggregated from the child surface so
1027   // its transform should be the combination of its original translation
1028   // (0, 10), the middle surface draw quad's scale of (2, 3), and the
1029   // child surface draw quad's translation (8, 0).
1030   expected_root_pass_quad_transforms[1].Translate(0, 10);
1031   expected_root_pass_quad_transforms[1].Scale(2, 3);
1032   expected_root_pass_quad_transforms[1].Translate(8, 0);
1033
1034   for (auto iter = aggregated_pass_list[1]->quad_list.cbegin();
1035        iter != aggregated_pass_list[1]->quad_list.cend();
1036        ++iter) {
1037     EXPECT_EQ(expected_root_pass_quad_transforms[iter.index()].ToString(),
1038               iter->quadTransform().ToString())
1039         << iter.index();
1040   }
1041
1042   EXPECT_TRUE(
1043       aggregated_pass_list[1]->shared_quad_state_list.ElementAt(1)->is_clipped);
1044
1045   // The second quad in the root pass is aggregated from the child, so its
1046   // clip rect must be transformed by the child's translation/scale and
1047   // clipped be the visible_rects for both children.
1048   EXPECT_EQ(gfx::Rect(0, 13, 8, 12).ToString(),
1049             aggregated_pass_list[1]
1050                 ->shared_quad_state_list.ElementAt(1)
1051                 ->clip_rect.ToString());
1052
1053   factory_.Destroy(middle_surface_id);
1054   factory_.Destroy(child_surface_id);
1055 }
1056
1057 // Tests that damage rects are aggregated correctly when surfaces change.
1058 TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
1059   SurfaceId child_surface_id = allocator_.GenerateId();
1060   factory_.Create(child_surface_id);
1061   RenderPassId child_pass_id = RenderPassId(1, 1);
1062   test::Quad child_quads[] = {test::Quad::RenderPassQuad(child_pass_id)};
1063   test::Pass child_passes[] = {
1064       test::Pass(child_quads, arraysize(child_quads), child_pass_id)};
1065
1066   RenderPassList child_pass_list;
1067   AddPasses(&child_pass_list,
1068             gfx::Rect(SurfaceSize()),
1069             child_passes,
1070             arraysize(child_passes));
1071
1072   RenderPass* child_root_pass = child_pass_list.at(0u);
1073   SharedQuadState* child_root_pass_sqs =
1074       child_root_pass->shared_quad_state_list.front();
1075   child_root_pass_sqs->content_to_target_transform.Translate(8, 0);
1076
1077   scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
1078   child_pass_list.swap(child_frame_data->render_pass_list);
1079
1080   scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
1081   child_frame->delegated_frame_data = child_frame_data.Pass();
1082
1083   factory_.SubmitFrame(child_surface_id, child_frame.Pass(),
1084                        SurfaceFactory::DrawCallback());
1085
1086   RenderPassId pass_id(5, 10);
1087   test::Quad first_quads[] = {test::Quad::SurfaceQuad(child_surface_id, 1.f)};
1088   test::Quad root_quads[] = {test::Quad::RenderPassQuad(pass_id)};
1089
1090   test::Pass root_passes[] = {
1091       test::Pass(first_quads, arraysize(first_quads), pass_id),
1092       test::Pass(root_quads, arraysize(root_quads))};
1093
1094   RenderPassList root_pass_list;
1095   AddPasses(&root_pass_list,
1096             gfx::Rect(SurfaceSize()),
1097             root_passes,
1098             arraysize(root_passes));
1099
1100   root_pass_list.at(0)
1101       ->shared_quad_state_list.front()
1102       ->content_to_target_transform.Translate(0, 10);
1103   root_pass_list.at(0)->damage_rect = gfx::Rect(5, 5, 10, 10);
1104   root_pass_list.at(1)->damage_rect = gfx::Rect(5, 5, 100, 100);
1105
1106   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
1107   root_pass_list.swap(root_frame_data->render_pass_list);
1108
1109   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
1110   root_frame->delegated_frame_data = root_frame_data.Pass();
1111
1112   factory_.SubmitFrame(root_surface_id_, root_frame.Pass(),
1113                        SurfaceFactory::DrawCallback());
1114
1115   scoped_ptr<CompositorFrame> aggregated_frame =
1116       aggregator_.Aggregate(root_surface_id_);
1117
1118   ASSERT_TRUE(aggregated_frame);
1119   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
1120
1121   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
1122
1123   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
1124
1125   ASSERT_EQ(2u, aggregated_pass_list.size());
1126
1127   // Damage rect for first aggregation should contain entire root surface.
1128   EXPECT_TRUE(
1129       aggregated_pass_list[1]->damage_rect.Contains(gfx::Rect(SurfaceSize())));
1130
1131   {
1132     AddPasses(&child_pass_list,
1133               gfx::Rect(SurfaceSize()),
1134               child_passes,
1135               arraysize(child_passes));
1136
1137     RenderPass* child_root_pass = child_pass_list.at(0u);
1138     SharedQuadState* child_root_pass_sqs =
1139         child_root_pass->shared_quad_state_list.front();
1140     child_root_pass_sqs->content_to_target_transform.Translate(8, 0);
1141     child_root_pass->damage_rect = gfx::Rect(10, 10, 10, 10);
1142
1143     scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
1144     child_pass_list.swap(child_frame_data->render_pass_list);
1145
1146     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
1147     child_frame->delegated_frame_data = child_frame_data.Pass();
1148
1149     factory_.SubmitFrame(child_surface_id, child_frame.Pass(),
1150                          SurfaceFactory::DrawCallback());
1151
1152     scoped_ptr<CompositorFrame> aggregated_frame =
1153         aggregator_.Aggregate(root_surface_id_);
1154
1155     ASSERT_TRUE(aggregated_frame);
1156     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
1157
1158     DelegatedFrameData* frame_data =
1159         aggregated_frame->delegated_frame_data.get();
1160
1161     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
1162
1163     ASSERT_EQ(2u, aggregated_pass_list.size());
1164
1165     // Outer surface didn't change, so transformed inner damage rect should be
1166     // used.
1167     EXPECT_EQ(gfx::Rect(10, 20, 10, 10).ToString(),
1168               aggregated_pass_list[1]->damage_rect.ToString());
1169   }
1170
1171   {
1172     RenderPassList root_pass_list;
1173     AddPasses(&root_pass_list,
1174               gfx::Rect(SurfaceSize()),
1175               root_passes,
1176               arraysize(root_passes));
1177
1178     root_pass_list.at(0)
1179         ->shared_quad_state_list.front()
1180         ->content_to_target_transform.Translate(0, 10);
1181     root_pass_list.at(0)->damage_rect = gfx::Rect(0, 0, 1, 1);
1182
1183     scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
1184     root_pass_list.swap(root_frame_data->render_pass_list);
1185
1186     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
1187     root_frame->delegated_frame_data = root_frame_data.Pass();
1188
1189     factory_.SubmitFrame(root_surface_id_, root_frame.Pass(),
1190                          SurfaceFactory::DrawCallback());
1191   }
1192
1193   {
1194     RenderPassList root_pass_list;
1195     AddPasses(&root_pass_list,
1196               gfx::Rect(SurfaceSize()),
1197               root_passes,
1198               arraysize(root_passes));
1199
1200     root_pass_list.at(0)
1201         ->shared_quad_state_list.front()
1202         ->content_to_target_transform.Translate(0, 10);
1203     root_pass_list.at(0)->damage_rect = gfx::Rect(1, 1, 1, 1);
1204
1205     scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
1206     root_pass_list.swap(root_frame_data->render_pass_list);
1207
1208     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
1209     root_frame->delegated_frame_data = root_frame_data.Pass();
1210
1211     factory_.SubmitFrame(root_surface_id_, root_frame.Pass(),
1212                          SurfaceFactory::DrawCallback());
1213
1214     scoped_ptr<CompositorFrame> aggregated_frame =
1215         aggregator_.Aggregate(root_surface_id_);
1216
1217     ASSERT_TRUE(aggregated_frame);
1218     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
1219
1220     DelegatedFrameData* frame_data =
1221         aggregated_frame->delegated_frame_data.get();
1222
1223     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
1224
1225     ASSERT_EQ(2u, aggregated_pass_list.size());
1226
1227     // The root surface was enqueued without being aggregated once, so it should
1228     // be treated as completely damaged.
1229     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.Contains(
1230         gfx::Rect(SurfaceSize())));
1231   }
1232
1233   factory_.Destroy(child_surface_id);
1234 }
1235
1236 class SurfaceAggregatorWithResourcesTest : public testing::Test {
1237  public:
1238   void SetUp() override {
1239     output_surface_ = FakeOutputSurface::CreateSoftware(
1240         make_scoped_ptr(new SoftwareOutputDevice));
1241     output_surface_->BindToClient(&output_surface_client_);
1242     shared_bitmap_manager_.reset(new TestSharedBitmapManager);
1243
1244     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
1245                                                   shared_bitmap_manager_.get(),
1246                                                   NULL,
1247                                                   NULL,
1248                                                   0,
1249                                                   false,
1250                                                   1);
1251
1252     aggregator_.reset(
1253         new SurfaceAggregator(&manager_, resource_provider_.get()));
1254   }
1255
1256  protected:
1257   SurfaceManager manager_;
1258   FakeOutputSurfaceClient output_surface_client_;
1259   scoped_ptr<OutputSurface> output_surface_;
1260   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
1261   scoped_ptr<ResourceProvider> resource_provider_;
1262   scoped_ptr<SurfaceAggregator> aggregator_;
1263 };
1264
1265 class ResourceTrackingSurfaceFactoryClient : public SurfaceFactoryClient {
1266  public:
1267   ResourceTrackingSurfaceFactoryClient() {}
1268   ~ResourceTrackingSurfaceFactoryClient() override {}
1269
1270   void ReturnResources(const ReturnedResourceArray& resources) override {
1271     returned_resources_ = resources;
1272   }
1273
1274   ReturnedResourceArray returned_resources() const {
1275     return returned_resources_;
1276   }
1277
1278  private:
1279   ReturnedResourceArray returned_resources_;
1280
1281   DISALLOW_COPY_AND_ASSIGN(ResourceTrackingSurfaceFactoryClient);
1282 };
1283
1284 void SubmitFrameWithResources(ResourceProvider::ResourceId* resource_ids,
1285                               size_t num_resource_ids,
1286                               SurfaceFactory* factory,
1287                               SurfaceId surface_id) {
1288   scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
1289   scoped_ptr<RenderPass> pass = RenderPass::Create();
1290   pass->id = RenderPassId(1, 1);
1291   SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
1292   for (size_t i = 0u; i < num_resource_ids; ++i) {
1293     TransferableResource resource;
1294     resource.id = resource_ids[i];
1295     resource.is_software = true;
1296     frame_data->resource_list.push_back(resource);
1297     TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
1298     const gfx::Rect rect;
1299     const gfx::Rect opaque_rect;
1300     const gfx::Rect visible_rect;
1301     bool needs_blending = false;
1302     bool premultiplied_alpha = false;
1303     const gfx::PointF uv_top_left;
1304     const gfx::PointF uv_bottom_right;
1305     SkColor background_color = SK_ColorGREEN;
1306     const float vertex_opacity[4] = {0.f, 0.f, 1.f, 1.f};
1307     bool flipped = false;
1308     bool nearest_neighbor = false;
1309     quad->SetAll(sqs,
1310                  rect,
1311                  opaque_rect,
1312                  visible_rect,
1313                  needs_blending,
1314                  resource_ids[i],
1315                  premultiplied_alpha,
1316                  uv_top_left,
1317                  uv_bottom_right,
1318                  background_color,
1319                  vertex_opacity,
1320                  flipped,
1321                  nearest_neighbor);
1322
1323     quad->shared_quad_state = sqs;
1324   }
1325   frame_data->render_pass_list.push_back(pass.Pass());
1326   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
1327   frame->delegated_frame_data = frame_data.Pass();
1328   factory->SubmitFrame(surface_id, frame.Pass(),
1329                        SurfaceFactory::DrawCallback());
1330 }
1331
1332 TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
1333   ResourceTrackingSurfaceFactoryClient client;
1334   SurfaceFactory factory(&manager_, &client);
1335   SurfaceId surface_id(7u);
1336   factory.Create(surface_id);
1337
1338   ResourceProvider::ResourceId ids[] = {11, 12, 13};
1339   SubmitFrameWithResources(ids, arraysize(ids), &factory, surface_id);
1340
1341   scoped_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface_id);
1342
1343   // Nothing should be available to be returned yet.
1344   EXPECT_TRUE(client.returned_resources().empty());
1345
1346   SubmitFrameWithResources(NULL, 0u, &factory, surface_id);
1347
1348   frame = aggregator_->Aggregate(surface_id);
1349
1350   ASSERT_EQ(3u, client.returned_resources().size());
1351   ResourceProvider::ResourceId returned_ids[3];
1352   for (size_t i = 0; i < 3; ++i) {
1353     returned_ids[i] = client.returned_resources()[i].id;
1354   }
1355   EXPECT_THAT(returned_ids,
1356               testing::WhenSorted(testing::ElementsAreArray(ids)));
1357   factory.Destroy(surface_id);
1358 }
1359
1360 TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) {
1361   ResourceTrackingSurfaceFactoryClient client;
1362   SurfaceFactory factory(&manager_, &client);
1363   SurfaceId surface_id(7u);
1364   factory.Create(surface_id);
1365
1366   scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
1367   scoped_ptr<RenderPass> pass = RenderPass::Create();
1368   pass->id = RenderPassId(1, 1);
1369   TransferableResource resource;
1370   resource.id = 11;
1371   // ResourceProvider is software but resource is not, so it should be
1372   // ignored.
1373   resource.is_software = false;
1374   frame_data->resource_list.push_back(resource);
1375   frame_data->render_pass_list.push_back(pass.Pass());
1376   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
1377   frame->delegated_frame_data = frame_data.Pass();
1378   factory.SubmitFrame(surface_id, frame.Pass(), SurfaceFactory::DrawCallback());
1379
1380   scoped_ptr<CompositorFrame> returned_frame =
1381       aggregator_->Aggregate(surface_id);
1382
1383   // Nothing should be available to be returned yet.
1384   EXPECT_TRUE(client.returned_resources().empty());
1385
1386   SubmitFrameWithResources(NULL, 0u, &factory, surface_id);
1387   ASSERT_EQ(1u, client.returned_resources().size());
1388   EXPECT_EQ(11u, client.returned_resources()[0].id);
1389
1390   factory.Destroy(surface_id);
1391 }
1392
1393 TEST_F(SurfaceAggregatorWithResourcesTest, TwoSurfaces) {
1394   ResourceTrackingSurfaceFactoryClient client;
1395   SurfaceFactory factory(&manager_, &client);
1396   SurfaceId surface_id(7u);
1397   factory.Create(surface_id);
1398   SurfaceId surface_id2(8u);
1399   factory.Create(surface_id2);
1400
1401   ResourceProvider::ResourceId ids[] = {11, 12, 13};
1402   SubmitFrameWithResources(ids, arraysize(ids), &factory, surface_id);
1403   ResourceProvider::ResourceId ids2[] = {14, 15, 16};
1404   SubmitFrameWithResources(ids2, arraysize(ids2), &factory, surface_id2);
1405
1406   scoped_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface_id);
1407
1408   SubmitFrameWithResources(NULL, 0, &factory, surface_id);
1409
1410   // Nothing should be available to be returned yet.
1411   EXPECT_TRUE(client.returned_resources().empty());
1412
1413   frame = aggregator_->Aggregate(surface_id2);
1414
1415   // surface_id wasn't referenced, so its resources should be returned.
1416   ASSERT_EQ(3u, client.returned_resources().size());
1417   ResourceProvider::ResourceId returned_ids[3];
1418   for (size_t i = 0; i < 3; ++i) {
1419     returned_ids[i] = client.returned_resources()[i].id;
1420   }
1421   EXPECT_THAT(returned_ids,
1422               testing::WhenSorted(testing::ElementsAreArray(ids)));
1423   EXPECT_EQ(3u, resource_provider_->num_resources());
1424   factory.Destroy(surface_id);
1425   factory.Destroy(surface_id2);
1426 }
1427
1428 }  // namespace
1429 }  // namespace cc
1430