Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/compositor/gl_helper_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #include <cmath>
 #include <string>
@@ skipping 106 matching lines @@
     std::string json_data = "[";
     base::trace_event::TraceLog::GetInstance()->SetDisabled();
     base::RunLoop run_loop;
     base::trace_event::TraceLog::GetInstance()->Flush(
         base::Bind(&GLHelperTest::TraceDataCB, run_loop.QuitClosure(),
                    base::Unretained(&json_data)));
     run_loop.Run();
     json_data.append("]");
 
     std::string error_msg;
-    scoped_ptr<base::Value> trace_data =
+    std::unique_ptr<base::Value> trace_data =
         base::JSONReader::ReadAndReturnError(json_data, 0, NULL, &error_msg);
     CHECK(trace_data) << "JSON parsing failed (" << error_msg
                       << ") JSON data:" << std::endl
                       << json_data;
 
     base::ListValue* list;
     CHECK(trace_data->GetAsList(&list));
     for (size_t i = 0; i < list->GetSize(); i++) {
       base::Value* item = NULL;
       if (list->Get(i, &item)) {
@@ skipping 529 matching lines @@
     }
 
     SkBitmap tmp;
     tmp.allocN32Pixels(xtmp, ytmp);
 
     ScaleSlowRecursive(input, &tmp, quality);
     ScaleSlowRecursive(&tmp, output, quality);
   }
 
   // Creates an RGBA SkBitmap
-  scoped_ptr<SkBitmap> CreateTestBitmap(int width,
-                                        int height,
-                                        int test_pattern) {
-    scoped_ptr<SkBitmap> bitmap(new SkBitmap);
+  std::unique_ptr<SkBitmap> CreateTestBitmap(int width,
+                                             int height,
+                                             int test_pattern) {
+    std::unique_ptr<SkBitmap> bitmap(new SkBitmap);
     bitmap->allocPixels(SkImageInfo::Make(width, height, kRGBA_8888_SkColorType,
                                           kPremul_SkAlphaType));
 
     for (int x = 0; x < width; ++x) {
       for (int y = 0; y < height; ++y) {
         switch (test_pattern) {
           case 0:  // Smooth test pattern
             SetChannel(bitmap.get(), x, y, 0, x * 10);
             SetChannel(bitmap.get(), x, y, 0, y == 0 ? x * 50 : x * 10);
             SetChannel(bitmap.get(), x, y, 1, y * 10);
@@ skipping 41 matching lines @@
                                             SkColorType out_color_type,
                                             bool swizzle,
                                             size_t quality_index) {
     DCHECK(out_color_type == kAlpha_8_SkColorType ||
            out_color_type == kRGBA_8888_SkColorType ||
            out_color_type == kBGRA_8888_SkColorType);
     GLuint src_texture;
     gl_->GenTextures(1, &src_texture);
     GLuint framebuffer;
     gl_->GenFramebuffers(1, &framebuffer);
-    scoped_ptr<SkBitmap> input_pixels =
+    std::unique_ptr<SkBitmap> input_pixels =
         CreateTestBitmap(xsize, ysize, test_pattern);
     BindTextureAndFrameBuffer(src_texture, framebuffer, input_pixels.get(),
                               xsize, ysize);
 
     std::string message = base::StringPrintf(
         "input size: %dx%d "
         "output size: %dx%d "
         "pattern: %d , quality: %s, "
         "out_color_type: %d",
         xsize, ysize, scaled_xsize, scaled_ysize, test_pattern,
@@ skipping 58 matching lines @@
                  int ysize,
                  int scaled_xsize,
                  int scaled_ysize,
                  int test_pattern,
                  size_t quality_index,
                  bool flip) {
     GLuint src_texture;
     gl_->GenTextures(1, &src_texture);
     GLuint framebuffer;
     gl_->GenFramebuffers(1, &framebuffer);
-    scoped_ptr<SkBitmap> input_pixels =
+    std::unique_ptr<SkBitmap> input_pixels =
         CreateTestBitmap(xsize, ysize, test_pattern);
     BindTextureAndFrameBuffer(src_texture, framebuffer, input_pixels.get(),
                               xsize, ysize);
 
     std::string message = base::StringPrintf(
         "input size: %dx%d "
         "output size: %dx%d "
         "pattern: %d quality: %s",
         xsize, ysize, scaled_xsize, scaled_ysize, test_pattern,
         kQualityNames[quality_index]);
@@ skipping 467 matching lines @@
     gpu::SyncToken sync_token;
     gl_->GenSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
 
     std::string message = base::StringPrintf(
         "input size: %dx%d "
         "output size: %dx%d "
         "margin: %dx%d "
         "pattern: %d %s %s",
         xsize, ysize, output_xsize, output_ysize, xmargin, ymargin,
         test_pattern, flip ? "flip" : "noflip", flip ? "mrt" : "nomrt");
-    scoped_ptr<ReadbackYUVInterface> yuv_reader(
+    std::unique_ptr<ReadbackYUVInterface> yuv_reader(
         helper_->CreateReadbackPipelineYUV(
             quality, gfx::Size(xsize, ysize), gfx::Rect(0, 0, xsize, ysize),
             gfx::Size(xsize, ysize), flip, use_mrt));
 
     scoped_refptr<media::VideoFrame> output_frame =
         media::VideoFrame::CreateFrame(
             media::PIXEL_FORMAT_YV12,
             // The coded size of the output frame is rounded up to the next
             // 16-byte boundary.  This tests that the readback is being
             // positioned inside the frame's visible region, and not dependent
@@ skipping 246 matching lines @@
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 2));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 1));
     CheckPipeline2(100, 100, 1, 1,
                    "100x100 -> 100x32 bilinear4 Y\n"
                    "100x32 -> 100x4 bilinear4 Y\n"
                    "100x4 -> 64x1 bilinear2x2\n"
                    "64x1 -> 8x1 bilinear4 X\n"
                    "8x1 -> 1x1 bilinear4 X\n");
   }
 
-  scoped_ptr<gpu::GLInProcessContext> context_;
+  std::unique_ptr<gpu::GLInProcessContext> context_;
   gpu::gles2::GLES2Interface* gl_;
-  scoped_ptr<content::GLHelper> helper_;
-  scoped_ptr<content::GLHelperScaling> helper_scaling_;
+  std::unique_ptr<content::GLHelper> helper_;
+  std::unique_ptr<content::GLHelperScaling> helper_scaling_;
   std::deque<GLHelperScaling::ScaleOp> x_ops_, y_ops_;
 };
 
 class GLHelperPixelTest : public GLHelperTest {
  private:
   gfx::DisableNullDrawGLBindings enable_pixel_output_;
 };
 
 TEST_F(GLHelperTest, RGBASyncReadbackTest) {
   const int kTestSize = 64;
@@ skipping 229 matching lines @@
     }
   }
 }
 
 TEST_F(GLHelperTest, CheckOptimizations) {
   // Test in baseclass since it is friends with GLHelperScaling
   CheckOptimizationsTest();
 }
 
 }  // namespace content