Reject frames with invalid BeginFrameAck in CompositorFrameSinkSupport

cc/surfaces/surfaces_pixeltest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/local_surface_id_allocator.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_aggregator.h"
 #include "cc/surfaces/surface_manager.h"
+#include "cc/test/compositor_frame_helpers.h"
 #include "cc/test/pixel_comparator.h"
 #include "cc/test/pixel_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if !defined(OS_ANDROID)
 
 namespace cc {
 namespace {
 
 constexpr FrameSinkId kArbitraryRootFrameSinkId(1, 1);
@@ skipping 51 matching lines @@
 
   SolidColorDrawQuad* color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   bool force_anti_aliasing_off = false;
   color_quad->SetNew(pass->shared_quad_state_list.back(),
                      rect,
                      rect,
                      SK_ColorGREEN,
                      force_anti_aliasing_off);
 
-
-  CompositorFrame root_frame;
+  CompositorFrame root_frame = test::MakeCompositorFrame();
   root_frame.render_pass_list.push_back(std::move(pass));
 
   LocalSurfaceId root_local_surface_id = allocator_.GenerateId();
   SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id);
   support_->SubmitCompositorFrame(root_local_surface_id, std::move(root_frame));
 
   SurfaceAggregator aggregator(&manager_, resource_provider_.get(), true);
   CompositorFrame aggregated_frame = aggregator.Aggregate(root_surface_id);
 
   bool discard_alpha = false;
@@ skipping 36 matching lines @@
 
     SolidColorDrawQuad* color_quad =
         pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bool force_anti_aliasing_off = false;
     color_quad->SetNew(pass->shared_quad_state_list.back(),
                        rect,
                        rect,
                        SK_ColorYELLOW,
                        force_anti_aliasing_off);
 
-    CompositorFrame root_frame;
+    CompositorFrame root_frame = test::MakeCompositorFrame();
     root_frame.render_pass_list.push_back(std::move(pass));
 
     support_->SubmitCompositorFrame(root_local_surface_id,
                                     std::move(root_frame));
   }
 
   {
     gfx::Rect rect(child_size);
     int id = 1;
     std::unique_ptr<RenderPass> pass = RenderPass::Create();
     pass->SetNew(id, rect, rect, gfx::Transform());
 
     CreateAndAppendTestSharedQuadState(
         pass.get(), gfx::Transform(), child_size);
 
     SolidColorDrawQuad* color_quad =
         pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bool force_anti_aliasing_off = false;
     color_quad->SetNew(pass->shared_quad_state_list.back(),
                        rect,
                        rect,
                        SK_ColorBLUE,
                        force_anti_aliasing_off);
 
-    CompositorFrame child_frame;
+    CompositorFrame child_frame = test::MakeCompositorFrame();
     child_frame.render_pass_list.push_back(std::move(pass));
 
     child_support->SubmitCompositorFrame(child_local_surface_id,
                                          std::move(child_frame));
   }
 
   SurfaceAggregator aggregator(&manager_, resource_provider_.get(), true);
   CompositorFrame aggregated_frame = aggregator.Aggregate(root_surface_id);
 
   bool discard_alpha = false;
@@ skipping 54 matching lines @@
     CreateAndAppendTestSharedQuadState(
         pass.get(), surface_transform, device_viewport_size_);
 
     SurfaceDrawQuad* right_surface_quad =
         pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
     right_surface_quad->SetNew(pass->shared_quad_state_list.back(),
                                gfx::Rect(child_size), gfx::Rect(child_size),
                                right_child_id, SurfaceDrawQuadType::PRIMARY,
                                nullptr);
 
-    CompositorFrame root_frame;
+    CompositorFrame root_frame = test::MakeCompositorFrame();
     root_frame.render_pass_list.push_back(std::move(pass));
 
     support_->SubmitCompositorFrame(root_local_surface_id,
                                     std::move(root_frame));
   }
 
   {
     gfx::Rect rect(child_size);
     int id = 1;
     std::unique_ptr<RenderPass> pass = RenderPass::Create();
@@ skipping 12 matching lines @@
                            force_anti_aliasing_off);
 
     SolidColorDrawQuad* bottom_color_quad =
         pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bottom_color_quad->SetNew(pass->shared_quad_state_list.back(),
                               gfx::Rect(0, 100, 100, 100),
                               gfx::Rect(0, 100, 100, 100),
                               SK_ColorBLUE,
                               force_anti_aliasing_off);
 
-    CompositorFrame child_frame;
+    CompositorFrame child_frame = test::MakeCompositorFrame();
     child_frame.render_pass_list.push_back(std::move(pass));
 
     left_support->SubmitCompositorFrame(left_child_local_id,
                                         std::move(child_frame));
   }
 
   {
     gfx::Rect rect(child_size);
     int id = 1;
     std::unique_ptr<RenderPass> pass = RenderPass::Create();
@@ skipping 12 matching lines @@
                            force_anti_aliasing_off);
 
     SolidColorDrawQuad* bottom_color_quad =
         pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bottom_color_quad->SetNew(pass->shared_quad_state_list.back(),
                               gfx::Rect(0, 100, 100, 100),
                               gfx::Rect(0, 100, 100, 100),
                               SK_ColorGREEN,
                               force_anti_aliasing_off);
 
-    CompositorFrame child_frame;
+    CompositorFrame child_frame = test::MakeCompositorFrame();
     child_frame.render_pass_list.push_back(std::move(pass));
 
     right_support->SubmitCompositorFrame(right_child_local_id,
                                          std::move(child_frame));
   }
 
   SurfaceAggregator aggregator(&manager_, resource_provider_.get(), true);
   CompositorFrame aggregated_frame = aggregator.Aggregate(root_surface_id);
 
   bool discard_alpha = false;
   ExactPixelComparator pixel_comparator(discard_alpha);
   RenderPassList* pass_list = &aggregated_frame.render_pass_list;
   EXPECT_TRUE(RunPixelTest(
       pass_list,
       base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
       pixel_comparator));
 
   left_support->EvictFrame();
   right_support->EvictFrame();
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // !defined(OS_ANDROID)