convert //gpu to std::unique_ptr

gpu/command_buffer/tests/gl_chromium_framebuffer_mixed_samples_unittest.cc

 // Copyright (c) 2015 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 <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stdint.h>
 #include <string.h>

[no sievers, 2016/04/05 19:02:41]

#include <memory>

[Mostyn Bramley-Moore, 2016/04/05 21:35:32]

Done.

 
 #include "base/command_line.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define SHADER(Src) #Src
 
@@ skipping 146 matching lines @@
 // The test tests that CoverageModulation call works.
 // The fractional pixels of both triangles end up being modulated
 // by the coverage of the fragment. Test that drawing with and without
 // CoverageModulation causes the result to be different.
 TEST_F(CHROMIUMFramebufferMixedSamplesTest, CoverageModulation) {
   if (!IsApplicable()) {
     return;
   }
   static const float kBlue[] = {0.0f, 0.0f, 1.0f, 1.0f};
   static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};
-  scoped_ptr<uint8_t[]> results[3];
+  std::unique_ptr<uint8_t[]> results[3];
   const GLint kResultSize = kWidth * kHeight * 4;
 
   for (int pass = 0; pass < 3; ++pass) {
     SetupState(MixedSampleFBO);
     if (pass == 1) {
       glCoverageModulationCHROMIUM(GL_RGBA);
     }
     glUniform4fv(color_loc_, 1, kGreen);
     glDrawArrays(GL_TRIANGLES, 0, 3);
 
@@ skipping 19 matching lines @@
 // color buffer is single-sampled. Draws the same pattern with single-sample
 // stencil buffer and with multisample stencil buffer. The images should differ.
 TEST_F(CHROMIUMFramebufferMixedSamplesTest, MultisampleStencilEffective) {
   if (!IsApplicable()) {
     return;
   }
 
   static const float kBlue[] = {0.0f, 0.0f, 1.0f, 1.0f};
   static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};
 
-  scoped_ptr<uint8_t[]> results[3];
+  std::unique_ptr<uint8_t[]> results[3];
   const GLint kResultSize = kWidth * kHeight * 4;
 
   for (int pass = 0; pass < 3; ++pass) {
     if (pass == 1) {
       SetupState(MixedSampleFBO);
     } else {
       SetupState(SingleSampleFBO);
     }
     glUniform4fv(color_loc_, 1, kGreen);
     glDrawArrays(GL_TRIANGLES, 0, 3);
 
     glUniform4fv(color_loc_, 1, kBlue);
     glDrawArrays(GL_TRIANGLES, 3, 3);
 
     results[pass].reset(new uint8_t[kResultSize]);
     memset(results[pass].get(), GLTestHelper::kCheckClearValue, kResultSize);
     glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
                  results[pass].get());
   }
 
   EXPECT_NE(0, memcmp(results[0].get(), results[1].get(), kResultSize));
   // Verify that rendering is deterministic, so that the pass above does not
   // come from non-deterministic rendering.
   EXPECT_EQ(0, memcmp(results[0].get(), results[2].get(), kResultSize));
 }
 
 }  // namespace gpu