Rename EvictFrame, EvictSurface to EvictCurrentSurface

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 90 matching lines @@
                                                kIsRoot,
                                                kHandlesFrameSinkIdInvalidation,
                                                kNeedsSyncPoints)),
         local_surface_id_(3, kArbitraryToken),
         frame_sync_token_(GenTestSyncToken(4)),
         consumer_sync_token_(GenTestSyncToken(5)) {
     manager_.AddObserver(this);
   }
   ~CompositorFrameSinkSupportTest() override {
     manager_.RemoveObserver(this);
-    support_->EvictFrame();
+    support_->EvictCurrentSurface();
   }
 
   const SurfaceId& last_created_surface_id() const {
     return last_created_surface_id_;
   }
 
   // SurfaceObserver implementation.
   void OnSurfaceCreated(const SurfaceInfo& surface_info) override {
     last_created_surface_id_ = surface_info.id();
     last_surface_info_ = surface_info;
@@ skipping 377 matching lines @@
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId local_surface_id(6, kArbitraryToken);
   support->SubmitCompositorFrame(local_surface_id, MakeCompositorFrame());
 
   EXPECT_CALL(mock_client, DidReceiveCompositorFrameAck(_))
       .WillOnce(testing::InvokeWithoutArgs([&support, &mock_client]() {
         LocalSurfaceId new_id(7, base::UnguessableToken::Create());
         support->SubmitCompositorFrame(new_id, MakeCompositorFrame());
       }))
       .WillRepeatedly(testing::Return());
-  support->EvictFrame();
+  support->EvictCurrentSurface();
 }
 
-// Tests doing an EvictFrame before shutting down the factory.
-TEST_F(CompositorFrameSinkSupportTest, EvictFrame) {
+// Tests doing an EvictCurrentSurface before shutting down the factory.
+TEST_F(CompositorFrameSinkSupportTest, EvictCurrentSurface) {
   MockCompositorFrameSinkSupportClient mock_client;
   std::unique_ptr<CompositorFrameSinkSupport> support =
       CompositorFrameSinkSupport::Create(
           &mock_client, &manager_, kAnotherArbitraryFrameSinkId, kIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId local_surface_id(7, kArbitraryToken);
   SurfaceId id(kAnotherArbitraryFrameSinkId, local_surface_id);
 
   TransferableResource resource;
   resource.id = 1;
   resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
   CompositorFrame frame = MakeCompositorFrame();
   frame.resource_list.push_back(resource);
   support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   EXPECT_EQ(last_created_surface_id().local_surface_id(), local_surface_id);
   local_surface_id_ = LocalSurfaceId();
 
   ReturnedResourceArray returned_resources = {resource.ToReturnedResource()};
   EXPECT_TRUE(manager_.GetSurfaceForId(id));
   EXPECT_CALL(mock_client, DidReceiveCompositorFrameAck(returned_resources))
       .Times(1);
-  support->EvictFrame();
+  support->EvictCurrentSurface();
   EXPECT_FALSE(manager_.GetSurfaceForId(id));
 }
 
-// Tests doing an EvictSurface which has unregistered dependency.
-TEST_F(CompositorFrameSinkSupportTest, EvictSurfaceDependencyUnRegistered) {
+// Tests doing an EvictCurrentSurface which has unregistered dependency.
+TEST_F(CompositorFrameSinkSupportTest,
+       EvictCurrentSurfaceDependencyUnRegistered) {
   MockCompositorFrameSinkSupportClient mock_client;
   std::unique_ptr<CompositorFrameSinkSupport> support =
       CompositorFrameSinkSupport::Create(
           &mock_client, &manager_, kAnotherArbitraryFrameSinkId, kIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId local_surface_id(7, kArbitraryToken);
 
   TransferableResource resource;
   resource.id = 1;
   resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
   CompositorFrame frame = MakeCompositorFrame();
   frame.resource_list.push_back(resource);
   support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   EXPECT_EQ(last_created_surface_id().local_surface_id(), local_surface_id);
   local_surface_id_ = LocalSurfaceId();
 
   SurfaceId surface_id(kAnotherArbitraryFrameSinkId, local_surface_id);
   Surface* surface = manager_.GetSurfaceForId(surface_id);
   surface->AddDestructionDependency(
       SurfaceSequence(kYetAnotherArbitraryFrameSinkId, 4));
 
   ReturnedResourceArray returned_resource = {resource.ToReturnedResource()};
 
   EXPECT_TRUE(manager_.GetSurfaceForId(surface_id));
   EXPECT_CALL(mock_client, DidReceiveCompositorFrameAck(returned_resource))
       .Times(1);
-  support->EvictFrame();
+  support->EvictCurrentSurface();
   EXPECT_FALSE(manager_.GetSurfaceForId(surface_id));
 }
 
-// Tests doing an EvictSurface which has registered dependency.
-TEST_F(CompositorFrameSinkSupportTest, EvictSurfaceDependencyRegistered) {
+// Tests doing an EvictCurrentSurface which has registered dependency.
+TEST_F(CompositorFrameSinkSupportTest,
+       EvictCurrentSurfaceDependencyRegistered) {
   MockCompositorFrameSinkSupportClient mock_client;
   std::unique_ptr<CompositorFrameSinkSupport> support =
       CompositorFrameSinkSupport::Create(
           &mock_client, &manager_, kAnotherArbitraryFrameSinkId, kIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId local_surface_id(7, kArbitraryToken);
 
   TransferableResource resource;
   resource.id = 1;
   resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
   CompositorFrame frame = MakeCompositorFrame();
   frame.resource_list.push_back(resource);
   uint32_t execute_count = 0;
   support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   EXPECT_EQ(last_created_surface_id().local_surface_id(), local_surface_id);
   local_surface_id_ = LocalSurfaceId();
 
   manager_.RegisterFrameSinkId(kYetAnotherArbitraryFrameSinkId);
 
   SurfaceId surface_id(kAnotherArbitraryFrameSinkId, local_surface_id);
   Surface* surface = manager_.GetSurfaceForId(surface_id);
   surface->AddDestructionDependency(
       SurfaceSequence(kYetAnotherArbitraryFrameSinkId, 4));
 
   ReturnedResourceArray returned_resources;
   EXPECT_TRUE(manager_.GetSurfaceForId(surface_id));
-  support->EvictFrame();
+  support->EvictCurrentSurface();
   EXPECT_TRUE(manager_.GetSurfaceForId(surface_id));
   EXPECT_EQ(0u, execute_count);
 
   returned_resources.push_back(resource.ToReturnedResource());
   EXPECT_CALL(mock_client, DidReceiveCompositorFrameAck(returned_resources))
       .Times(1);
   manager_.SatisfySequence(SurfaceSequence(kYetAnotherArbitraryFrameSinkId, 4));
   EXPECT_FALSE(manager_.GetSurfaceForId(surface_id));
 }
 
 TEST_F(CompositorFrameSinkSupportTest, DestroySequence) {
   LocalSurfaceId local_surface_id2(5, kArbitraryToken);
   std::unique_ptr<CompositorFrameSinkSupport> support2 =
       CompositorFrameSinkSupport::Create(
           &fake_support_client_, &manager_, kYetAnotherArbitraryFrameSinkId,
           kIsChildRoot, kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   SurfaceId id2(kYetAnotherArbitraryFrameSinkId, local_surface_id2);
   support2->SubmitCompositorFrame(local_surface_id2, MakeCompositorFrame());
 
   // Check that waiting before the sequence is satisfied works.
   manager_.GetSurfaceForId(id2)->AddDestructionDependency(
       SurfaceSequence(kYetAnotherArbitraryFrameSinkId, 4));
-  support2->EvictFrame();
+  support2->EvictCurrentSurface();
 
   DCHECK(manager_.GetSurfaceForId(id2));
   manager_.SatisfySequence(SurfaceSequence(kYetAnotherArbitraryFrameSinkId, 4));
   manager_.SatisfySequence(SurfaceSequence(kYetAnotherArbitraryFrameSinkId, 6));
   DCHECK(!manager_.GetSurfaceForId(id2));
 
   // Check that waiting after the sequence is satisfied works.
   support2->SubmitCompositorFrame(local_surface_id2, MakeCompositorFrame());
   DCHECK(manager_.GetSurfaceForId(id2));
   manager_.GetSurfaceForId(id2)->AddDestructionDependency(
       SurfaceSequence(kAnotherArbitraryFrameSinkId, 6));
-  support2->EvictFrame();
+  support2->EvictCurrentSurface();
   DCHECK(!manager_.GetSurfaceForId(id2));
 }
 
 // Tests that Surface ID namespace invalidation correctly allows
 // Sequences to be ignored.
 TEST_F(CompositorFrameSinkSupportTest, InvalidFrameSinkId) {
   FrameSinkId frame_sink_id(1234, 5678);
 
   LocalSurfaceId local_surface_id(5, kArbitraryToken);
   SurfaceId id(support_->frame_sink_id(), local_surface_id);
   support_->SubmitCompositorFrame(local_surface_id, MakeCompositorFrame());
 
   manager_.RegisterFrameSinkId(frame_sink_id);
   manager_.GetSurfaceForId(id)->AddDestructionDependency(
       SurfaceSequence(frame_sink_id, 4));
 
-  support_->EvictFrame();
+  support_->EvictCurrentSurface();
 
   // Verify the dependency has prevented the surface from getting destroyed.
   EXPECT_TRUE(manager_.GetSurfaceForId(id));
 
   manager_.InvalidateFrameSinkId(frame_sink_id);
 
   // Verify that the invalidated namespace caused the unsatisfied sequence
   // to be ignored.
   EXPECT_FALSE(manager_.GetSurfaceForId(id));
 }
@@ skipping 11 matching lines @@
     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->EvictFrame();
+  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_->EvictFrame();
+  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.
@@ skipping 43 matching lines @@
   request = CopyOutputRequest::CreateRequest(
       base::Bind(&CopyRequestTestCallback, &called3));
   request->set_source(kArbitrarySourceId1);
 
   support_->RequestCopyOfSurface(std::move(request));
   // Two callbacks are from source1, so the first should be called.
   EXPECT_TRUE(called1);
   EXPECT_FALSE(called2);
   EXPECT_FALSE(called3);
 
-  support_->EvictFrame();
+  support_->EvictCurrentSurface();
   local_surface_id_ = LocalSurfaceId();
   EXPECT_TRUE(called1);
   EXPECT_TRUE(called2);
   EXPECT_TRUE(called3);
 }
 
 // Check whether the SurfaceInfo object is created and populated correctly
 // after the frame submission.
 TEST_F(CompositorFrameSinkSupportTest, SurfaceInfo) {
   CompositorFrame frame = MakeCompositorFrame();
@@ skipping 13 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