convert //gpu to std::unique_ptr

gpu/command_buffer/service/program_manager.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/program_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
@@ skipping 284 matching lines @@
   return output + input.as_string();
 }
 
 void Program::UpdateLogInfo() {
   GLint max_len = 0;
   glGetProgramiv(service_id_, GL_INFO_LOG_LENGTH, &max_len);
   if (max_len == 0) {
     set_log_info(NULL);
     return;
   }
-  scoped_ptr<char[]> temp(new char[max_len]);
+  std::unique_ptr<char[]> temp(new char[max_len]);
   GLint len = 0;
   glGetProgramInfoLog(service_id_, max_len, &len, temp.get());
   DCHECK(max_len == 0 || len < max_len);
   DCHECK(len == 0 || temp[len] == '\0');
   std::string log(temp.get(), len);
   set_log_info(ProcessLogInfo(log).c_str());
 }
 
 void Program::ClearUniforms(std::vector<uint8_t>* zero_buffer) {
   DCHECK(zero_buffer);
@@ skipping 123 matching lines @@
   Reset();
   UpdateLogInfo();
   link_status_ = true;
   uniforms_cleared_ = false;
   GLint num_attribs = 0;
   GLint max_len = 0;
   GLint max_location = -1;
   glGetProgramiv(service_id_, GL_ACTIVE_ATTRIBUTES, &num_attribs);
   glGetProgramiv(service_id_, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_len);
   // TODO(gman): Should we check for error?
-  scoped_ptr<char[]> name_buffer(new char[max_len]);
+  std::unique_ptr<char[]> name_buffer(new char[max_len]);
   for (GLint ii = 0; ii < num_attribs; ++ii) {
     GLsizei length = 0;
     GLsizei size = 0;
     GLenum type = 0;
     glGetActiveAttrib(
         service_id_, ii, max_len, &length, &size, &type, name_buffer.get());
     DCHECK(max_len == 0 || length < max_len);
     DCHECK(length == 0 || name_buffer[length] == '\0');
     std::string original_name;
     GetVertexAttribData(name_buffer.get(), &original_name, &type);
@@ skipping 67 matching lines @@
   glGetProgramiv(service_id_, GL_ACTIVE_UNIFORMS, &num_uniforms);
   if (num_uniforms <= 0)
     return;
 
   uniform_infos_.resize(num_uniforms);
 
   GLint name_buffer_length = 0;
   glGetProgramiv(service_id_, GL_ACTIVE_UNIFORM_MAX_LENGTH,
                  &name_buffer_length);
   DCHECK(name_buffer_length > 0);
-  scoped_ptr<char[]> name_buffer(new char[name_buffer_length]);
+  std::unique_ptr<char[]> name_buffer(new char[name_buffer_length]);
 
   size_t unused_client_location_cursor = 0;
 
   for (GLint uniform_index = 0; uniform_index < num_uniforms; ++uniform_index) {
     GLsizei name_length = 0;
     GLsizei size = 0;
     GLenum type = GL_NONE;
     glGetActiveUniform(service_id_, uniform_index, name_buffer_length,
                        &name_length, &size, &type, name_buffer.get());
     DCHECK(name_length < name_buffer_length);
@@ skipping 153 matching lines @@
   glGetProgramInterfaceiv(service_id_, GL_FRAGMENT_INPUT_NV,
                           GL_ACTIVE_RESOURCES, &num_fragment_inputs);
   if (num_fragment_inputs <= 0)
     return;
 
   GLint max_len = 0;
   glGetProgramInterfaceiv(service_id_, GL_FRAGMENT_INPUT_NV, GL_MAX_NAME_LENGTH,
                           &max_len);
   DCHECK(max_len > 0);
 
-  scoped_ptr<char[]> name_buffer(new char[max_len]);
+  std::unique_ptr<char[]> name_buffer(new char[max_len]);
 
   Shader* fragment_shader =
       attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
 
   const GLenum kQueryProperties[] = {GL_LOCATION, GL_TYPE, GL_ARRAY_SIZE};
 
   std::vector<size_t> client_location_indices;
   for (GLint ii = 0; ii < num_fragment_inputs; ++ii) {
     GLsizei name_length = 0;
     glGetProgramResourceName(service_id_, GL_FRAGMENT_INPUT_NV, ii, max_len,
@@ skipping 1040 matching lines @@
     }
 
     ShVariableInfo var;
     var.type = static_cast<sh::GLenum>(key_value.second.type);
     var.size = std::max(1u, key_value.second.arraySize);
     combined_map[key_value.first] = var;
   }
 
   if (combined_map.size() == 0)
     return true;
-  scoped_ptr<ShVariableInfo[]> variables(
+  std::unique_ptr<ShVariableInfo[]> variables(
       new ShVariableInfo[combined_map.size()]);
   size_t index = 0;
   for (const auto& key_value : combined_map) {
     variables[index].type = key_value.second.type;
     variables[index].size = key_value.second.size;
     ++index;
   }
   return ShCheckVariablesWithinPackingLimits(
       static_cast<int>(manager_->max_varying_vectors()),
       variables.get(),
@@ skipping 566 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32_t ProgramManager::MakeFakeLocation(int32_t index, int32_t element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu