cc: Remove LayerTreeHostImpl::FrameData::render_passes_by_id.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 620 matching lines @@
       value->BeginDictionary();
       render_passes[i]->AsValueInto(value);
       value->EndDictionary();
     }
     value->EndArray();
   }
 }
 
 void LayerTreeHostImpl::FrameData::AppendRenderPass(
     scoped_ptr<RenderPass> render_pass) {
-  render_passes_by_id[render_pass->id] = render_pass.get();
   render_passes.push_back(render_pass.Pass());
 }
 
 DrawMode LayerTreeHostImpl::GetDrawMode() const {
   if (resourceless_software_draw_) {
     return DRAW_MODE_RESOURCELESS_SOFTWARE;
   } else if (output_surface_->context_provider()) {
     return DRAW_MODE_HARDWARE;
   } else {
     return DRAW_MODE_SOFTWARE;
@@ skipping 79 matching lines @@
     SolidColorDrawQuad* quad =
         target_render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     quad->SetNew(shared_quad_state,
                  screen_space_rect,
                  visible_screen_space_rect,
                  screen_background_color,
                  false);
   }
 }
 
+static RenderPass* FindRenderPassById(const RenderPassList& list,
+                                      RenderPassId id) {
+  auto it = std::find_if(list.begin(), list.end(),
+                         [id](const RenderPass* p) { return p->id == id; });
+  return it == list.end() ? nullptr : *it;
+}
+
 DrawResult LayerTreeHostImpl::CalculateRenderPasses(
     FrameData* frame) {
   DCHECK(frame->render_passes.empty());
   DCHECK(CanDraw());
   DCHECK(active_tree_->root_layer());
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
                             *frame->render_surface_layer_list);
 
   // If the root render surface has no visible damage, then don't generate a
@@ skipping 89 matching lines @@
   bool have_copy_request = false;
   bool have_missing_animated_tiles = false;
 
   LayerIterator end = LayerIterator::End(frame->render_surface_layer_list);
   for (LayerIterator it =
            LayerIterator::Begin(frame->render_surface_layer_list);
        it != end; ++it) {
     RenderPassId target_render_pass_id =
         it.target_render_surface_layer()->render_surface()->GetRenderPassId();
     RenderPass* target_render_pass =
-        frame->render_passes_by_id[target_render_pass_id];
+        FindRenderPassById(frame->render_passes, target_render_pass_id);
 
     AppendQuadsData append_quads_data;
 
     if (it.represents_target_render_surface()) {
       if (it->HasCopyRequest()) {
         have_copy_request = true;
         it->TakeCopyRequestsAndTransformToTarget(
             &target_render_pass->copy_requests);
       }
     } else if (it.represents_contributing_render_surface() &&
                it->render_surface()->contributes_to_drawn_surface()) {
       RenderPassId contributing_render_pass_id =
           it->render_surface()->GetRenderPassId();
       RenderPass* contributing_render_pass =
-          frame->render_passes_by_id[contributing_render_pass_id];
+          FindRenderPassById(frame->render_passes, contributing_render_pass_id);
       AppendQuadsForRenderSurfaceLayer(target_render_pass,
                                        *it,
                                        contributing_render_pass,
                                        &append_quads_data);
     } else if (it.represents_itself() && !it->visible_layer_rect().IsEmpty()) {
       bool occluded =
           it->draw_properties().occlusion_in_content_space.IsOccluded(
               it->visible_layer_rect());
       if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
         DCHECK_EQ(active_tree_, it->layer_tree_impl());
 
         frame->will_draw_layers.push_back(*it);
 
         if (it->HasContributingDelegatedRenderPasses()) {
           RenderPassId contributing_render_pass_id =
               it->FirstContributingRenderPassId();
-          while (frame->render_passes_by_id.find(contributing_render_pass_id) !=
-                 frame->render_passes_by_id.end()) {
-            RenderPass* render_pass =
-                frame->render_passes_by_id[contributing_render_pass_id];
-
-            it->AppendQuads(render_pass, &append_quads_data);
-
+          while (true) {
+            RenderPass* pass = FindRenderPassById(frame->render_passes,
+                                                  contributing_render_pass_id);
+            if (!pass)
+              break;
+            it->AppendQuads(pass, &append_quads_data);
             contributing_render_pass_id =
                 it->NextContributingRenderPassId(contributing_render_pass_id);
           }
         }
 
         it->AppendQuads(target_render_pass, &append_quads_data);
 
         // For layers that represent themselves, add composite frame timing
         // requests if the visible rect intersects the requested rect.
         for (const auto& request : it->frame_timing_requests()) {
@@ skipping 50 matching lines @@
   // surface the compositor draws to, so even though the frame may not be
   // complete, the previous frame has already been potentially lost, so an
   // incomplete frame is better than nothing, so this takes highest precidence.
   if (resourceless_software_draw_)
     draw_result = DRAW_SUCCESS;
 
 #if DCHECK_IS_ON()
   for (const auto& render_pass : frame->render_passes) {
     for (const auto& quad : render_pass->quad_list)
       DCHECK(quad->shared_quad_state);
-    DCHECK(frame->render_passes_by_id.find(render_pass->id) !=
-           frame->render_passes_by_id.end());
   }
+  DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 #endif
-  DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 
   if (!active_tree_->has_transparent_background()) {
     frame->render_passes.back()->has_transparent_background = false;
     AppendQuadsToFillScreen(
         active_tree_->RootScrollLayerDeviceViewportBounds(),
         frame->render_passes.back(), active_tree_->root_layer(),
         active_tree_->background_color(), unoccluded_screen_space_region);
   }
 
   RemoveRenderPasses(frame);
@@ skipping 95 matching lines @@
   bool ok = active_tree_->UpdateDrawProperties(update_lcd_text);
   DCHECK(ok) << "UpdateDrawProperties failed during draw";
 
   // This will cause NotifyTileStateChanged() to be called for any tiles that
   // completed, which will add damage for visible tiles to the frame for them so
   // they appear as part of the current frame being drawn.
   tile_manager_->Flush();
 
   frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
   frame->render_passes.clear();
-  frame->render_passes_by_id.clear();
   frame->will_draw_layers.clear();
   frame->has_no_damage = false;
 
   if (active_tree_->root_layer()) {
     gfx::Rect device_viewport_damage_rect = viewport_damage_rect_;
     viewport_damage_rect_ = gfx::Rect();
 
     active_tree_->root_layer()->render_surface()->damage_tracker()->
         AddDamageNextUpdate(device_viewport_damage_rect);
   }
@@ skipping 43 matching lines @@
     }
 
     if (i == frame->render_passes.size() - 1) {
       // Don't remove the root RenderPass.
       break;
     }
 
     if (pass->quad_list.empty() && pass->copy_requests.empty()) {
       // Remove the pass and decrement |i| to counter the for loop's increment,
       // so we don't skip the next pass in the loop.
-      frame->render_passes_by_id.erase(pass->id);
       frame->render_passes.erase(frame->render_passes.begin() + i);
       --i;
       continue;
     }
 
     pass_exists.insert(pass->id);
   }
 
   // Remove RenderPasses that are not referenced by any draw quads or copy
   // requests (except the root RenderPass).
   for (size_t i = 0; i < frame->render_passes.size() - 1; ++i) {
     // Iterating from the back of the list to the front, skipping over the
     // back-most (root) pass, in order to remove each qualified RenderPass, and
     // drop references to earlier RenderPasses allowing them to be removed to.
     RenderPass* pass =
         frame->render_passes[frame->render_passes.size() - 2 - i];
     if (!pass->copy_requests.empty())
       continue;
     if (pass_references[pass->id])
       continue;
 
     for (auto it = pass->quad_list.begin(); it != pass->quad_list.end(); ++it) {
       if (it->material != DrawQuad::RENDER_PASS)
         continue;
       const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(*it);
       pass_references[quad->render_pass_id]--;
     }
 
-    frame->render_passes_by_id.erase(pass->id);
     frame->render_passes.erase(frame->render_passes.end() - 2 - i);
     --i;
   }
 }
 
 void LayerTreeHostImpl::EvictTexturesForTesting() {
   UpdateTileManagerMemoryPolicy(ManagedMemoryPolicy(0));
 }
 
 void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
@@ skipping 440 matching lines @@
     temp_software_renderer->DrawFrame(
         &frame->render_passes, active_tree_->device_scale_factor(),
         DeviceViewport(), DeviceClip(), disable_picture_quad_image_filtering);
   } else {
     renderer_->DrawFrame(&frame->render_passes,
                          active_tree_->device_scale_factor(), DeviceViewport(),
                          DeviceClip(), false);
   }
   // The render passes should be consumed by the renderer.
   DCHECK(frame->render_passes.empty());
-  frame->render_passes_by_id.clear();
 
   // The next frame should start by assuming nothing has changed, and changes
   // are noted as they occur.
   // TODO(boliu): If we did a temporary software renderer frame, propogate the
   // damage forward to the next frame.
   for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
     (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
         DidDrawDamagedArea();
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
@@ skipping 2013 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc