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;
+  cc::SharedQuadStateList::ConstIterator shared_quad_state_index =

[danakj, 2014/09/26 20:40:55]

this isn't an index, it's an iterator, so let's name it as such

[weiliangc, 2014/10/01 23:02:00]

Done.

+      p.shared_quad_state_list.begin();
+  cc::SharedQuadStateList::ConstIterator last_shared_quad_state_index =

[danakj, 2014/09/26 20:40:55]

same

[weiliangc, 2014/10/01 23:02:00]

Done.

+      p.shared_quad_state_list.end();
   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()
@@ skipping 30 matching lines @@
       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
         WriteParam(m, *cc::StreamVideoDrawQuad::MaterialCast(quad));
         break;
       case cc::DrawQuad::YUV_VIDEO_CONTENT:
         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;
-    }
 
     // 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])
+    while (shared_quad_state_index != p.shared_quad_state_list.end() &&
+           quad->shared_quad_state != &(*shared_quad_state_index))

[danakj, 2014/09/26 20:40:55]

&*?

[weiliangc, 2014/10/01 23:02:00]

Done.

       ++shared_quad_state_index;
 
-    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_index != 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]);
+      WriteParam(m, true);
+      WriteParam(m, *shared_quad_state_index);
       last_shared_quad_state_index = shared_quad_state_index;
+    } else {
+      WriteParam(m, false);
     }
   }
 }
 
 static size_t ReserveSizeForRenderPassWrite(const cc::RenderPass& p) {
   size_t to_reserve = sizeof(cc::RenderPass);
 
   to_reserve += p.shared_quad_state_list.size() * sizeof(cc::SharedQuadState);
 
   // The shared_quad_state_index for each quad.

[danakj, 2014/09/26 20:40:55]

update this

[weiliangc, 2014/10/01 23:02:50]

I think the logic is correct, but I add more comments hopefully more clear.

-  to_reserve += p.quad_list.size() * sizeof(size_t);
+  to_reserve += p.quad_list.size() * sizeof(bool);
 
   // 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 (cc::SharedQuadStateList::ConstIterator iter =

[danakj, 2014/09/26 20:40:55]

Can you use auto and c++11 for loops in this CL? They are allowed now and would
make things like this much easier to read

+           p.shared_quad_state_list.begin();
+       iter != p.shared_quad_state_list.end();
+       ++iter) {
+    if (iter != p.shared_quad_state_list.begin())
       l->append(", ");
-    LogParam(*p.shared_quad_state_list[i], l);
+    LogParam(*(&(*iter)), l);

[danakj, 2014/09/26 20:40:55]

wat. you mean *iter?

[weiliangc, 2014/10/01 23:02:00]

Done.

   }
   l->append("], [");
   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 = &*iter;
     switch (quad->material) {
       case cc::DrawQuad::CHECKERBOARD:
@@ skipping 165 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);

[danakj, 2014/09/26 20:40:55]

*2?

[weiliangc, 2014/10/01 23:02:00]

Done.

     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;
 
   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) ||

[danakj, 2014/09/26 20:40:55]

can you range check these things? like kMaxRenderPasses, but larger. Maybe
100000?

[weiliangc, 2014/10/01 23:02:00]

Done.

+        !ReadParam(m, iter, &shared_quad_state_list_size))
+      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