cc: Pass SurfaceId by const ref in more places

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 106 matching lines @@
 };
 
 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,
-                                            SurfaceId surface_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);
 }
 
 int SurfaceAggregator::ChildIdForSurface(Surface* surface) {
   SurfaceToResourceChildIdMap::iterator it =
@@ skipping 15 matching lines @@
 gfx::Rect SurfaceAggregator::DamageRectForSurface(
     const Surface* surface,
     const RenderPass& source,
     const gfx::Rect& full_rect) const {
   auto it = previous_contained_surfaces_.find(surface->surface_id());
   if (it != previous_contained_surfaces_.end()) {
     int previous_index = it->second;
     if (previous_index == surface->frame_index())
       return gfx::Rect();
   }
-  SurfaceId previous_surface_id = surface->previous_frame_surface_id();
+  const SurfaceId& previous_surface_id = surface->previous_frame_surface_id();
 
   if (surface->surface_id() != previous_surface_id) {
     it = previous_contained_surfaces_.find(previous_surface_id);
   }
   if (it != previous_contained_surfaces_.end()) {
     int previous_index = it->second;
     if (previous_index == surface->frame_index() - 1)
       return source.damage_rect;
   }
 
@@ skipping 177 matching lines @@
   return true;
 }
 
 void SurfaceAggregator::CopyQuadsToPass(
     const QuadList& source_quad_list,
     const SharedQuadStateList& source_shared_quad_state_list,
     const ResourceProvider::ResourceIdMap& child_to_parent_map,
     const gfx::Transform& target_transform,
     const ClipData& clip_rect,
     RenderPass* dest_pass,
-    SurfaceId surface_id) {
+    const SurfaceId& surface_id) {
   const SharedQuadState* last_copied_source_shared_quad_state = nullptr;
   const SharedQuadState* dest_shared_quad_state = nullptr;
   // If the current frame has copy requests then aggregate the entire
   // thing, as otherwise parts of the copy requests may be ignored.
   const bool ignore_undamaged = aggregate_only_damaged_ &&
                                 !has_copy_requests_ &&
                                 !moved_pixel_passes_.count(dest_pass->id);
   // Damage rect in the quad space of the current shared quad state.
   // TODO(jbauman): This rect may contain unnecessary area if
   // transform isn't axis-aligned.
@@ skipping 164 matching lines @@
       if (surface_ptr) {
         surface_ptr->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
       }
     }
   }
 }
 
 // Walk the Surface tree from surface_id. Validate the resources of the current
 // surface and its descendants, check if there are any copy requests, and
 // return the combined damage rect.
-gfx::Rect SurfaceAggregator::PrewalkTree(SurfaceId surface_id,
+gfx::Rect SurfaceAggregator::PrewalkTree(const SurfaceId& surface_id,
                                          bool in_moved_pixel_pass,
                                          RenderPassId parent_pass,
                                          PrewalkResult* result) {
   // This is for debugging a possible use after free.
   // TODO(jbauman): Remove this once we have enough information.
   // http://crbug.com/560181
   base::WeakPtr<SurfaceAggregator> debug_weak_this = weak_factory_.GetWeakPtr();
 
   if (referenced_surfaces_.count(surface_id))
     return gfx::Rect();
@@ skipping 201 matching lines @@
     if (it == render_pass_dependencies_.end())
       continue;
     for (auto pass : it->second) {
       if (copy_request_passes_.insert(pass).second) {
         copy_requests_to_iterate.push_back(pass);
       }
     }
   }
 }
 
-CompositorFrame SurfaceAggregator::Aggregate(SurfaceId surface_id) {
+CompositorFrame SurfaceAggregator::Aggregate(const SurfaceId& surface_id) {
   Surface* surface = manager_->GetSurfaceForId(surface_id);
   DCHECK(surface);
   contained_surfaces_[surface_id] = surface->frame_index();
   const CompositorFrame& root_surface_frame = surface->GetEligibleFrame();
   if (!root_surface_frame.delegated_frame_data)
     return CompositorFrame();
   TRACE_EVENT0("cc", "SurfaceAggregator::Aggregate");
 
   CompositorFrame frame;
   frame.delegated_frame_data = base::WrapUnique(new DelegatedFrameData);
@@ skipping 34 matching lines @@
     if (surface)
       surface->TakeLatencyInfo(&frame.metadata.latency_info);
   }
 
   // TODO(jamesr): Aggregate all resource references into the returned frame's
   // resource list.
 
   return frame;
 }
 
-void SurfaceAggregator::ReleaseResources(SurfaceId surface_id) {
+void SurfaceAggregator::ReleaseResources(const SurfaceId& surface_id) {
   SurfaceToResourceChildIdMap::iterator it =
       surface_id_to_resource_child_id_.find(surface_id);
   if (it != surface_id_to_resource_child_id_.end()) {
     provider_->DestroyChild(it->second);
     surface_id_to_resource_child_id_.erase(it);
   }
 }
 
-void SurfaceAggregator::SetFullDamageForSurface(SurfaceId surface_id) {
+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