cc: Pass SurfaceId by const ref in more places

cc/surfaces/surface_hittest.cc

 // Copyright 2015 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_hittest.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_hittest_delegate.h"
 #include "cc/surfaces/surface_manager.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 SurfaceHittest::SurfaceHittest(SurfaceHittestDelegate* delegate,
                                SurfaceManager* manager)
     : delegate_(delegate), manager_(manager) {}
 
 SurfaceHittest::~SurfaceHittest() {}
 
-SurfaceId SurfaceHittest::GetTargetSurfaceAtPoint(SurfaceId root_surface_id,
-                                                  const gfx::Point& point,
-                                                  gfx::Transform* transform) {
+SurfaceId SurfaceHittest::GetTargetSurfaceAtPoint(
+    const SurfaceId& root_surface_id,
+    const gfx::Point& point,
+    gfx::Transform* transform) {
   SurfaceId out_surface_id = root_surface_id;
 
   // Reset the output transform to identity.
   if (transform)
     *transform = gfx::Transform();
 
   std::set<const RenderPass*> referenced_passes;
   GetTargetSurfaceAtPointInternal(root_surface_id, RenderPassId(), point,
                                   &referenced_passes, &out_surface_id,
                                   transform);
 
   return out_surface_id;
 }
 
-bool SurfaceHittest::GetTransformToTargetSurface(SurfaceId root_surface_id,
-                                                 SurfaceId target_surface_id,
-                                                 gfx::Transform* transform) {
+bool SurfaceHittest::GetTransformToTargetSurface(
+    const SurfaceId& root_surface_id,
+    const SurfaceId& target_surface_id,
+    gfx::Transform* transform) {
   // Reset the output transform to identity.
   if (transform)
     *transform = gfx::Transform();
 
   std::set<const RenderPass*> referenced_passes;
   return GetTransformToTargetSurfaceInternal(root_surface_id, target_surface_id,
                                              RenderPassId(), &referenced_passes,
                                              transform);
 }
 
 bool SurfaceHittest::GetTargetSurfaceAtPointInternal(
-    SurfaceId surface_id,
+    const SurfaceId& surface_id,
     const RenderPassId& render_pass_id,
     const gfx::Point& point_in_root_target,
     std::set<const RenderPass*>* referenced_passes,
     SurfaceId* out_surface_id,
     gfx::Transform* out_transform) {
   const RenderPass* render_pass =
       GetRenderPassForSurfaceById(surface_id, render_pass_id);
   if (!render_pass)
     return false;
 
@@ skipping 73 matching lines @@
     // need to iterate anymore, this is the quad that receives the event.
     *out_surface_id = surface_id;
     return true;
   }
 
   // No quads were found beneath the provided |point|.
   return false;
 }
 
 bool SurfaceHittest::GetTransformToTargetSurfaceInternal(
-    SurfaceId root_surface_id,
-    SurfaceId target_surface_id,
+    const SurfaceId& root_surface_id,
+    const SurfaceId& target_surface_id,
     const RenderPassId& render_pass_id,
     std::set<const RenderPass*>* referenced_passes,
     gfx::Transform* out_transform) {
   if (root_surface_id == target_surface_id) {
     *out_transform = gfx::Transform();
     return true;
   }
 
   const RenderPass* render_pass =
       GetRenderPassForSurfaceById(root_surface_id, render_pass_id);
@@ skipping 58 matching lines @@
 
       continue;
     }
   }
 
   // The target surface was not found.
   return false;
 }
 
 const RenderPass* SurfaceHittest::GetRenderPassForSurfaceById(
-    SurfaceId surface_id,
+    const SurfaceId& surface_id,
     const RenderPassId& render_pass_id) {
   Surface* surface = manager_->GetSurfaceForId(surface_id);
   if (!surface)
     return nullptr;
 
   const CompositorFrame& surface_frame = surface->GetEligibleFrame();
   if (!surface_frame.delegated_frame_data)
     return nullptr;
 
   const DelegatedFrameData* frame_data =
@@ skipping 31 matching lines @@
     return false;
   }
 
   *point_in_quad_space = point_in_render_pass_space;
   target_to_quad_transform->TransformPoint(point_in_quad_space);
 
   return quad->rect.Contains(*point_in_quad_space);
 }
 
 }  // namespace cc