Make RenderPass::Id an isolated class

cc/layers/delegated_renderer_layer_impl.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/layers/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 147 matching lines @@
 }
 
 void DelegatedRendererLayerImpl::SetRenderPasses(
     RenderPassList* render_passes_in_draw_order) {
   ClearRenderPasses();
 
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
     RenderPassList::iterator to_take =
         render_passes_in_draw_order->begin() + i;
     render_passes_index_by_id_.insert(
-        std::pair<RenderPass::Id, int>((*to_take)->id, i));
+        std::pair<RenderPassId, int>((*to_take)->id, i));
     scoped_ptr<RenderPass> taken_render_pass =
         render_passes_in_draw_order->take(to_take);
     render_passes_in_draw_order_.push_back(taken_render_pass.Pass());
   }
 
   // Give back an empty array instead of nulls.
   render_passes_in_draw_order->clear();
 }
 
 void DelegatedRendererLayerImpl::ClearRenderPasses() {
   render_passes_index_by_id_.clear();
   render_passes_in_draw_order_.clear();
 }
 
 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return DelegatedRendererLayerImpl::Create(
       tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void DelegatedRendererLayerImpl::ReleaseResources() {
   ClearRenderPasses();
   ClearChildId();
 }
 
 static inline int IndexToId(int index) { return index + 1; }
 static inline int IdToIndex(int id) { return id - 1; }
 
-RenderPass::Id DelegatedRendererLayerImpl::FirstContributingRenderPassId()
-    const {
-  return RenderPass::Id(id(), IndexToId(0));
+RenderPassId DelegatedRendererLayerImpl::FirstContributingRenderPassId() const {
+  return RenderPassId(id(), IndexToId(0));
 }
 
-RenderPass::Id DelegatedRendererLayerImpl::NextContributingRenderPassId(
-    RenderPass::Id previous) const {
-  return RenderPass::Id(previous.layer_id, previous.index + 1);
+RenderPassId DelegatedRendererLayerImpl::NextContributingRenderPassId(
+    RenderPassId previous) const {
+  return RenderPassId(previous.layer_id, previous.index + 1);
 }
 
 bool DelegatedRendererLayerImpl::ConvertDelegatedRenderPassId(
-    RenderPass::Id delegated_render_pass_id,
-    RenderPass::Id* output_render_pass_id) const {
-  base::hash_map<RenderPass::Id, int>::const_iterator found =
+    RenderPassId delegated_render_pass_id,
+    RenderPassId* output_render_pass_id) const {
+  base::hash_map<RenderPassId, int>::const_iterator found =
       render_passes_index_by_id_.find(delegated_render_pass_id);
   if (found == render_passes_index_by_id_.end()) {
     // Be robust against a RenderPass id that isn't part of the frame.
     return false;
   }
   unsigned delegated_render_pass_index = found->second;
   *output_render_pass_id =
-      RenderPass::Id(id(), IndexToId(delegated_render_pass_index));
+      RenderPassId(id(), IndexToId(delegated_render_pass_index));
   return true;
 }
 
 void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
     RenderPassSink* render_pass_sink) {
   DCHECK(HasContributingDelegatedRenderPasses());
 
   const RenderPass* root_delegated_render_pass =
       render_passes_in_draw_order_.back();
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
   gfx::Transform delegated_frame_to_root_transform = screen_space_transform();
   delegated_frame_to_root_transform.Scale(inverse_device_scale_factor_,
                                           inverse_device_scale_factor_);
 
   for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) {
-    RenderPass::Id output_render_pass_id(-1, -1);
+    RenderPassId output_render_pass_id(-1, -1);
     bool present =
         ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id,
                                      &output_render_pass_id);
 
     // Don't clash with the RenderPass we generate if we own a RenderSurface.
     DCHECK(present) << render_passes_in_draw_order_[i]->id.layer_id << ", "
                     << render_passes_in_draw_order_[i]->id.index;
     DCHECK_GT(output_render_pass_id.index, 0);
 
     scoped_ptr<RenderPass> copy_pass =
@@ skipping 14 matching lines @@
 void DelegatedRendererLayerImpl::AppendQuads(
     RenderPass* render_pass,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
   AppendRainbowDebugBorder(render_pass, append_quads_data);
 
   // This list will be empty after a lost context until a new frame arrives.
   if (render_passes_in_draw_order_.empty())
     return;
 
-  RenderPass::Id target_render_pass_id = append_quads_data->render_pass_id;
+  RenderPassId target_render_pass_id = append_quads_data->render_pass_id;
 
   const RenderPass* root_delegated_render_pass =
       render_passes_in_draw_order_.back();
 
   DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
 
   // If the index of the RenderPassId is 0, then it is a RenderPass generated
   // for a layer in this compositor, not the delegating renderer. Then we want
   // to merge our root RenderPass with the target RenderPass. Otherwise, it is
@@ skipping 169 matching lines @@
         delegated_quad->visible_rect, quad_content_to_delegated_target_space);
 
     if (quad_visible_rect.IsEmpty())
       continue;
 
     if (delegated_quad->material != DrawQuad::RENDER_PASS) {
       DrawQuad* output_quad = render_pass->CopyFromAndAppendDrawQuad(
           delegated_quad, output_shared_quad_state);
       output_quad->visible_rect = quad_visible_rect;
     } else {
-      RenderPass::Id delegated_contributing_render_pass_id =
+      RenderPassId delegated_contributing_render_pass_id =
           RenderPassDrawQuad::MaterialCast(delegated_quad)->render_pass_id;
-      RenderPass::Id output_contributing_render_pass_id(-1, -1);
+      RenderPassId output_contributing_render_pass_id(-1, -1);
 
       bool present =
           ConvertDelegatedRenderPassId(delegated_contributing_render_pass_id,
                                        &output_contributing_render_pass_id);
 
       // The frame may have a RenderPassDrawQuad that points to a RenderPass not
       // part of the frame. Just ignore these quads.
       if (present) {
         DCHECK(output_contributing_render_pass_id !=
                append_quads_data->render_pass_id);
@@ skipping 20 matching lines @@
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   resources_.clear();
   child_id_ = 0;
 }
 
 }  // namespace cc