convert //gpu to std::unique_ptr

gpu/command_buffer/service/gpu_state_tracer.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 "gpu/command_buffer/service/gpu_state_tracer.h"
 
 #include "base/base64.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "context_state.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 namespace gles2 {
 namespace {
 
 const int kBytesPerPixel = 4;
 
 class Snapshot : public base::trace_event::ConvertableToTraceFormat {
  public:
-  static scoped_ptr<Snapshot> Create(const ContextState* state);
+  static std::unique_ptr<Snapshot> Create(const ContextState* state);
 
   ~Snapshot() override {}
 
   // Save a screenshot of the currently bound framebuffer.
   bool SaveScreenshot(const gfx::Size& size);
 
   // base::trace_event::ConvertableToTraceFormat implementation.
   void AppendAsTraceFormat(std::string* out) const override;
 
  private:
   explicit Snapshot(const ContextState* state);
 
   const ContextState* state_;
 
   std::vector<unsigned char> screenshot_pixels_;
   gfx::Size screenshot_size_;
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
 }  // namespace
 
 Snapshot::Snapshot(const ContextState* state) : state_(state) {}
 
-scoped_ptr<Snapshot> Snapshot::Create(const ContextState* state) {
-  return make_scoped_ptr(new Snapshot(state));
+std::unique_ptr<Snapshot> Snapshot::Create(const ContextState* state) {
+  return base::WrapUnique(new Snapshot(state));
 }
 
 bool Snapshot::SaveScreenshot(const gfx::Size& size) {
   screenshot_size_ = size;
   screenshot_pixels_.resize(screenshot_size_.width() *
                             screenshot_size_.height() * kBytesPerPixel);
 
   glPixelStorei(GL_PACK_ALIGNMENT, kBytesPerPixel);
   glReadPixels(0,
                0,
@@ skipping 33 matching lines @@
     base::StringPiece base64_input(reinterpret_cast<const char*>(&png_data[0]),
                                    png_data.size());
     std::string base64_output;
     Base64Encode(base64_input, &base64_output);
 
     *out += "\"screenshot\":\"" + base64_output + "\"";
   }
   *out += "}";
 }
 
-scoped_ptr<GPUStateTracer> GPUStateTracer::Create(const ContextState* state) {
-  return scoped_ptr<GPUStateTracer>(new GPUStateTracer(state));
+std::unique_ptr<GPUStateTracer> GPUStateTracer::Create(
+    const ContextState* state) {
+  return std::unique_ptr<GPUStateTracer>(new GPUStateTracer(state));
 }
 
 GPUStateTracer::GPUStateTracer(const ContextState* state) : state_(state) {
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("gpu.debug"), "gpu::State", state_);
 }
 
 GPUStateTracer::~GPUStateTracer() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("gpu.debug"), "gpu::State", state_);
 }
 
 void GPUStateTracer::TakeSnapshotWithCurrentFramebuffer(const gfx::Size& size) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
                "GPUStateTracer::TakeSnapshotWithCurrentFramebuffer");
 
-  scoped_ptr<Snapshot> snapshot(Snapshot::Create(state_));
+  std::unique_ptr<Snapshot> snapshot(Snapshot::Create(state_));
 
   // Only save a screenshot for now.
   if (!snapshot->SaveScreenshot(size))
     return;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
                                       "gpu::State", state_,
                                       std::move(snapshot));
 }
 
 }  // namespace gles2
 }  // namespace gpu