convert //gpu to std::unique_ptr

gpu/command_buffer/service/memory_program_cache_unittest.cc

 // Copyright (c) 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 "gpu/command_buffer/service/memory_program_cache.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/bind.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_mock.h"
@@ skipping 155 matching lines @@
                 ProgramBinary(program_id,
                               emulator->format(),
                               _,
                               emulator->length()))
         .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::ProgramBinary));
     EXPECT_CALL(*gl_.get(),
                 GetProgramiv(program_id, GL_LINK_STATUS, _))
                 .WillOnce(SetArgPointee<2>(GL_FALSE));
   }
 
-  scoped_ptr<MemoryProgramCache> cache_;
+  std::unique_ptr<MemoryProgramCache> cache_;
   ShaderManager shader_manager_;
   Shader* vertex_shader_;
   Shader* fragment_shader_;
   int32_t shader_cache_count_;
   std::string shader_cache_shader_;
   std::vector<std::string> varyings_;
 };
 
 TEST_F(MemoryProgramCacheTest, CacheSave) {
   const GLenum kFormat = 1;
@@ skipping 357 matching lines @@
                                        base::Unretained(this)));
 
   const int kEvictingProgramId = 11;
   const GLuint kEvictingBinaryLength = kCacheSizeBytes - kBinaryLength + 1;
 
   // save old source and modify for new program
   const std::string& old_sig = fragment_shader_->last_compiled_signature();
   fragment_shader_->set_source("al sdfkjdk");
   TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
 
-  scoped_ptr<char[]> bigTestBinary =
-      scoped_ptr<char[]>(new char[kEvictingBinaryLength]);
+  std::unique_ptr<char[]> bigTestBinary =
+      std::unique_ptr<char[]>(new char[kEvictingBinaryLength]);
   for (size_t i = 0; i < kEvictingBinaryLength; ++i) {
     bigTestBinary[i] = i % 250;
   }
   ProgramBinaryEmulator emulator2(kEvictingBinaryLength,
                                   kFormat,
                                   bigTestBinary.get());
 
   SetExpectationsForSaveLinkedProgram(kEvictingProgramId, &emulator2);
   cache_->SaveLinkedProgram(kEvictingProgramId,
                             vertex_shader_,
@@ skipping 107 matching lines @@
       fragment_shader_,
       NULL,
       varyings_,
       GL_NONE,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 }
 
 }  // namespace gles2
 }  // namespace gpu