Delete old RenderPassId mappings in SurfaceAggregator.

cc/surfaces/surface_aggregator.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 <map>
 
@@ skipping 75 matching lines @@
     if (out_clip.is_clipped)
       out_clip.rect.Intersect(final_clip);
     else
       out_clip.rect = final_clip;
     out_clip.is_clipped = true;
   }
 
   return out_clip;
 }
 
-class SurfaceAggregator::RenderPassIdAllocator {
- public:
-  explicit RenderPassIdAllocator(int* next_index) : next_index_(next_index) {}
-  ~RenderPassIdAllocator() {}
-
-  void AddKnownPass(RenderPassId id) {
-    if (id_to_index_map_.find(id) != id_to_index_map_.end())
-      return;
-    id_to_index_map_[id] = (*next_index_)++;
-  }
-
-  RenderPassId Remap(RenderPassId id) {
-    DCHECK(id_to_index_map_.find(id) != id_to_index_map_.end());
-    return RenderPassId(1, id_to_index_map_[id]);
-  }
-
- private:
-  std::unordered_map<RenderPassId, int, RenderPassIdHash> id_to_index_map_;
-  int* next_index_;
-
-  DISALLOW_COPY_AND_ASSIGN(RenderPassIdAllocator);
-};
-
 static void UnrefHelper(base::WeakPtr<SurfaceFactory> surface_factory,
                         const ReturnedResourceArray& resources,
                         BlockingTaskRunner* main_thread_task_runner) {
   if (surface_factory)
     surface_factory->UnrefResources(resources);
 }
 
 RenderPassId SurfaceAggregator::RemapPassId(RenderPassId surface_local_pass_id,
                                             const SurfaceId& surface_id) {
-  std::unique_ptr<RenderPassIdAllocator>& allocator =
-      render_pass_allocator_map_[surface_id];
-  if (!allocator)
-    allocator.reset(new RenderPassIdAllocator(&next_render_pass_id_));
-  allocator->AddKnownPass(surface_local_pass_id);
-  return allocator->Remap(surface_local_pass_id);
+  auto key = std::make_pair(surface_id, surface_local_pass_id);
+  auto it = render_pass_allocator_map_.find(key);
+  if (it != render_pass_allocator_map_.end()) {
+    it->second.in_use = true;
+    return it->second.id;
+  }
+
+  RenderPassInfo render_pass_info;
+  render_pass_info.id = RenderPassId(1, next_render_pass_id_++);
+  render_pass_allocator_map_[key] = render_pass_info;
+  return render_pass_info.id;
 }
 
 int SurfaceAggregator::ChildIdForSurface(Surface* surface) {
   SurfaceToResourceChildIdMap::iterator it =
       surface_id_to_resource_child_id_.find(surface->surface_id());
   if (it == surface_id_to_resource_child_id_.end()) {
     int child_id =
         provider_->CreateChild(base::Bind(&UnrefHelper, surface->factory()));
     if (surface->factory()) {
       provider_->SetChildNeedsSyncTokens(
@@ skipping 641 matching lines @@
 
   CopyUndrawnSurfaces(&prewalk_result);
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
   CopyPasses(root_surface_frame, surface);
   referenced_surfaces_.erase(it);
 
   moved_pixel_passes_.clear();
   copy_request_passes_.clear();
   render_pass_dependencies_.clear();
 
+  // Remove all render pass mappings that weren't used in the current frame.
+  for (auto it = render_pass_allocator_map_.begin();
+       it != render_pass_allocator_map_.end();) {
+    if (it->second.in_use) {
+      it->second.in_use = false;
+      it++;
+    } else {
+      it = render_pass_allocator_map_.erase(it);
+    }
+  }
+
   DCHECK(referenced_surfaces_.empty());
 
   if (dest_pass_list_->empty())
     return CompositorFrame();
 
   dest_pass_list_ = NULL;
   ProcessAddedAndRemovedSurfaces();
   contained_surfaces_.swap(previous_contained_surfaces_);
   contained_surfaces_.clear();
 
@@ skipping 22 matching lines @@
 
 void SurfaceAggregator::SetFullDamageForSurface(const SurfaceId& surface_id) {
   auto it = previous_contained_surfaces_.find(surface_id);
   if (it == previous_contained_surfaces_.end())
     return;
   // Set the last drawn index as 0 to ensure full damage next time it's drawn.
   it->second = 0;
 }
 
 }  // namespace cc