WIP: Surface Synchronization System

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 964 matching lines @@
                                           CompositorFrame(),
                                           SurfaceFactory::DrawCallback());
 
   std::unique_ptr<RenderPass> child_one_pass = RenderPass::Create();
   child_one_pass->SetNew(pass_id, output_rect, damage_rect,
                          transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[1]);
   SurfaceDrawQuad* grandchild_surface_quad =
       child_one_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
-  grandchild_surface_quad->SetNew(child_one_pass->shared_quad_state_list.back(),
-                                  gfx::Rect(SurfaceSize()),
-                                  gfx::Rect(SurfaceSize()),
-                                  grandchild_surface_id);
+  grandchild_surface_quad->SetNew(
+      child_one_pass->shared_quad_state_list.back(), gfx::Rect(SurfaceSize()),
+      gfx::Rect(SurfaceSize()), grandchild_surface_id,
+      SurfaceDrawQuadType::PRIMARY, nullptr);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[3]);
   QueuePassAsFrame(std::move(child_one_pass), child_one_local_frame_id,
                    &child_one_factory);
 
   LocalFrameId child_two_local_frame_id = allocator_.GenerateId();
   SurfaceId child_two_surface_id(child_two_factory.frame_sink_id(),
                                  child_two_local_frame_id);
   child_two_factory.SubmitCompositorFrame(child_two_local_frame_id,
                                           CompositorFrame(),
@@ skipping 10 matching lines @@
   std::unique_ptr<RenderPass> root_pass = RenderPass::Create();
   root_pass->SetNew(pass_id, output_rect, damage_rect,
                     transform_to_root_target);
 
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[0]);
   SurfaceDrawQuad* child_one_surface_quad =
       root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   child_one_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
                                  gfx::Rect(SurfaceSize()),
-                                 gfx::Rect(SurfaceSize()),
-                                 child_one_surface_id);
+                                 gfx::Rect(SurfaceSize()), child_one_surface_id,
+                                 SurfaceDrawQuadType::PRIMARY, nullptr);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[4]);
   SurfaceDrawQuad* child_two_surface_quad =
       root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   child_two_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
                                  gfx::Rect(SurfaceSize()),
-                                 gfx::Rect(SurfaceSize()),
-                                 child_two_surface_id);
+                                 gfx::Rect(SurfaceSize()), child_two_surface_id,
+                                 SurfaceDrawQuadType::PRIMARY, nullptr);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[6]);
 
   QueuePassAsFrame(std::move(root_pass), root_local_frame_id_, &factory_);
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
   const RenderPassList& aggregated_pass_list =
       aggregated_frame.render_pass_list;
@@ skipping 780 matching lines @@
                                         SurfaceId surface_id) {
   CompositorFrame frame;
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   pass->id = 1;
   SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
   sqs->opacity = 1.f;
   if (child_id.is_valid()) {
     SurfaceDrawQuad* surface_quad =
         pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
     surface_quad->SetNew(sqs, gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1),
-                         child_id);
+                         child_id, SurfaceDrawQuadType::PRIMARY, nullptr);
   }
 
   for (size_t i = 0u; i < num_resource_ids; ++i) {
     TransferableResource resource;
     resource.id = resource_ids[i];
     // ResourceProvider is software, so only software resources are valid.
     resource.is_software = valid;
     frame.resource_list.push_back(resource);
     TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     const gfx::Rect rect;
@@ skipping 198 matching lines @@
 
   {
     std::unique_ptr<RenderPass> pass = RenderPass::Create();
     pass->id = 1;
     SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
     sqs->opacity = 1.f;
     SurfaceDrawQuad* surface_quad =
         pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
 
     surface_quad->SetNew(sqs, gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1),
-                         surface1_id);
+                         surface1_id, SurfaceDrawQuadType::PRIMARY, nullptr);
     pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
     CompositorFrame frame;
     frame.render_pass_list.push_back(std::move(pass));
 
     factory2.SubmitCompositorFrame(local_frame2_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   frame = aggregator_->Aggregate(surface2_id);
@@ skipping 19 matching lines @@
   // Output is insecure, so texture should be drawn.
   EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
 
   factory1.EvictSurface();
   factory2.EvictSurface();
 }
 
 }  // namespace
 }  // namespace cc