Use Custome ListContainer to Allocate SharedQuadState

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 "cc/output/compositor_frame.h"
 #include "cc/output/filter_operations.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "content/public/common/common_param_traits.h"
@@ skipping 276 matching lines @@
   l->append(") ");
 }
 
 void ParamTraits<cc::RenderPass>::Write(
     Message* 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.shared_quad_state_list.size());
   WriteParam(m, p.quad_list.size());
 
-  size_t shared_quad_state_index = 0;
-  size_t last_shared_quad_state_index = kuint32max;
-  for (cc::QuadList::ConstIterator iter = p.quad_list.begin();
-       iter != p.quad_list.end();
-       ++iter) {
-    const cc::DrawQuad* quad = &*iter;
-    DCHECK(quad->rect.Contains(quad->visible_rect))
-        << quad->material << " rect: " << quad->rect.ToString()
-        << " visible_rect: " << quad->visible_rect.ToString();
-    DCHECK(quad->opaque_rect.IsEmpty() ||
-           quad->rect.Contains(quad->opaque_rect))
-        << quad->material << " rect: " << quad->rect.ToString()
-        << " opaque_rect: " << quad->opaque_rect.ToString();
+  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() || quad.rect.Contains(quad.opaque_rect))
+        << quad.material << " rect: " << quad.rect.ToString()
+        << " opaque_rect: " << quad.opaque_rect.ToString();
 
-    switch (quad->material) {
+    switch (quad.material) {
       case cc::DrawQuad::CHECKERBOARD:
-        WriteParam(m, *cc::CheckerboardDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::CheckerboardDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::DEBUG_BORDER:
-        WriteParam(m, *cc::DebugBorderDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::DebugBorderDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::IO_SURFACE_CONTENT:
-        WriteParam(m, *cc::IOSurfaceDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::IOSurfaceDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::PICTURE_CONTENT:
         NOTREACHED();
         break;
       case cc::DrawQuad::TEXTURE_CONTENT:
-        WriteParam(m, *cc::TextureDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::TextureDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::RENDER_PASS:
-        WriteParam(m, *cc::RenderPassDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::RenderPassDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::SOLID_COLOR:
-        WriteParam(m, *cc::SolidColorDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::SolidColorDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::SURFACE_CONTENT:
-        WriteParam(m, *cc::SurfaceDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::SurfaceDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::TILED_CONTENT:
-        WriteParam(m, *cc::TileDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::TileDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
-        WriteParam(m, *cc::StreamVideoDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::StreamVideoDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::YUV_VIDEO_CONTENT:
-        WriteParam(m, *cc::YUVVideoDrawQuad::MaterialCast(quad));
+        WriteParam(m, *cc::YUVVideoDrawQuad::MaterialCast(&quad));
         break;
       case cc::DrawQuad::INVALID:
         break;
     }
 
-    const cc::ScopedPtrVector<cc::SharedQuadState>& sqs_list =
-        p.shared_quad_state_list;
-
-    // This is an invalid index.
-    size_t bad_index = sqs_list.size();
-
     // Null shared quad states should not occur.
-    DCHECK(quad->shared_quad_state);
-    if (!quad->shared_quad_state) {
-      WriteParam(m, bad_index);
-      continue;
-    }
+    DCHECK(quad.shared_quad_state);
 
     // SharedQuadStates should appear in the order they are used by DrawQuads.
     // Find the SharedQuadState for this DrawQuad.
-    while (shared_quad_state_index < sqs_list.size() &&
-           quad->shared_quad_state != sqs_list[shared_quad_state_index])
-      ++shared_quad_state_index;
+    while (shared_quad_state_iter != p.shared_quad_state_list.end() &&
+           quad.shared_quad_state != &*shared_quad_state_iter)
+      ++shared_quad_state_iter;
 
-    DCHECK_LT(shared_quad_state_index, sqs_list.size());
-    if (shared_quad_state_index >= sqs_list.size()) {
-      WriteParam(m, bad_index);
-      continue;
-    }
+    DCHECK(shared_quad_state_iter != p.shared_quad_state_list.end());
 
-    WriteParam(m, shared_quad_state_index);
-    if (shared_quad_state_index != last_shared_quad_state_index) {
-      WriteParam(m, *sqs_list[shared_quad_state_index]);
-      last_shared_quad_state_index = shared_quad_state_index;
+    if (shared_quad_state_iter != last_shared_quad_state_iter) {
+      WriteParam(m, true);
+      WriteParam(m, *shared_quad_state_iter);
+      last_shared_quad_state_iter = shared_quad_state_iter;
+    } else {
+      WriteParam(m, false);
     }
   }
 }
 
 static size_t ReserveSizeForRenderPassWrite(const cc::RenderPass& p) {
   size_t to_reserve = sizeof(cc::RenderPass);
 
+  // Whether the quad points to a new shared quad state for each quad.
+  to_reserve += p.quad_list.size() * sizeof(bool);
+
+  // Shared quad state is only written when a quad contains a shared quad state
+  // that has not been written.
   to_reserve += p.shared_quad_state_list.size() * sizeof(cc::SharedQuadState);
 
-  // The shared_quad_state_index for each quad.
-  to_reserve += p.quad_list.size() * sizeof(size_t);
-
   // The largest quad type, verified by a unit test.
   to_reserve += p.quad_list.size() * sizeof(cc::kLargestDrawQuad);
   return to_reserve;
 }
 
 template <typename QuadType>
 static cc::DrawQuad* ReadDrawQuad(const Message* m,
                                   PickleIterator* iter,
                                   cc::RenderPass* render_pass) {
   QuadType* quad = render_pass->CreateAndAppendDrawQuad<QuadType>();
   if (!ReadParam(m, iter, quad))
     return NULL;
   return quad;
 }
 
 bool ParamTraits<cc::RenderPass>::Read(
     const Message* m, PickleIterator* iter, param_type* p) {
   cc::RenderPassId id(-1, -1);
   gfx::Rect output_rect;
   gfx::Rect damage_rect;
   gfx::Transform transform_to_root_target;
   bool has_transparent_background;
-  size_t shared_quad_state_list_size;
   size_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, &shared_quad_state_list_size) ||
       !ReadParam(m, iter, &quad_list_size))
     return false;
 
   p->SetAll(id,
             output_rect,
             damage_rect,
             transform_to_root_target,
             has_transparent_background);
 
-  size_t last_shared_quad_state_index = kuint32max;
   for (size_t i = 0; i < quad_list_size; ++i) {
     cc::DrawQuad::Material material;
     PickleIterator temp_iter = *iter;
     if (!ReadParam(m, &temp_iter, &material))
       return false;
 
     cc::DrawQuad* draw_quad = NULL;
     switch (material) {
       case cc::DrawQuad::CHECKERBOARD:
         draw_quad = ReadDrawQuad<cc::CheckerboardDrawQuad>(m, iter, p);
@@ skipping 40 matching lines @@
       return false;
     }
     if (!draw_quad->opaque_rect.IsEmpty() &&
         !draw_quad->rect.Contains(draw_quad->opaque_rect)) {
       LOG(ERROR) << "Quad with invalid opaque rect " << draw_quad->material
                  << " rect: " << draw_quad->rect.ToString()
                  << " opaque_rect: " << draw_quad->opaque_rect.ToString();
       return false;
     }
 
-    size_t shared_quad_state_index;
-    if (!ReadParam(m, iter, &shared_quad_state_index))
-      return false;
-    if (shared_quad_state_index >= shared_quad_state_list_size)
-      return false;
-    // SharedQuadState indexes should be in ascending order.
-    if (last_shared_quad_state_index != kuint32max &&
-        shared_quad_state_index < last_shared_quad_state_index)
+    bool has_new_shared_quad_state;
+    if (!ReadParam(m, iter, &has_new_shared_quad_state))
       return false;
 
     // If the quad has a new shared quad state, read it in.
-    if (last_shared_quad_state_index != shared_quad_state_index) {
+    if (has_new_shared_quad_state) {
       cc::SharedQuadState* state = p->CreateAndAppendSharedQuadState();
       if (!ReadParam(m, iter, state))
         return false;
-      last_shared_quad_state_index = shared_quad_state_index;
     }
 
     draw_quad->shared_quad_state = p->shared_quad_state_list.back();
   }
 
   return true;
 }
 
 void ParamTraits<cc::RenderPass>::Log(
     const param_type& p, std::string* l) {
   l->append("RenderPass((");
   LogParam(p.id, l);
   l->append("), ");
   LogParam(p.output_rect, l);
   l->append(", ");
   LogParam(p.damage_rect, l);
   l->append(", ");
   LogParam(p.transform_to_root_target, l);
   l->append(", ");
   LogParam(p.has_transparent_background, l);
   l->append(", ");
 
   l->append("[");
-  for (size_t i = 0; i < p.shared_quad_state_list.size(); ++i) {
-    if (i)
+  for (const auto& shared_quad_state : p.shared_quad_state_list) {
+    if (&shared_quad_state != p.shared_quad_state_list.front())
       l->append(", ");
-    LogParam(*p.shared_quad_state_list[i], l);
+    LogParam(shared_quad_state, l);
   }
   l->append("], [");
-  for (cc::QuadList::ConstIterator iter = p.quad_list.begin();
-       iter != p.quad_list.end();
-       ++iter) {
-    if (iter != p.quad_list.begin())
+  for (const auto& quad : p.quad_list) {
+    if (&quad != p.quad_list.front())
       l->append(", ");
-    const cc::DrawQuad* quad = &*iter;
-    switch (quad->material) {
+    switch (quad.material) {
       case cc::DrawQuad::CHECKERBOARD:
-        LogParam(*cc::CheckerboardDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::CheckerboardDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::DEBUG_BORDER:
-        LogParam(*cc::DebugBorderDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::DebugBorderDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::IO_SURFACE_CONTENT:
-        LogParam(*cc::IOSurfaceDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::IOSurfaceDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::PICTURE_CONTENT:
         NOTREACHED();
         break;
       case cc::DrawQuad::TEXTURE_CONTENT:
-        LogParam(*cc::TextureDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::TextureDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::RENDER_PASS:
-        LogParam(*cc::RenderPassDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::RenderPassDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::SOLID_COLOR:
-        LogParam(*cc::SolidColorDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::SolidColorDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::SURFACE_CONTENT:
-        LogParam(*cc::SurfaceDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::SurfaceDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::TILED_CONTENT:
-        LogParam(*cc::TileDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::TileDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
-        LogParam(*cc::StreamVideoDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::StreamVideoDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::YUV_VIDEO_CONTENT:
-        LogParam(*cc::YUVVideoDrawQuad::MaterialCast(quad), l);
+        LogParam(*cc::YUVVideoDrawQuad::MaterialCast(&quad), l);
         break;
       case cc::DrawQuad::INVALID:
         break;
     }
   }
   l->append("])");
 }
 
 namespace {
   enum CompositorFrameType {
@@ skipping 124 matching lines @@
 }
 
 void ParamTraits<cc::DelegatedFrameData>::Write(Message* m,
                                                 const param_type& p) {
   DCHECK_NE(0u, p.render_pass_list.size());
 
   size_t to_reserve = sizeof(p.device_scale_factor);
   to_reserve += p.resource_list.size() * sizeof(cc::TransferableResource);
   for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
     const cc::RenderPass* pass = p.render_pass_list[i];
+    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());
-  for (size_t i = 0; i < p.render_pass_list.size(); ++i)
+  for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
+    WriteParam(m, p.render_pass_list[i]->quad_list.size());
+    WriteParam(m, p.render_pass_list[i]->shared_quad_state_list.size());
     WriteParam(m, *p.render_pass_list[i]);
+  }
 }
 
 bool ParamTraits<cc::DelegatedFrameData>::Read(const Message* m,
                                                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;
 
   size_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) {
-    scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+    size_t quad_list_size;
+    size_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);
     if (!ReadParam(m, iter, render_pass.get()))
       return false;
     p->render_pass_list.push_back(render_pass.Pass());
   }
   return true;
 }
 
 void ParamTraits<cc::DelegatedFrameData>::Log(const param_type& p,
                                               std::string* l) {
   l->append("DelegatedFrameData(");
@@ skipping 41 matching lines @@
   l->append(", ");
   LogParam(p.size, l);
   l->append(", ");
   LogParam(p.damage_rect, l);
   l->append(", ");
   LogParam(p.bitmap_id, l);
   l->append(")");
 }
 
 }  // namespace IPC