Switch cc::RenderPassId and cc::DrawQuad::Resources to use uint32_t instead of size_t.

content/common/cc_messages.cc

 // Copyright (c) 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 "content/common/cc_messages.h"
 
 #include <stddef.h>
 #include <utility>
 
+#include "base/numerics/safe_conversions.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/filter_operations.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/render_pass_id.h"
 #include "content/public/common/common_param_traits.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkFlattenableSerialization.h"
 #include "ui/gfx/transform.h"
 
@@ skipping 159 matching lines @@
       break;
     case cc::FilterOperation::ALPHA_THRESHOLD:
       NOTREACHED();
       break;
   }
   l->append(")");
 }
 
 void ParamTraits<cc::FilterOperations>::Write(base::Pickle* m,
                                               const param_type& p) {
-  WriteParam(m, p.size());
+  WriteParam(m, base::checked_cast<uint32_t>(p.size()));
   for (std::size_t i = 0; i < p.size(); ++i) {
     WriteParam(m, p.at(i));
   }
 }
 
 bool ParamTraits<cc::FilterOperations>::Read(const base::Pickle* m,
                                              base::PickleIterator* iter,
                                              param_type* r) {
-  size_t count;
+  uint32_t count;
   if (!ReadParam(m, iter, &count))
     return false;
 
   for (std::size_t i = 0; i < count; ++i) {
     cc::FilterOperation op = cc::FilterOperation::CreateEmptyFilter();
     if (!ReadParam(m, iter, &op))
       return false;
     r->Append(op);
   }
   return true;
@@ skipping 85 matching lines @@
   }
   l->append(") ");
 }
 
 void ParamTraits<cc::RenderPass>::Write(base::Pickle* m, const param_type& p) {
   WriteParam(m, p.id);
   WriteParam(m, p.output_rect);
   WriteParam(m, p.damage_rect);
   WriteParam(m, p.transform_to_root_target);
   WriteParam(m, p.has_transparent_background);
-  WriteParam(m, p.quad_list.size());
+  WriteParam(m, base::checked_cast<uint32_t>(p.quad_list.size()));
 
   cc::SharedQuadStateList::ConstIterator shared_quad_state_iter =
       p.shared_quad_state_list.begin();
   cc::SharedQuadStateList::ConstIterator last_shared_quad_state_iter =
       p.shared_quad_state_list.end();
   for (const auto& quad : p.quad_list) {
     DCHECK(quad->rect.Contains(quad->visible_rect))
         << quad->material << " rect: " << quad->rect.ToString()
         << " visible_rect: " << quad->visible_rect.ToString();
     DCHECK(quad->opaque_rect.IsEmpty() ||
@@ skipping 83 matching lines @@
 }
 
 bool ParamTraits<cc::RenderPass>::Read(const base::Pickle* m,
                                        base::PickleIterator* iter,
                                        param_type* p) {
   cc::RenderPassId id;
   gfx::Rect output_rect;
   gfx::Rect damage_rect;
   gfx::Transform transform_to_root_target;
   bool has_transparent_background;
-  size_t quad_list_size;
+  uint32_t quad_list_size;
 
   if (!ReadParam(m, iter, &id) || !ReadParam(m, iter, &output_rect) ||
       !ReadParam(m, iter, &damage_rect) ||
       !ReadParam(m, iter, &transform_to_root_target) ||
       !ReadParam(m, iter, &has_transparent_background) ||
       !ReadParam(m, iter, &quad_list_size))
     return false;
 
   p->SetAll(id,
             output_rect,
             damage_rect,
             transform_to_root_target,
             has_transparent_background);
 
-  for (size_t i = 0; i < quad_list_size; ++i) {
+  for (uint32_t i = 0; i < quad_list_size; ++i) {
     cc::DrawQuad::Material material;
     base::PickleIterator temp_iter = *iter;
     if (!ReadParam(m, &temp_iter, &material))
       return false;
 
     cc::DrawQuad* draw_quad = NULL;
     switch (material) {
       case cc::DrawQuad::DEBUG_BORDER:
         draw_quad = ReadDrawQuad<cc::DebugBorderDrawQuad>(m, iter, p);
         break;
@@ skipping 238 matching lines @@
   size_t to_reserve = sizeof(p.device_scale_factor);
   to_reserve += p.resource_list.size() * sizeof(cc::TransferableResource);
   for (const auto& pass : p.render_pass_list) {
     to_reserve += sizeof(size_t) * 2;
     to_reserve += ReserveSizeForRenderPassWrite(*pass);
   }
   m->Reserve(to_reserve);
 
   WriteParam(m, p.device_scale_factor);
   WriteParam(m, p.resource_list);
-  WriteParam(m, p.render_pass_list.size());
+  WriteParam(m, static_cast<uint32_t>(p.render_pass_list.size()));

[enne (OOO), 2016/02/08 18:39:26]

Should these be checked_cast too?

[jam, 2016/02/08 18:43:43]

yeah, done

   for (const auto& pass : p.render_pass_list) {
-    WriteParam(m, pass->quad_list.size());
-    WriteParam(m, pass->shared_quad_state_list.size());
+    WriteParam(m, static_cast<uint32_t>(pass->quad_list.size()));
+    WriteParam(m, static_cast<uint32_t>(pass->shared_quad_state_list.size()));
     WriteParam(m, *pass);
   }
 }
 
 bool ParamTraits<cc::DelegatedFrameData>::Read(const base::Pickle* m,
                                                base::PickleIterator* iter,
                                                param_type* p) {
   if (!ReadParam(m, iter, &p->device_scale_factor))
     return false;
 
   const static size_t kMaxRenderPasses = 10000;
   const static size_t kMaxSharedQuadStateListSize = 100000;
   const static size_t kMaxQuadListSize = 1000000;
 
   std::set<cc::RenderPassId> pass_set;
 
-  size_t num_render_passes;
+  uint32_t num_render_passes;
   if (!ReadParam(m, iter, &p->resource_list) ||
       !ReadParam(m, iter, &num_render_passes) ||
       num_render_passes > kMaxRenderPasses || num_render_passes == 0)
     return false;
-  for (size_t i = 0; i < num_render_passes; ++i) {
-    size_t quad_list_size;
-    size_t shared_quad_state_list_size;
+  for (uint32_t i = 0; i < num_render_passes; ++i) {
+    uint32_t quad_list_size;
+    uint32_t shared_quad_state_list_size;
     if (!ReadParam(m, iter, &quad_list_size) ||
         !ReadParam(m, iter, &shared_quad_state_list_size) ||
         quad_list_size > kMaxQuadListSize ||
         shared_quad_state_list_size > kMaxSharedQuadStateListSize)
       return false;
     scoped_ptr<cc::RenderPass> render_pass =
-        cc::RenderPass::Create(shared_quad_state_list_size, quad_list_size);
+        cc::RenderPass::Create(
+            static_cast<size_t>(shared_quad_state_list_size),
+            static_cast<size_t>(quad_list_size));
     if (!ReadParam(m, iter, render_pass.get()))
       return false;
     // Validate that each RenderPassDrawQuad points at a valid RenderPass
     // earlier in the frame.
     for (const auto* quad : render_pass->quad_list) {
       if (quad->material != cc::DrawQuad::RENDER_PASS)
         continue;
       const cc::RenderPassDrawQuad* rpdq =
           cc::RenderPassDrawQuad::MaterialCast(quad);
       if (!pass_set.count(rpdq->render_pass_id))
@@ skipping 115 matching lines @@
   l->append("TextureDrawQuad::OverlayResources([");
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     LogParam(p.size_in_pixels[i], l);
     if (i < (cc::DrawQuad::Resources::kMaxResourceIdCount - 1))
       l->append(", ");
   }
   l->append("])");
 }
 
 }  // namespace IPC