Use custom ListContainer to allocate DrawQuads

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 281 matching lines @@
   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 (size_t i = 0; i < p.quad_list.size(); ++i) {
-    const cc::DrawQuad* quad = p.quad_list[i];
+  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();
 
     switch (quad->material) {
       case cc::DrawQuad::CHECKERBOARD:
@@ skipping 72 matching lines @@
   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 scoped_ptr<cc::DrawQuad> ReadDrawQuad(const Message* m,
-                                             PickleIterator* iter) {
-  scoped_ptr<QuadType> quad(new QuadType);
-  if (!ReadParam(m, iter, quad.get()))
-    return scoped_ptr<QuadType>().template PassAs<cc::DrawQuad>();
-  return quad.template PassAs<cc::DrawQuad>();
+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;
@@ skipping 14 matching lines @@
             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;
 
-    scoped_ptr<cc::DrawQuad> draw_quad;
+    cc::DrawQuad* draw_quad = NULL;
     switch (material) {
       case cc::DrawQuad::CHECKERBOARD:
-        draw_quad = ReadDrawQuad<cc::CheckerboardDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::CheckerboardDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::DEBUG_BORDER:
-        draw_quad = ReadDrawQuad<cc::DebugBorderDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::DebugBorderDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::IO_SURFACE_CONTENT:
-        draw_quad = ReadDrawQuad<cc::IOSurfaceDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::IOSurfaceDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::PICTURE_CONTENT:
         NOTREACHED();
         return false;
       case cc::DrawQuad::SURFACE_CONTENT:
-        draw_quad = ReadDrawQuad<cc::SurfaceDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::SurfaceDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::TEXTURE_CONTENT:
-        draw_quad = ReadDrawQuad<cc::TextureDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::TextureDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::RENDER_PASS:
-        draw_quad = ReadDrawQuad<cc::RenderPassDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::RenderPassDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::SOLID_COLOR:
-        draw_quad = ReadDrawQuad<cc::SolidColorDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::SolidColorDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::TILED_CONTENT:
-        draw_quad = ReadDrawQuad<cc::TileDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::TileDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
-        draw_quad = ReadDrawQuad<cc::StreamVideoDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::StreamVideoDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::YUV_VIDEO_CONTENT:
-        draw_quad = ReadDrawQuad<cc::YUVVideoDrawQuad>(m, iter);
+        draw_quad = ReadDrawQuad<cc::YUVVideoDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::INVALID:
         break;
     }
     if (!draw_quad)
       return false;
     if (!draw_quad->rect.Contains(draw_quad->visible_rect)) {
       LOG(ERROR) << "Quad with invalid visible rect " << draw_quad->material
                  << " rect: " << draw_quad->rect.ToString()
                  << " visible_rect: " << draw_quad->visible_rect.ToString();
@@ skipping 19 matching lines @@
 
     // If the quad has a new shared quad state, read it in.
     if (last_shared_quad_state_index != shared_quad_state_index) {
       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();
-    p->quad_list.push_back(draw_quad.Pass());
   }
 
   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)
       l->append(", ");
     LogParam(*p.shared_quad_state_list[i], l);
   }
   l->append("], [");
-  for (size_t i = 0; i < p.quad_list.size(); ++i) {
-    if (i)
+  for (cc::QuadList::ConstIterator iter = p.quad_list.begin();
+       iter != p.quad_list.end();
+       ++iter) {
+    if (iter != p.quad_list.begin())
       l->append(", ");
-    const cc::DrawQuad* quad = p.quad_list[i];
+    const cc::DrawQuad* quad = &*iter;
     switch (quad->material) {
       case cc::DrawQuad::CHECKERBOARD:
         LogParam(*cc::CheckerboardDrawQuad::MaterialCast(quad), l);
         break;
       case cc::DrawQuad::DEBUG_BORDER:
         LogParam(*cc::DebugBorderDrawQuad::MaterialCast(quad), l);
         break;
       case cc::DrawQuad::IO_SURFACE_CONTENT:
         LogParam(*cc::IOSurfaceDrawQuad::MaterialCast(quad), l);
         break;
@@ skipping 244 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