Enforce constant size and device scale factor for surfaces

cc/surfaces/compositor_frame_sink_support_unittest.cc

 // Copyright 2017 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/compositor_frame_sink_support.h"
 
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
@@ skipping 56 matching lines @@
 
   void OnBeginFrame(const BeginFrameArgs& args) override {}
 
   void ReclaimResources(const ReturnedResourceArray& resources) override {
     InsertResources(resources);
   }
 
   void WillDrawSurface(const LocalSurfaceId& local_surface_id,
                        const gfx::Rect& damage_rect) override {}
 
+  void DidRejectCompositorFrame() override { NOTREACHED(); }
+
   void clear_returned_resources() { returned_resources_.clear(); }
   const ReturnedResourceArray& returned_resources() {
     return returned_resources_;
   }
 
  private:
   void InsertResources(const ReturnedResourceArray& resources) {
     returned_resources_.insert(returned_resources_.end(), resources.begin(),
                                resources.end());
   }
@@ skipping 578 matching lines @@
 TEST_F(CompositorFrameSinkSupportTest, DestroyCycle) {
   LocalSurfaceId local_surface_id2(5, kArbitraryToken);
   SurfaceId id2(kYetAnotherArbitraryFrameSinkId, local_surface_id2);
   std::unique_ptr<CompositorFrameSinkSupport> support2 =
       CompositorFrameSinkSupport::Create(
           &fake_support_client_, &manager_, kYetAnotherArbitraryFrameSinkId,
           kIsChildRoot, kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   manager_.RegisterFrameSinkId(kAnotherArbitraryFrameSinkId);
   // Give id2 a frame that references local_surface_id_.
   {
-    std::unique_ptr<RenderPass> render_pass(RenderPass::Create());
     CompositorFrame frame = MakeCompositorFrame();
-    frame.render_pass_list.push_back(std::move(render_pass));
     frame.metadata.referenced_surfaces.push_back(
         SurfaceId(support_->frame_sink_id(), local_surface_id_));
     support2->SubmitCompositorFrame(local_surface_id2, std::move(frame));
     EXPECT_EQ(last_created_surface_id().local_surface_id(), local_surface_id2);
   }
   manager_.GetSurfaceForId(id2)->AddDestructionDependency(
       SurfaceSequence(kAnotherArbitraryFrameSinkId, 4));
   support2->EvictCurrentSurface();
   // Give local_surface_id_ a frame that references id2.
   {
-    std::unique_ptr<RenderPass> render_pass(RenderPass::Create());
     CompositorFrame frame = MakeCompositorFrame();
-    frame.render_pass_list.push_back(std::move(render_pass));
     frame.metadata.referenced_surfaces.push_back(id2);
     support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
   }
   support_->EvictCurrentSurface();
   EXPECT_TRUE(manager_.GetSurfaceForId(id2));
   // local_surface_id_ should be retained by reference from id2.
   EXPECT_TRUE(manager_.GetSurfaceForId(
       SurfaceId(support_->frame_sink_id(), local_surface_id_)));
 
   // Satisfy last destruction dependency for id2.
   manager_.SatisfySequence(SurfaceSequence(kAnotherArbitraryFrameSinkId, 4));
 
   // id2 and local_surface_id_ are in a reference cycle that has no surface
   // sequences holding on to it, so they should be destroyed.
   EXPECT_TRUE(!manager_.GetSurfaceForId(id2));
   EXPECT_TRUE(!manager_.GetSurfaceForId(
       SurfaceId(support_->frame_sink_id(), local_surface_id_)));
 
   local_surface_id_ = LocalSurfaceId();
 }
 
 void CopyRequestTestCallback(bool* called,
                              std::unique_ptr<CopyOutputResult> result) {
   *called = true;
 }
 
 TEST_F(CompositorFrameSinkSupportTest, DuplicateCopyRequest) {
   {
-    std::unique_ptr<RenderPass> render_pass(RenderPass::Create());
     CompositorFrame frame = MakeCompositorFrame();
-    frame.render_pass_list.push_back(std::move(render_pass));
     frame.metadata.referenced_surfaces.push_back(
         SurfaceId(support_->frame_sink_id(), local_surface_id_));
     support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
     EXPECT_EQ(last_created_surface_id().local_surface_id(), local_surface_id_);
   }
 
   bool called1 = false;
   std::unique_ptr<CopyOutputRequest> request;
   request = CopyOutputRequest::CreateRequest(
       base::Bind(&CopyRequestTestCallback, &called1));
@@ skipping 50 matching lines @@
   EXPECT_EQ(expected_surface_id, last_surface_info_.id());
   EXPECT_EQ(2.5f, last_surface_info_.device_scale_factor());
   EXPECT_EQ(gfx::Size(7, 8), last_surface_info_.size_in_pixels());
 }
 
 }  // namespace
 
 }  // namespace test
 
 }  // namespace cc