Rename LocalFrameId to LocalSurfaceId

cc/surfaces/surface_manager.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_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 19 matching lines @@
     const FrameSinkSourceMapping& other) = default;
 
 SurfaceManager::FrameSinkSourceMapping::~FrameSinkSourceMapping() {
   DCHECK(is_empty()) << "client: " << client
                      << ", children: " << children.size();
 }
 
 SurfaceManager::SurfaceManager(LifetimeType lifetime_type)
     : lifetime_type_(lifetime_type),
       root_surface_id_(FrameSinkId(0u, 0u),
-                       LocalFrameId(1u, base::UnguessableToken::Create())),
+                       LocalSurfaceId(1u, base::UnguessableToken::Create())),
       weak_factory_(this) {
   thread_checker_.DetachFromThread();
   reference_factory_ =
       new DirectSurfaceReferenceFactory(weak_factory_.GetWeakPtr());
 }
 
 SurfaceManager::~SurfaceManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (lifetime_type_ == LifetimeType::REFERENCES) {
     // Remove all temporary references on shutdown.
     for (const auto& map_entry : temp_references_) {
       const FrameSinkId& frame_sink_id = map_entry.first;
-      for (const auto& local_frame_id : map_entry.second) {
+      for (const auto& local_surface_id : map_entry.second) {
         RemoveSurfaceReferenceImpl(GetRootSurfaceId(),
-                                   SurfaceId(frame_sink_id, local_frame_id));
+                                   SurfaceId(frame_sink_id, local_surface_id));
       }
     }
     GarbageCollectSurfaces();
   }
 
   for (SurfaceDestroyList::iterator it = surfaces_to_destroy_.begin();
        it != surfaces_to_destroy_.end();
        ++it) {
     DeregisterSurface((*it)->surface_id());
   }
@@ skipping 83 matching lines @@
   // sent over IPC. We don't trust |child_id|, since it is sent over IPC.
   if (surface_map_.count(child_id) == 0) {
     DLOG(ERROR) << "No surface in map for " << child_id.ToString();
     return;
   }
 
   // There could be a temporary reference to |child_id| which we should now
   // remove because a real reference is being added to it. To find out whether
   // or not a temporary reference exists, we need to first look up the
   // FrameSinkId of |child_id| in |temp_references_|, which returns a vector of
-  // LocalFrameIds, and then search for the LocalFrameId of |child_id| in the
+  // LocalSurfaceIds, and then search for the LocalSurfaceId of |child_id| in
+  // the
   // said vector. If there is no temporary reference, we can immediately add the
   // reference from |parent_id| and return.
   auto refs_iter = temp_references_.find(child_id.frame_sink_id());
   if (refs_iter == temp_references_.end()) {
     AddSurfaceReferenceImpl(parent_id, child_id);
     return;
   }
-  std::vector<LocalFrameId>& refs = refs_iter->second;
+  std::vector<LocalSurfaceId>& refs = refs_iter->second;
   auto temp_ref_iter =
-      std::find(refs.begin(), refs.end(), child_id.local_frame_id());
+      std::find(refs.begin(), refs.end(), child_id.local_surface_id());
   if (temp_ref_iter == refs.end()) {
     AddSurfaceReferenceImpl(parent_id, child_id);
     return;
   }
 
   // Temporary references are implemented by holding a reference from the top
   // level root to the child. If |parent_id| is the top level root, we do
   // nothing because the reference already exists. Otherwise, remove the
   // temporary reference and add the reference.
   if (parent_id != GetRootSurfaceId()) {
@@ skipping 406 matching lines @@
 
   if (lifetime_type_ == LifetimeType::REFERENCES) {
     // We can get into a situation where multiple CompositorFrames arrive for a
     // CompositorFrameSink before the client can add any references for the
     // frame. When the second frame with a new size arrives, the first will be
     // destroyed in SurfaceFactory and then if there are no references it will
     // be deleted during surface GC. A temporary reference, removed when a real
     // reference is received, is added to prevent this from happening.
     AddSurfaceReferenceImpl(GetRootSurfaceId(), surface_info.id());
     temp_references_[surface_info.id().frame_sink_id()].push_back(
-        surface_info.id().local_frame_id());
+        surface_info.id().local_surface_id());
   }
 
   for (auto& observer : observer_list_)
     observer.OnSurfaceCreated(surface_info);
 }
 
 #if DCHECK_IS_ON()
 void SurfaceManager::SurfaceReferencesToStringImpl(const SurfaceId& surface_id,
                                                    std::string indent,
                                                    std::stringstream* str) {
@@ skipping 22 matching lines @@
     std::vector<SurfaceId> children(iter->second.begin(), iter->second.end());
     std::sort(children.begin(), children.end());
 
     for (const SurfaceId& child_id : children)
       SurfaceReferencesToStringImpl(child_id, indent + "  ", str);
   }
 }
 #endif  // DCHECK_IS_ON()
 
 }  // namespace cc