Convert //cc from scoped_ptr to std::unique_ptr.

cc/test/test_web_graphics_context_3d.cc

 // Copyright 2013 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/test/test_web_graphics_context_3d.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "cc/test/test_context_support.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 namespace cc {
 
 static unsigned s_context_id = 1;
@@ skipping 13 matching lines @@
       next_renderbuffer_id(1) {
 }
 
 TestWebGraphicsContext3D::Namespace::~Namespace() {
   g_shared_namespace_lock.Get().AssertAcquired();
   if (shared_namespace_ == this)
     shared_namespace_ = NULL;
 }
 
 // static
-scoped_ptr<TestWebGraphicsContext3D> TestWebGraphicsContext3D::Create() {
-  return make_scoped_ptr(new TestWebGraphicsContext3D());
+std::unique_ptr<TestWebGraphicsContext3D> TestWebGraphicsContext3D::Create() {
+  return base::WrapUnique(new TestWebGraphicsContext3D());
 }
 
 TestWebGraphicsContext3D::TestWebGraphicsContext3D()
     : context_id_(s_context_id++),
       times_bind_texture_succeeds_(-1),
       times_end_query_succeeds_(-1),
       context_lost_(false),
       times_map_buffer_chromium_succeeds_(-1),
       current_used_transfer_buffer_usage_bytes_(0),
       max_used_transfer_buffer_usage_bytes_(0),
@@ skipping 458 matching lines @@
   bound_buffer_ = buffer;
   if (!bound_buffer_)
     return;
   unsigned context_id = buffer >> 16;
   unsigned buffer_id = buffer & 0xffff;
   base::AutoLock lock(namespace_->lock);
   DCHECK(buffer_id);
   DCHECK_LT(buffer_id, namespace_->next_buffer_id);
   DCHECK_EQ(context_id, context_id_);
 
-  std::unordered_map<unsigned, scoped_ptr<Buffer>>& buffers =
+  std::unordered_map<unsigned, std::unique_ptr<Buffer>>& buffers =
       namespace_->buffers;
   if (buffers.count(bound_buffer_) == 0)
-    buffers[bound_buffer_] = make_scoped_ptr(new Buffer);
+    buffers[bound_buffer_] = base::WrapUnique(new Buffer);
 
   buffers[bound_buffer_]->target = target;
 }
 
 void TestWebGraphicsContext3D::bufferData(GLenum target,
                                           GLsizeiptr size,
                                           const void* data,
                                           GLenum usage) {
   base::AutoLock lock(namespace_->lock);
-  std::unordered_map<unsigned, scoped_ptr<Buffer>>& buffers =
+  std::unordered_map<unsigned, std::unique_ptr<Buffer>>& buffers =
       namespace_->buffers;
   DCHECK_GT(buffers.count(bound_buffer_), 0u);
   DCHECK_EQ(target, buffers[bound_buffer_]->target);
   Buffer* buffer = buffers[bound_buffer_].get();
   if (context_lost_) {
     buffer->pixels = nullptr;
     return;
   }
 
   size_t old_size = buffer->size;
@@ skipping 29 matching lines @@
       }
       break;
     default:
       break;
   }
 }
 
 void* TestWebGraphicsContext3D::mapBufferCHROMIUM(GLenum target,
                                                   GLenum access) {
   base::AutoLock lock(namespace_->lock);
-  std::unordered_map<unsigned, scoped_ptr<Buffer>>& buffers =
+  std::unordered_map<unsigned, std::unique_ptr<Buffer>>& buffers =
       namespace_->buffers;
   DCHECK_GT(buffers.count(bound_buffer_), 0u);
   DCHECK_EQ(target, buffers[bound_buffer_]->target);
   if (times_map_buffer_chromium_succeeds_ >= 0) {
     if (!times_map_buffer_chromium_succeeds_) {
       return NULL;
     }
     --times_map_buffer_chromium_succeeds_;
   }
 
   return buffers[bound_buffer_]->pixels.get();
 }
 
 GLboolean TestWebGraphicsContext3D::unmapBufferCHROMIUM(
     GLenum target) {
   base::AutoLock lock(namespace_->lock);
-  std::unordered_map<unsigned, scoped_ptr<Buffer>>& buffers =
+  std::unordered_map<unsigned, std::unique_ptr<Buffer>>& buffers =
       namespace_->buffers;
   DCHECK_GT(buffers.count(bound_buffer_), 0u);
   DCHECK_EQ(target, buffers[bound_buffer_]->target);
   buffers[bound_buffer_]->pixels = nullptr;
   return true;
 }
 
 GLuint TestWebGraphicsContext3D::createImageCHROMIUM(ClientBuffer buffer,
                                                      GLsizei width,
                                                      GLsizei height,
@@ skipping 220 matching lines @@
 
 TestWebGraphicsContext3D::Buffer::Buffer() : target(0), size(0) {}
 
 TestWebGraphicsContext3D::Buffer::~Buffer() {}
 
 TestWebGraphicsContext3D::Image::Image() {}
 
 TestWebGraphicsContext3D::Image::~Image() {}
 
 }  // namespace cc