Make RenderPass::Id an isolated class

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 "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 17 matching lines @@
 }
 
 SurfaceAggregator::~SurfaceAggregator() {}
 
 class SurfaceAggregator::RenderPassIdAllocator {
  public:
   explicit RenderPassIdAllocator(SurfaceId surface_id)
       : surface_id_(surface_id), next_index_(1) {}
   ~RenderPassIdAllocator() {}
 
-  void AddKnownPass(RenderPass::Id id) {
+  void AddKnownPass(RenderPassId id) {
     if (id_to_index_map_.find(id) != id_to_index_map_.end())
       return;
     id_to_index_map_[id] = next_index_++;
   }
 
-  RenderPass::Id Remap(RenderPass::Id id) {
+  RenderPassId Remap(RenderPassId id) {
     DCHECK(id_to_index_map_.find(id) != id_to_index_map_.end());
-    return RenderPass::Id(surface_id_.id, id_to_index_map_[id]);
+    return RenderPassId(surface_id_.id, id_to_index_map_[id]);
   }
 
  private:
-  base::hash_map<RenderPass::Id, int> id_to_index_map_;
+  base::hash_map<RenderPassId, int> id_to_index_map_;
   SurfaceId surface_id_;
   int next_index_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderPassIdAllocator);
 };
 
-RenderPass::Id SurfaceAggregator::RemapPassId(
-    RenderPass::Id surface_local_pass_id,
-    SurfaceId surface_id) {
+RenderPassId SurfaceAggregator::RemapPassId(RenderPassId surface_local_pass_id,
+                                            SurfaceId surface_id) {
   RenderPassIdAllocator* allocator = render_pass_allocator_map_.get(surface_id);
   if (!allocator) {
     allocator = new RenderPassIdAllocator(surface_id);
     render_pass_allocator_map_.set(surface_id, make_scoped_ptr(allocator));
   }
   allocator->AddKnownPass(surface_local_pass_id);
   return allocator->Remap(surface_local_pass_id);
 }
 
 int SurfaceAggregator::ChildIdForSurface(Surface* surface) {
@@ skipping 87 matching lines @@
     return;
 
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
 
   const RenderPassList& referenced_passes = render_pass_list;
   for (size_t j = 0; j + 1 < referenced_passes.size(); ++j) {
     const RenderPass& source = *referenced_passes[j];
 
     scoped_ptr<RenderPass> copy_pass(RenderPass::Create());
 
-    RenderPass::Id remapped_pass_id = RemapPassId(source.id, surface_id);
+    RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
 
     copy_pass->SetAll(remapped_pass_id,
                       source.output_rect,
                       source.damage_rect,
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     // Contributing passes aggregated in to the pass list need to take the
     // transform of the surface quad into account to update their transform to
     // the root surface.
@@ skipping 67 matching lines @@
       HandleSurfaceQuad(surface_quad, dest_pass);
     } else {
       if (quad->shared_quad_state != last_copied_source_shared_quad_state) {
         CopySharedQuadState(
             quad->shared_quad_state, content_to_target_transform, dest_pass);
         last_copied_source_shared_quad_state = quad->shared_quad_state;
       }
       if (quad->material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_quad =
             RenderPassDrawQuad::MaterialCast(quad);
-        RenderPass::Id original_pass_id = pass_quad->render_pass_id;
-        RenderPass::Id remapped_pass_id =
+        RenderPassId original_pass_id = pass_quad->render_pass_id;
+        RenderPassId remapped_pass_id =
             RemapPassId(original_pass_id, surface_id);
 
         dest_pass->CopyFromAndAppendRenderPassDrawQuad(
             pass_quad,
             dest_pass->shared_quad_state_list.back(),
             remapped_pass_id);
       } else {
         dest_pass->CopyFromAndAppendDrawQuad(
             quad, dest_pass->shared_quad_state_list.back());
       }
     }
   }
 }
 
 void SurfaceAggregator::CopyPasses(const RenderPassList& source_pass_list,
                                    SurfaceId surface_id) {
   for (size_t i = 0; i < source_pass_list.size(); ++i) {
     const RenderPass& source = *source_pass_list[i];
 
     scoped_ptr<RenderPass> copy_pass(RenderPass::Create());
 
-    RenderPass::Id remapped_pass_id = RemapPassId(source.id, surface_id);
+    RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
 
     copy_pass->SetAll(remapped_pass_id,
                       source.output_rect,
                       source.damage_rect,
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     CopyQuadsToPass(source.quad_list,
                     source.shared_quad_state_list,
                     gfx::Transform(),
@@ skipping 41 matching lines @@
 
   dest_pass_list_ = NULL;
 
   // TODO(jamesr): Aggregate all resource references into the returned frame's
   // resource list.
 
   return frame.Pass();
 }
 
 }  // namespace cc