cc: Make the ScopedPtrVector and ScopedPtrDeque containers act like STL vector and deque.

content/common/cc_messages_unittest.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 <string.h>
 
 #include "cc/compositor_frame.h"
 #include "ipc/ipc_message.h"
@@ skipping 342 matching lines @@
       yuvvideo_in->shared_quad_state);
 
   scoped_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(arbitrary_id,
                   arbitrary_rect1,
                   arbitrary_rectf1,
                   arbitrary_matrix,
                   arbitrary_bool1,
                   arbitrary_bool2);
 
-  pass_in->shared_quad_state_list.append(shared_state1_in.Pass());
-  pass_in->quad_list.append(checkerboard_in.PassAs<DrawQuad>());
-  pass_in->quad_list.append(debugborder_in.PassAs<DrawQuad>());
-  pass_in->quad_list.append(iosurface_in.PassAs<DrawQuad>());
-  pass_in->quad_list.append(renderpass_in.PassAs<DrawQuad>());
-  pass_in->shared_quad_state_list.append(shared_state2_in.Pass());
-  pass_in->shared_quad_state_list.append(shared_state3_in.Pass());
-  pass_in->quad_list.append(solidcolor_in.PassAs<DrawQuad>());
-  pass_in->quad_list.append(streamvideo_in.PassAs<DrawQuad>());
-  pass_in->quad_list.append(yuvvideo_in.PassAs<DrawQuad>());
+  pass_in->shared_quad_state_list.push_back(shared_state1_in.Pass());
+  pass_in->quad_list.push_back(checkerboard_in.PassAs<DrawQuad>());
+  pass_in->quad_list.push_back(debugborder_in.PassAs<DrawQuad>());
+  pass_in->quad_list.push_back(iosurface_in.PassAs<DrawQuad>());
+  pass_in->quad_list.push_back(renderpass_in.PassAs<DrawQuad>());
+  pass_in->shared_quad_state_list.push_back(shared_state2_in.Pass());
+  pass_in->shared_quad_state_list.push_back(shared_state3_in.Pass());
+  pass_in->quad_list.push_back(solidcolor_in.PassAs<DrawQuad>());
+  pass_in->quad_list.push_back(streamvideo_in.PassAs<DrawQuad>());
+  pass_in->quad_list.push_back(yuvvideo_in.PassAs<DrawQuad>());
 
   scoped_ptr<RenderPass> pass_cmp = RenderPass::Create();
   pass_cmp->SetAll(arbitrary_id,
                    arbitrary_rect1,
                    arbitrary_rectf1,
                    arbitrary_matrix,
                    arbitrary_bool1,
                    arbitrary_bool2);
 
-  pass_cmp->shared_quad_state_list.append(shared_state1_cmp.Pass());
-  pass_cmp->quad_list.append(checkerboard_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.append(debugborder_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.append(iosurface_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.append(renderpass_cmp.PassAs<DrawQuad>());
-  pass_cmp->shared_quad_state_list.append(shared_state2_cmp.Pass());
-  pass_cmp->shared_quad_state_list.append(shared_state3_cmp.Pass());
-  pass_cmp->quad_list.append(solidcolor_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.append(streamvideo_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.append(yuvvideo_cmp.PassAs<DrawQuad>());
+  pass_cmp->shared_quad_state_list.push_back(shared_state1_cmp.Pass());
+  pass_cmp->quad_list.push_back(checkerboard_cmp.PassAs<DrawQuad>());
+  pass_cmp->quad_list.push_back(debugborder_cmp.PassAs<DrawQuad>());
+  pass_cmp->quad_list.push_back(iosurface_cmp.PassAs<DrawQuad>());
+  pass_cmp->quad_list.push_back(renderpass_cmp.PassAs<DrawQuad>());
+  pass_cmp->shared_quad_state_list.push_back(shared_state2_cmp.Pass());
+  pass_cmp->shared_quad_state_list.push_back(shared_state3_cmp.Pass());
+  pass_cmp->quad_list.push_back(solidcolor_cmp.PassAs<DrawQuad>());
+  pass_cmp->quad_list.push_back(streamvideo_cmp.PassAs<DrawQuad>());
+  pass_cmp->quad_list.push_back(yuvvideo_cmp.PassAs<DrawQuad>());
 
   // Make sure the in and cmp RenderPasses match.
   Compare(pass_cmp.get(), pass_in.get());
   ASSERT_EQ(3u, pass_in->shared_quad_state_list.size());
   ASSERT_EQ(7u, pass_in->quad_list.size());
   for (size_t i = 0; i < 3; ++i) {
     Compare(pass_cmp->shared_quad_state_list[i],
             pass_in->shared_quad_state_list[i]);
   }
   for (size_t i = 0; i < 7; ++i)
     Compare(pass_cmp->quad_list[i], pass_in->quad_list[i]);
   for (size_t i = 1; i < 7; ++i) {
     bool same_shared_quad_state_cmp =
         pass_cmp->quad_list[i]->shared_quad_state ==
         pass_cmp->quad_list[i - 1]->shared_quad_state;
     bool same_shared_quad_state_in =
         pass_in->quad_list[i]->shared_quad_state ==
         pass_in->quad_list[i - 1]->shared_quad_state;
     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_in);
   }
 
   DelegatedFrameData frame_in;
   frame_in.size = arbitrary_size1;
-  frame_in.render_pass_list.append(pass_in.Pass());
+  frame_in.render_pass_list.push_back(pass_in.Pass());
 
   IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 
   DelegatedFrameData frame_out;
   PickleIterator iter(msg);
   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
       &iter, &frame_out));
 
   EXPECT_EQ(arbitrary_size1, frame_out.size);
 
   // Make sure the out and cmp RenderPasses match.
-  scoped_ptr<RenderPass> pass_out = frame_out.render_pass_list.take(0);
+  scoped_ptr<RenderPass> pass_out = frame_out.render_pass_list.take(
+      frame_out.render_pass_list.begin());
   Compare(pass_cmp.get(), pass_out.get());
   ASSERT_EQ(3u, pass_out->shared_quad_state_list.size());
   ASSERT_EQ(7u, pass_out->quad_list.size());
   for (size_t i = 0; i < 3; ++i) {
     Compare(pass_cmp->shared_quad_state_list[i],
             pass_out->shared_quad_state_list[i]);
   }
   for (size_t i = 0; i < 7; ++i)
     Compare(pass_cmp->quad_list[i], pass_out->quad_list[i]);
   for (size_t i = 1; i < 7; ++i) {
@@ skipping 55 matching lines @@
   EXPECT_EQ(arbitrary_size.ToString(), frame_out.size.ToString());
   EXPECT_EQ(arbitrary_uint, frame_out.resource_list.sync_point);
 
   EXPECT_EQ(2u, frame_out.resource_list.resources.size());
   Compare(arbitrary_resource1, frame_out.resource_list.resources[0]);
   Compare(arbitrary_resource2, frame_out.resource_list.resources[1]);
 }
 
 }  // namespace
 }  // namespace content