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

cc/test/layer_tree_pixel_test.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/layer_tree_pixel_test.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "cc/base/switches.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/test/paths.h"
 #include "cc/test/pixel_comparator.h"
@@ skipping 10 matching lines @@
 namespace cc {
 
 LayerTreePixelTest::LayerTreePixelTest()
     : pixel_comparator_(new ExactPixelComparator(true)),
       test_type_(PIXEL_TEST_GL),
       pending_texture_mailbox_callbacks_(0) {
 }
 
 LayerTreePixelTest::~LayerTreePixelTest() {}
 
-scoped_ptr<OutputSurface> LayerTreePixelTest::CreateOutputSurface() {
+std::unique_ptr<OutputSurface> LayerTreePixelTest::CreateOutputSurface() {
   gfx::Size surface_expansion_size(40, 60);
-  scoped_ptr<PixelTestOutputSurface> output_surface;
+  std::unique_ptr<PixelTestOutputSurface> output_surface;
 
   switch (test_type_) {
     case PIXEL_TEST_SOFTWARE: {
-      scoped_ptr<PixelTestSoftwareOutputDevice> software_output_device(
+      std::unique_ptr<PixelTestSoftwareOutputDevice> software_output_device(
           new PixelTestSoftwareOutputDevice);
       software_output_device->set_surface_expansion_size(
           surface_expansion_size);
-      output_surface = make_scoped_ptr(
+      output_surface = base::WrapUnique(
           new PixelTestOutputSurface(std::move(software_output_device)));
       break;
     }
     case PIXEL_TEST_GL: {
       bool flipped_output_surface = false;
       scoped_refptr<TestInProcessContextProvider> compositor(
           new TestInProcessContextProvider(nullptr));
       scoped_refptr<TestInProcessContextProvider> worker(
           new TestInProcessContextProvider(compositor.get()));
-      output_surface = make_scoped_ptr(new PixelTestOutputSurface(
+      output_surface = base::WrapUnique(new PixelTestOutputSurface(
           std::move(compositor), std::move(worker), flipped_output_surface));
       break;
     }
   }
 
   output_surface->set_surface_expansion_size(surface_expansion_size);
   return std::move(output_surface);
 }
 
 void LayerTreePixelTest::WillCommitCompleteOnThread(LayerTreeHostImpl* impl) {
   if (impl->sync_tree()->source_frame_number() != 0)
     return;
 
   DirectRenderer* renderer = static_cast<DirectRenderer*>(impl->renderer());
   renderer->SetEnlargePassTextureAmountForTesting(enlarge_texture_amount_);
 }
 
-scoped_ptr<CopyOutputRequest> LayerTreePixelTest::CreateCopyOutputRequest() {
+std::unique_ptr<CopyOutputRequest>
+LayerTreePixelTest::CreateCopyOutputRequest() {
   return CopyOutputRequest::CreateBitmapRequest(
       base::Bind(&LayerTreePixelTest::ReadbackResult, base::Unretained(this)));
 }
 
-void LayerTreePixelTest::ReadbackResult(scoped_ptr<CopyOutputResult> result) {
+void LayerTreePixelTest::ReadbackResult(
+    std::unique_ptr<CopyOutputResult> result) {
   ASSERT_TRUE(result->HasBitmap());
   result_bitmap_ = result->TakeBitmap();
   EndTest();
 }
 
 void LayerTreePixelTest::BeginTest() {
   Layer* target = readback_target_ ? readback_target_
                                    : layer_tree_host()->root_layer();
   target->RequestCopyOfOutput(CreateCopyOutputRequest());
   PostSetNeedsCommitToMainThread();
@@ skipping 104 matching lines @@
 }
 
 void LayerTreePixelTest::SetupTree() {
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(content_root_->bounds());
   root->AddChild(content_root_);
   layer_tree_host()->SetRootLayer(root);
   LayerTreeTest::SetupTree();
 }
 
-scoped_ptr<SkBitmap> LayerTreePixelTest::CopyTextureMailboxToBitmap(
+std::unique_ptr<SkBitmap> LayerTreePixelTest::CopyTextureMailboxToBitmap(
     const gfx::Size& size,
     const TextureMailbox& texture_mailbox) {
   DCHECK(texture_mailbox.IsTexture());
   if (!texture_mailbox.IsTexture())
     return nullptr;
 
-  scoped_ptr<gpu::GLInProcessContext> context = CreateTestInProcessContext();
+  std::unique_ptr<gpu::GLInProcessContext> context =
+      CreateTestInProcessContext();
   GLES2Interface* gl = context->GetImplementation();
 
   if (texture_mailbox.sync_token().HasData())
     gl->WaitSyncTokenCHROMIUM(texture_mailbox.sync_token().GetConstData());
 
   GLuint texture_id = 0;
   gl->GenTextures(1, &texture_id);
   gl->BindTexture(GL_TEXTURE_2D, texture_id);
   gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   gl->ConsumeTextureCHROMIUM(texture_mailbox.target(), texture_mailbox.name());
   gl->BindTexture(GL_TEXTURE_2D, 0);
 
   GLuint fbo = 0;
   gl->GenFramebuffers(1, &fbo);
   gl->BindFramebuffer(GL_FRAMEBUFFER, fbo);
   gl->FramebufferTexture2D(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0);
   EXPECT_EQ(static_cast<unsigned>(GL_FRAMEBUFFER_COMPLETE),
             gl->CheckFramebufferStatus(GL_FRAMEBUFFER));
 
-  scoped_ptr<uint8_t[]> pixels(new uint8_t[size.GetArea() * 4]);
+  std::unique_ptr<uint8_t[]> pixels(new uint8_t[size.GetArea() * 4]);
   gl->ReadPixels(0,
                  0,
                  size.width(),
                  size.height(),
                  GL_RGBA,
                  GL_UNSIGNED_BYTE,
                  pixels.get());
 
   gl->DeleteFramebuffers(1, &fbo);
   gl->DeleteTextures(1, &texture_id);
 
-  scoped_ptr<SkBitmap> bitmap(new SkBitmap);
+  std::unique_ptr<SkBitmap> bitmap(new SkBitmap);
   bitmap->allocN32Pixels(size.width(), size.height());
 
   uint8_t* out_pixels = static_cast<uint8_t*>(bitmap->getPixels());
 
   size_t row_bytes = size.width() * 4;
   size_t total_bytes = size.height() * row_bytes;
   for (size_t dest_y = 0; dest_y < total_bytes; dest_y += row_bytes) {
     // Flip Y axis.
     size_t src_y = total_bytes - dest_y - row_bytes;
     // Swizzle OpenGL -> Skia byte order.
     for (size_t x = 0; x < row_bytes; x += 4) {
       out_pixels[dest_y + x + SK_R32_SHIFT/8] = pixels.get()[src_y + x + 0];
       out_pixels[dest_y + x + SK_G32_SHIFT/8] = pixels.get()[src_y + x + 1];
       out_pixels[dest_y + x + SK_B32_SHIFT/8] = pixels.get()[src_y + x + 2];
       out_pixels[dest_y + x + SK_A32_SHIFT/8] = pixels.get()[src_y + x + 3];
     }
   }
 
   return bitmap;
 }
 
 void LayerTreePixelTest::Finish() {
-  scoped_ptr<gpu::GLInProcessContext> context = CreateTestInProcessContext();
+  std::unique_ptr<gpu::GLInProcessContext> context =
+      CreateTestInProcessContext();
   GLES2Interface* gl = context->GetImplementation();
   gl->Finish();
 }
 
 }  // namespace cc