Revert of cc: Fix size_t to int truncations in layers/ output/ playback/ quads/

cc/quads/render_pass.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/quads/render_pass.h"
 
 #include <algorithm>
 
-#include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/checkerboard_draw_quad.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
@@ skipping 26 matching lines @@
   return make_scoped_ptr(new RenderPass(num_layers));
 }
 
 scoped_ptr<RenderPass> RenderPass::Create(size_t shared_quad_state_list_size,
                                           size_t quad_list_size) {
   return make_scoped_ptr(
       new RenderPass(shared_quad_state_list_size, quad_list_size));
 }
 
 RenderPass::RenderPass()
-    : has_transparent_background(true),
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
       quad_list(kDefaultNumQuadsToReserve),
       shared_quad_state_list(sizeof(SharedQuadState),
                              kDefaultNumSharedQuadStatesToReserve) {
 }
 
 // Each layer usually produces one shared quad state, so the number of layers
 // is a good hint for what to reserve here.
 RenderPass::RenderPass(size_t num_layers)
-    : has_transparent_background(true),
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
       quad_list(kDefaultNumQuadsToReserve),
       shared_quad_state_list(sizeof(SharedQuadState), num_layers) {
 }
 
 RenderPass::RenderPass(size_t shared_quad_state_list_size,
                        size_t quad_list_size)
-    : has_transparent_background(true),
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
       quad_list(quad_list_size),
       shared_quad_state_list(sizeof(SharedQuadState),
                              shared_quad_state_list_size) {
 }
 
 RenderPass::~RenderPass() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
       "cc::RenderPass", id.AsTracingId());
 }
@@ skipping 56 matching lines @@
     }
     out->push_back(copy_pass.Pass());
   }
 }
 
 void RenderPass::SetNew(RenderPassId id,
                         const gfx::Rect& output_rect,
                         const gfx::Rect& damage_rect,
                         const gfx::Transform& transform_to_root_target) {
   DCHECK_GT(id.layer_id, 0);
+  DCHECK_GE(id.index, 0);
   DCHECK(damage_rect.IsEmpty() || output_rect.Contains(damage_rect))
       << "damage_rect: " << damage_rect.ToString()
       << " output_rect: " << output_rect.ToString();
 
   this->id = id;
   this->output_rect = output_rect;
   this->damage_rect = damage_rect;
   this->transform_to_root_target = transform_to_root_target;
 
   DCHECK(quad_list.empty());
   DCHECK(shared_quad_state_list.empty());
 }
 
 void RenderPass::SetAll(RenderPassId id,
                         const gfx::Rect& output_rect,
                         const gfx::Rect& damage_rect,
                         const gfx::Transform& transform_to_root_target,
                         bool has_transparent_background) {
   DCHECK_GT(id.layer_id, 0);
+  DCHECK_GE(id.index, 0);
 
   this->id = id;
   this->output_rect = output_rect;
   this->damage_rect = damage_rect;
   this->transform_to_root_target = transform_to_root_target;
   this->has_transparent_background = has_transparent_background;
 
   DCHECK(quad_list.empty());
   DCHECK(shared_quad_state_list.empty());
 }
 
 void RenderPass::AsValueInto(base::trace_event::TracedValue* value) const {
   MathUtil::AddToTracedValue("output_rect", output_rect, value);
   MathUtil::AddToTracedValue("damage_rect", damage_rect, value);
 
   value->SetBoolean("has_transparent_background", has_transparent_background);
-  value->SetInteger("copy_requests",
-                    base::saturated_cast<int>(copy_requests.size()));
+  value->SetInteger("copy_requests", copy_requests.size());
 
   value->BeginArray("shared_quad_state_list");
   for (const auto& shared_quad_state : shared_quad_state_list) {
     value->BeginDictionary();
     shared_quad_state->AsValueInto(value);
     value->EndDictionary();
   }
   value->EndArray();
 
   value->BeginArray("quad_list");
@@ skipping 64 matching lines @@
     case DrawQuad::RENDER_PASS:
     case DrawQuad::INVALID:
       LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
       break;
   }
   quad_list.back()->shared_quad_state = shared_quad_state;
   return quad_list.back();
 }
 
 }  // namespace cc