cc: Remove ScopedPtrDeque.

cc/resources/resource_provider_unittest.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
+#include <deque>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "cc/base/scoped_ptr_deque.h"
 #include "cc/output/output_surface.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_texture.h"
 #include "cc/test/test_web_graphics_context_3d.h"
@@ skipping 148 matching lines @@
  public:
   static scoped_ptr<ResourceProviderContext> Create(
       ContextSharedData* shared_data) {
     return make_scoped_ptr(new ResourceProviderContext(shared_data));
   }
 
   GLuint insertSyncPoint() override {
     uint32 sync_point = shared_data_->InsertSyncPoint();
     // Commit the produceTextureCHROMIUM calls at this point, so that
     // they're associated with the sync point.
-    for (PendingProduceTextureList::iterator it =
-             pending_produce_textures_.begin();
-         it != pending_produce_textures_.end();
-         ++it) {
-      shared_data_->ProduceTexture((*it)->mailbox, gpu::SyncToken(sync_point),
-                                   (*it)->texture);
+    for (const scoped_ptr<PendingProduceTexture>& pending_texture :
+         pending_produce_textures_) {
+      shared_data_->ProduceTexture(pending_texture->mailbox,
+                                   gpu::SyncToken(sync_point),
+                                   pending_texture->texture);
     }
     pending_produce_textures_.clear();
     return sync_point;
   }
 
   void waitSyncToken(const GLbyte* sync_token) override {
     gpu::SyncToken sync_token_data;
     if (sync_token)
       memcpy(&sync_token_data, sync_token, sizeof(sync_token_data));
 
@@ skipping 149 matching lines @@
       memcpy(dest, src, in_pitch);
       dest += out_pitch;
       src += in_pitch;
     }
   }
 
   struct PendingProduceTexture {
     GLbyte mailbox[GL_MAILBOX_SIZE_CHROMIUM];
     scoped_refptr<TestTexture> texture;
   };
-  typedef ScopedPtrDeque<PendingProduceTexture> PendingProduceTextureList;
   ContextSharedData* shared_data_;
   gpu::SyncToken last_waited_sync_token_;
-  PendingProduceTextureList pending_produce_textures_;
+  std::deque<scoped_ptr<PendingProduceTexture>> pending_produce_textures_;
 };
 
 void GetResourcePixels(ResourceProvider* resource_provider,
                        ResourceProviderContext* context,
                        ResourceId id,
                        const gfx::Size& size,
                        ResourceFormat format,
                        uint8_t* pixels) {
   resource_provider->WaitSyncTokenIfNeeded(id);
   switch (resource_provider->default_resource_type()) {
@@ skipping 3181 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc