Improving flat containers interface.

cc/output/direct_renderer.cc

 // Copyright 2012 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/output/direct_renderer.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 174 matching lines @@
       if (const TileDrawQuad* tile_quad = CanPassBeDrawnDirectly(pass.get())) {
         // If the render pass is drawn directly, it will not be drawn from as
         // a render pass so it's not added to the map.
         render_pass_bypass_quads_[pass->id] = *tile_quad;
         continue;
       }
     }
     render_passes_in_frame[pass->id] = RenderPassTextureSize(pass.get());
   }
 
-  std::vector<int> passes_to_delete;
-  for (const auto& pair : render_pass_textures_) {
-    auto it = render_passes_in_frame.find(pair.first);
-    if (it == render_passes_in_frame.end()) {
-      passes_to_delete.push_back(pair.first);
-      continue;
-    }
+  base::EraseIf(render_pass_textures_,
+                [&](const std::pair<RenderPassId,

[danakj, 2017/07/20 16:12:20]

can you put the lambda in an auto var first, rather than nesting it all inside
EraseIf?

and maybe give it a name and/or comment that's clear this function is doing more
than an EraseIf comparison, it's also freeing textures of the wrong size, cuz
that seems surprising from an EraseIf() call.

Alternatively, if that seems hard to express, since these vectors are of sizes
around 1 to 3 elements.. you could split this into EraseIf() and a separate loop
for size checks.

[dyaroshev, 2017/07/20 16:33:02]

Just reverted and fixed compilation.

+                                    std::unique_ptr<ScopedResource>>& pair) {
+                  auto it = render_passes_in_frame.find(pair.first);
 
-    gfx::Size required_size = it->second;
-    ScopedResource* texture = pair.second.get();
-    DCHECK(texture);
+                  // Delete RenderPass textures from the previous frame that
+                  // will not be used again.
+                  if (it == render_passes_in_frame.end())
+                    return true;
 
-    bool size_appropriate = texture->size().width() >= required_size.width() &&
-                            texture->size().height() >= required_size.height();
-    if (texture->id() && !size_appropriate)
-      texture->Free();
-  }
+                  gfx::Size required_size = it->second;
+                  ScopedResource* texture = pair.second.get();
+                  DCHECK(texture);
 
-  // Delete RenderPass textures from the previous frame that will not be used
-  // again.
-  for (size_t i = 0; i < passes_to_delete.size(); ++i)
-    render_pass_textures_.erase(passes_to_delete[i]);
+                  bool size_appropriate =
+                      texture->size().width() >= required_size.width() &&
+                      texture->size().height() >= required_size.height();
+                  if (texture->id() && !size_appropriate)
+                    texture->Free();
+
+                  return false;
+                });
 
   for (auto& pass : render_passes_in_draw_order) {
     auto& resource = render_pass_textures_[pass->id];
     if (!resource)
       resource = base::MakeUnique<ScopedResource>(resource_provider_);
   }
 }
 
 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
                                float device_scale_factor,
@@ skipping 403 matching lines @@
   if (BindFramebufferToTexture(texture)) {
     InitializeViewport(current_frame(), render_pass->output_rect,
                        gfx::Rect(render_pass->output_rect.size()),
                        texture->size());
     return true;
   }
 
   return false;
 }
 
-bool DirectRenderer::HasAllocatedResourcesForTesting(int render_pass_id) const {
+bool DirectRenderer::HasAllocatedResourcesForTesting(
+    RenderPassId render_pass_id) const {
   auto iter = render_pass_textures_.find(render_pass_id);
   return iter != render_pass_textures_.end() && iter->second->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 void DirectRenderer::SetCurrentFrameForTesting(const DrawingFrame& frame) {
   current_frame_valid_ = true;
   current_frame_ = frame;
 }
 
 }  // namespace cc