Rename EvictFrame, EvictSurface to EvictCurrentSurface

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 55 matching lines @@
                                                &manager_,
                                                kArbitraryRootFrameSinkId,
                                                kRootIsRoot,
                                                kHandlesFrameSinkIdInvalidation,
                                                kNeedsSyncPoints)),
         aggregator_(&manager_, NULL, use_damage_rect) {}
 
   SurfaceAggregatorTest() : SurfaceAggregatorTest(false) {}
 
   void TearDown() override {
-    support_->EvictFrame();
+    support_->EvictCurrentSurface();
     testing::Test::TearDown();
   }
 
  protected:
   SurfaceManager manager_;
   FakeCompositorFrameSinkSupportClient fake_client_;
   std::unique_ptr<CompositorFrameSinkSupport> support_;
   SurfaceAggregator aggregator_;
 };
 
@@ skipping 12 matching lines @@
       : SurfaceAggregatorValidSurfaceTest(false) {}
 
   void SetUp() override {
     SurfaceAggregatorTest::SetUp();
     root_local_surface_id_ = allocator_.GenerateId();
     root_surface_ = manager_.GetSurfaceForId(
         SurfaceId(support_->frame_sink_id(), root_local_surface_id_));
   }
 
   void TearDown() override {
-    child_support_->EvictFrame();
+    child_support_->EvictCurrentSurface();
     SurfaceAggregatorTest::TearDown();
   }
 
   void AggregateAndVerify(test::Pass* expected_passes,
                           size_t expected_pass_count,
                           SurfaceId* surface_ids,
                           size_t expected_surface_count) {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(
         SurfaceId(support_->frame_sink_id(), root_local_surface_id_));
 
@@ skipping 103 matching lines @@
       render_pass_list[0]->shared_quad_state_list);
   ASSERT_EQ(2u, shared_quad_state_list.size());
   EXPECT_EQ(1.f, shared_quad_state_list.ElementAt(0)->opacity);
   EXPECT_EQ(1.f, shared_quad_state_list.ElementAt(1)->opacity);
 
   SharedQuadStateList& shared_quad_state_list2(
       render_pass_list[1]->shared_quad_state_list);
   ASSERT_EQ(1u, shared_quad_state_list2.size());
   EXPECT_EQ(.5f, shared_quad_state_list2.ElementAt(0)->opacity);
 
-  embedded_support->EvictFrame();
+  embedded_support->EvictCurrentSurface();
 }
 
 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]), 1),
                          test::Pass(quads[1], arraysize(quads[1]), 2)};
 
@@ skipping 89 matching lines @@
   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 root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
   SurfaceId ids[] = {root_surface_id, embedded_surface_id};
   AggregateAndVerify(
       expected_passes, arraysize(expected_passes), ids, arraysize(ids));
 
-  embedded_support->EvictFrame();
+  embedded_support->EvictCurrentSurface();
 }
 
 // This test verifies that in the absence of a primary Surface,
 // SurfaceAggregator will embed a fallback Surface, if available. If the primary
 // Surface is available, though, the fallback will not be used.
 TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReference) {
   std::unique_ptr<CompositorFrameSinkSupport> primary_child_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId1, kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
@@ skipping 54 matching lines @@
 
   // Now that the primary Surface has a CompositorFrame, we expect
   // SurfaceAggregator to embed the primary Surface, and drop the fallback
   // Surface.
   test::Quad expected_quads2[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
   test::Pass expected_passes2[] = {
       test::Pass(expected_quads2, arraysize(expected_quads2))};
   AggregateAndVerify(expected_passes2, arraysize(expected_passes2), ids,
                      arraysize(ids));
 
-  primary_child_support->EvictFrame();
-  fallback_child_support->EvictFrame();
+  primary_child_support->EvictCurrentSurface();
+  fallback_child_support->EvictCurrentSurface();
 }
 
 // This test verifies that in the presence of both primary Surface and fallback
 // Surface, the fallback will not be used.
 TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReferenceWithPrimary) {
   std::unique_ptr<CompositorFrameSinkSupport> primary_child_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId1, kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId primary_child_local_surface_id = allocator_.GenerateId();
@@ skipping 43 matching lines @@
   test::Quad expected_quads1[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
   test::Pass expected_passes1[] = {
       test::Pass(expected_quads1, arraysize(expected_quads1))};
 
   SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
   SurfaceId ids[] = {root_surface_id, primary_child_surface_id,
                      fallback_child_surface_id};
   AggregateAndVerify(expected_passes1, arraysize(expected_passes1), ids,
                      arraysize(ids));
 
-  primary_child_support->EvictFrame();
-  fallback_child_support->EvictFrame();
+  primary_child_support->EvictCurrentSurface();
+  fallback_child_support->EvictCurrentSurface();
 }
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) {
   std::unique_ptr<CompositorFrameSinkSupport> embedded_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId1, kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId embedded_local_surface_id = allocator_.GenerateId();
   SurfaceId embedded_surface_id(embedded_support->frame_sink_id(),
                                 embedded_local_surface_id);
@@ skipping 37 matching lines @@
 
   SurfaceId surface_ids[] = {root_surface_id, embedded_surface_id};
   EXPECT_EQ(arraysize(surface_ids),
             aggregator_.previous_contained_surfaces().size());
   for (size_t i = 0; i < arraysize(surface_ids); i++) {
     EXPECT_TRUE(
         aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
         aggregator_.previous_contained_surfaces().end());
   }
 
-  embedded_support->EvictFrame();
+  embedded_support->EvictCurrentSurface();
 }
 
 // Root surface may contain copy requests.
 TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {
   std::unique_ptr<CompositorFrameSinkSupport> embedded_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId2, kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId embedded_local_surface_id = allocator_.GenerateId();
   SurfaceId embedded_surface_id(embedded_support->frame_sink_id(),
@@ skipping 60 matching lines @@
   }
 
   // Ensure copy requests have been removed from root surface.
   const CompositorFrame& original_frame =
       manager_.GetSurfaceForId(root_surface_id)->GetActiveFrame();
   const RenderPassList& original_pass_list = original_frame.render_pass_list;
   ASSERT_EQ(2u, original_pass_list.size());
   DCHECK(original_pass_list[0]->copy_requests.empty());
   DCHECK(original_pass_list[1]->copy_requests.empty());
 
-  embedded_support->EvictFrame();
+  embedded_support->EvictCurrentSurface();
 }
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) {
   std::unique_ptr<CompositorFrameSinkSupport> embedded_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId1, kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   std::unique_ptr<CompositorFrameSinkSupport> parent_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId2, kRootIsRoot,
@@ skipping 76 matching lines @@
       SurfaceId(support_->frame_sink_id(), root_local_surface_id_),
       parent_surface_id, embedded_surface_id, nonexistent_surface_id};
   EXPECT_EQ(arraysize(surface_ids),
             aggregator_.previous_contained_surfaces().size());
   for (size_t i = 0; i < arraysize(surface_ids); i++) {
     EXPECT_TRUE(
         aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
         aggregator_.previous_contained_surfaces().end());
   }
 
-  embedded_support->EvictFrame();
-  parent_support->EvictFrame();
+  embedded_support->EvictCurrentSurface();
+  parent_support->EvictCurrentSurface();
 }
 
 // This tests referencing a surface that has multiple render passes.
 TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) {
   LocalSurfaceId embedded_local_surface_id = child_allocator_.GenerateId();
   SurfaceId embedded_surface_id(child_support_->frame_sink_id(),
                                 embedded_local_surface_id);
 
   int pass_ids[] = {1, 2, 3};
 
@@ skipping 462 matching lines @@
 
   ASSERT_EQ(7u, aggregated_quad_list.size());
 
   for (auto iter = aggregated_quad_list.cbegin();
        iter != aggregated_quad_list.cend();
        ++iter) {
     EXPECT_EQ(blend_modes[iter.index()], iter->shared_quad_state->blend_mode)
         << iter.index();
   }
 
-  grandchild_support->EvictFrame();
-  child_one_support->EvictFrame();
-  child_two_support->EvictFrame();
+  grandchild_support->EvictCurrentSurface();
+  child_one_support->EvictCurrentSurface();
+  child_two_support->EvictCurrentSurface();
 }
 
 // This tests that when aggregating a frame with multiple render passes that we
 // map the transforms for the root pass but do not modify the transform on child
 // passes.
 //
 // The root surface has one pass with a surface quad transformed by +10 in the y
 // direction.
 //
 // The middle surface has one pass with a surface quad scaled by 2 in the x
@@ skipping 167 matching lines @@
       aggregated_pass_list[1]->shared_quad_state_list.ElementAt(1)->is_clipped);
 
   // The second quad in the root pass is aggregated from the child, so its
   // clip rect must be transformed by the child's translation/scale and
   // clipped be the visible_rects for both children.
   EXPECT_EQ(gfx::Rect(0, 13, 8, 12).ToString(),
             aggregated_pass_list[1]
                 ->shared_quad_state_list.ElementAt(1)
                 ->clip_rect.ToString());
 
-  middle_support->EvictFrame();
+  middle_support->EvictCurrentSurface();
 }
 
 // Tests that damage rects are aggregated correctly when surfaces change.
 TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
   std::unique_ptr<CompositorFrameSinkSupport> parent_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryMiddleFrameSinkId, kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   test::Quad child_quads[] = {test::Quad::RenderPassQuad(1)};
   test::Pass child_passes[] = {
@@ skipping 157 matching lines @@
 
     const RenderPassList& aggregated_pass_list =
         aggregated_frame.render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.Contains(
         gfx::Rect(SurfaceSize())));
   }
 
-  parent_support->EvictFrame();
+  parent_support->EvictCurrentSurface();
 }
 
 // Check that damage is correctly calculated for surfaces.
 TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) {
   test::Quad root_render_pass_quads[] = {test::Quad::SolidColorQuad(1)};
 
   test::Pass root_passes[] = {
       test::Pass(root_render_pass_quads, arraysize(root_render_pass_quads), 2)};
 
   CompositorFrame root_frame = test::MakeEmptyCompositorFrame();
@@ skipping 439 matching lines @@
   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)));
 
-  support->EvictFrame();
+  support->EvictCurrentSurface();
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) {
   FakeCompositorFrameSinkSupportClient client;
   std::unique_ptr<CompositorFrameSinkSupport> support =
       CompositorFrameSinkSupport::Create(
           &client, &manager_, kArbitraryRootFrameSinkId, kRootIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId local_surface_id(7u, base::UnguessableToken::Create());
   SurfaceId surface_id(support->frame_sink_id(), local_surface_id);
@@ skipping 13 matching lines @@
   CompositorFrame returned_frame = aggregator_->Aggregate(surface_id);
 
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
 
   SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), support.get(),
                                      surface_id);
   ASSERT_EQ(1u, client.returned_resources().size());
   EXPECT_EQ(11u, client.returned_resources()[0].id);
 
-  support->EvictFrame();
+  support->EvictCurrentSurface();
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TwoSurfaces) {
   FakeCompositorFrameSinkSupportClient client;
   std::unique_ptr<CompositorFrameSinkSupport> support1 =
       CompositorFrameSinkSupport::Create(
           &client, &manager_, FrameSinkId(1, 1), kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   std::unique_ptr<CompositorFrameSinkSupport> support2 =
       CompositorFrameSinkSupport::Create(
@@ skipping 25 matching lines @@
   // surface1_id wasn't referenced, so its resources should be returned.
   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)));
   EXPECT_EQ(3u, resource_provider_->num_resources());
 
-  support1->EvictFrame();
-  support2->EvictFrame();
+  support1->EvictCurrentSurface();
+  support2->EvictCurrentSurface();
 }
 
 // Ensure that aggregator completely ignores Surfaces that reference invalid
 // resources.
 TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) {
   std::unique_ptr<CompositorFrameSinkSupport> root_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryRootFrameSinkId, kRootIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   std::unique_ptr<CompositorFrameSinkSupport> middle_support =
@@ skipping 39 matching lines @@
                                      child_surface_id, middle_support.get(),
                                      middle_surface_id);
 
   frame = aggregator_->Aggregate(root_surface_id);
 
   pass_list = &frame.render_pass_list;
   ASSERT_EQ(1u, pass_list->size());
   EXPECT_EQ(3u, pass_list->back()->shared_quad_state_list.size());
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
-  root_support->EvictFrame();
-  middle_support->EvictFrame();
-  child_support->EvictFrame();
+  root_support->EvictCurrentSurface();
+  middle_support->EvictCurrentSurface();
+  child_support->EvictCurrentSurface();
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) {
   std::unique_ptr<CompositorFrameSinkSupport> support1 =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, FrameSinkId(1, 1), kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   std::unique_ptr<CompositorFrameSinkSupport> support2 =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, FrameSinkId(2, 2), kChildIsRoot,
@@ skipping 48 matching lines @@
             render_pass->quad_list.front()->material);
 
   aggregator_->set_output_is_secure(false);
 
   frame = aggregator_->Aggregate(surface2_id);
   render_pass = frame.render_pass_list.back().get();
 
   // Output is insecure, so texture should be drawn.
   EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
 
-  support1->EvictFrame();
-  support2->EvictFrame();
+  support1->EvictCurrentSurface();
+  support2->EvictCurrentSurface();
 }
 
 // Ensure that the render passes have correct color spaces.
 TEST_F(SurfaceAggregatorValidSurfaceTest, ColorSpaceTest) {
   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]), 2),
                          test::Pass(quads[1], arraysize(quads[1]), 1)};
@@ skipping 23 matching lines @@
   aggregated_frame = aggregator_.Aggregate(surface_id);
   EXPECT_EQ(3u, aggregated_frame.render_pass_list.size());
   EXPECT_EQ(color_space1, aggregated_frame.render_pass_list[0]->color_space);
   EXPECT_EQ(color_space1, aggregated_frame.render_pass_list[1]->color_space);
   EXPECT_EQ(color_space3, aggregated_frame.render_pass_list[2]->color_space);
 }
 
 }  // namespace
 }  // namespace cc