Rename LocalFrameId to LocalSurfaceId

cc/surfaces/surface_manager_ref_unittest.cc

 // Copyright 2016 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 <stddef.h>
 
 #include <unordered_map>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
@@ skipping 27 matching lines @@
 }  // namespace
 
 // Tests for reference tracking in SurfaceManager.
 class SurfaceManagerRefTest : public testing::Test {
  public:
   SurfaceManager& manager() { return *manager_; }
 
   // Creates a new Surface with the provided |frame_sink_id| and |local_id|.
   // Will first create a SurfaceFactory for |frame_sink_id| if necessary.
   SurfaceId CreateSurface(const FrameSinkId& frame_sink_id, uint32_t local_id) {
-    LocalFrameId local_frame_id(local_id,
-                                base::UnguessableToken::Deserialize(0, 1u));
+    LocalSurfaceId local_surface_id(local_id,
+                                    base::UnguessableToken::Deserialize(0, 1u));
     GetFactory(frame_sink_id)
-        .SubmitCompositorFrame(local_frame_id, CompositorFrame(),
+        .SubmitCompositorFrame(local_surface_id, CompositorFrame(),
                                SurfaceFactory::DrawCallback());
-    return SurfaceId(frame_sink_id, local_frame_id);
+    return SurfaceId(frame_sink_id, local_surface_id);
   }
 
   // Destroy Surface with |surface_id|.
   void DestroySurface(const SurfaceId& surface_id) {
     GetFactory(surface_id.frame_sink_id()).EvictSurface();
   }
 
  protected:
   SurfaceFactory& GetFactory(const FrameSinkId& frame_sink_id) {
     auto& factory_ptr = factories_[frame_sink_id];
@@ skipping 26 matching lines @@
   const SurfaceManager::SurfaceIdSet& GetReferencesFor(
       const SurfaceId& surface_id) {
     return manager().child_to_parent_refs_[surface_id];
   }
 
   const SurfaceManager::SurfaceIdSet& GetReferencesFromRoot() {
     return GetReferencesFrom(manager().GetRootSurfaceId());
   }
 
   // Returns all the temporary references for the given frame sink id.
-  std::vector<LocalFrameId> GetTempReferencesFor(
+  std::vector<LocalSurfaceId> GetTempReferencesFor(
       const FrameSinkId& frame_sink_id) {
     return manager().temp_references_[frame_sink_id];
   }
 
   // Temporary references are stored as a map in SurfaceManager. This method
   // converts the map to a vector.
   std::vector<SurfaceId> GetAllTempReferences() {
     std::vector<SurfaceId> temp_references;
     for (auto& map_entry : manager().temp_references_) {
-      for (auto local_frame_id : map_entry.second)
-        temp_references.push_back(SurfaceId(map_entry.first, local_frame_id));
+      for (auto local_surface_id : map_entry.second)
+        temp_references.push_back(SurfaceId(map_entry.first, local_surface_id));
     }
     return temp_references;
   }
 
   std::unordered_map<FrameSinkId,
                      std::unique_ptr<SurfaceFactory>,
                      FrameSinkIdHash>
       factories_;
   std::unique_ptr<SurfaceManager> manager_;
   StubSurfaceFactoryClient client_;
@@ skipping 135 matching lines @@
   // Removing the reference from the root to id1 should allow all three surfaces
   // to be deleted during GC.
   EXPECT_EQ(nullptr, manager().GetSurfaceForId(id1));
   EXPECT_EQ(nullptr, manager().GetSurfaceForId(id2));
   EXPECT_EQ(nullptr, manager().GetSurfaceForId(id3));
 }
 
 TEST_F(SurfaceManagerRefTest, TryAddReferenceToBadSurface) {
   // Not creating an accompanying Surface and SurfaceFactory.
   SurfaceId id(FrameSinkId(100u, 200u),
-               LocalFrameId(1u, base::UnguessableToken::Create()));
+               LocalSurfaceId(1u, base::UnguessableToken::Create()));
 
   // Adding reference from root to the Surface should do nothing because
   // SurfaceManager doesn't know Surface for |id| exists.
   manager().AddSurfaceReference(manager().GetRootSurfaceId(), id);
   EXPECT_THAT(GetReferencesFor(id), IsEmpty());
 }
 
 TEST_F(SurfaceManagerRefTest, TryDoubleAddReference) {
   SurfaceId id1 = CreateSurface(kFrameSink1, 1);
   SurfaceId id2 = CreateSurface(kFrameSink2, 1);
@@ skipping 101 matching lines @@
 
 TEST_F(SurfaceManagerRefTest, AddSurfacesSkipReference) {
   // Add two surfaces that have the same FrameSinkId. This would happen when a
   // client submits two CompositorFrames before parent submits a new
   // CompositorFrame.
   const SurfaceId surface_id1 = CreateSurface(kFrameSink2, 2);
   const SurfaceId surface_id2 = CreateSurface(kFrameSink2, 1);
 
   // Temporary references should be added for both surfaces and they should be
   // stored in the order of creation.
-  EXPECT_THAT(
-      GetTempReferencesFor(surface_id1.frame_sink_id()),
-      ElementsAre(surface_id1.local_frame_id(), surface_id2.local_frame_id()));
+  EXPECT_THAT(GetTempReferencesFor(surface_id1.frame_sink_id()),
+              ElementsAre(surface_id1.local_surface_id(),
+                          surface_id2.local_surface_id()));
   EXPECT_THAT(GetReferencesFromRoot(),
               UnorderedElementsAre(surface_id1, surface_id2));
 
   // Create |parent_id| and add a reference from it to |surface_id2| which was
   // created later.
   const SurfaceId parent_id = CreateSurface(kFrameSink1, 1);
   manager().AddSurfaceReference(parent_id, surface_id2);
 
   // The real reference should be added for |surface_id2| and the temporary
   // references to both |surface_id1| and |surface_id2| should be gone.
   // There should be a temporary reference to |parent_id|.
   EXPECT_THAT(GetAllTempReferences(), ElementsAre(parent_id));
   EXPECT_THAT(GetReferencesFromRoot(), ElementsAre(parent_id));
   EXPECT_THAT(GetReferencesFrom(parent_id), ElementsAre(surface_id2));
 }
 
 TEST_F(SurfaceManagerRefTest, RemoveFirstTempRefOnly) {
   // Add two surfaces that have the same FrameSinkId. This would happen when a
   // client submits two CFs before parent submits a new CF.
   const SurfaceId surface_id1 = CreateSurface(kFrameSink2, 1);
   const SurfaceId surface_id2 = CreateSurface(kFrameSink2, 2);
 
   // Temporary references should be added for both surfaces and they should be
   // stored in the order of creation.
-  EXPECT_THAT(
-      GetTempReferencesFor(surface_id1.frame_sink_id()),
-      ElementsAre(surface_id1.local_frame_id(), surface_id2.local_frame_id()));
+  EXPECT_THAT(GetTempReferencesFor(surface_id1.frame_sink_id()),
+              ElementsAre(surface_id1.local_surface_id(),
+                          surface_id2.local_surface_id()));
   EXPECT_THAT(GetReferencesFromRoot(),
               UnorderedElementsAre(surface_id1, surface_id2));
 
   // Create |parent_id| and add a reference from it to |surface_id1| which was
   // created earlier.
   const SurfaceId parent_id = CreateSurface(kFrameSink1, 1);
   manager().AddSurfaceReference(parent_id, surface_id1);
 
   // The real reference should be added for |surface_id1| and its temporary
   // reference should be removed. The temporary reference for |surface_id2|
   // should remain. A temporary reference must be added for |parent_id|.
   EXPECT_THAT(GetAllTempReferences(),
               UnorderedElementsAre(parent_id, surface_id2));
   EXPECT_THAT(GetReferencesFromRoot(),
               UnorderedElementsAre(parent_id, surface_id2));
   EXPECT_THAT(GetReferencesFrom(parent_id), ElementsAre(surface_id1));
 }
 
 }  // namespace cc