Convert //ppapi to use std::unique_ptr

ppapi/proxy/file_io_resource.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 "ppapi/proxy/file_io_resource.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 64 matching lines @@
 }
 
 int32_t FileIOResource::ReadOp::DoWork() {
   DCHECK(!buffer_.get());
   buffer_.reset(new char[bytes_to_read_]);
   return file_holder_->file()->Read(offset_, buffer_.get(), bytes_to_read_);
 }
 
 FileIOResource::WriteOp::WriteOp(scoped_refptr<FileHolder> file_holder,
                                  int64_t offset,
-                                 scoped_ptr<char[]> buffer,
+                                 std::unique_ptr<char[]> buffer,
                                  int32_t bytes_to_write,
                                  bool append)
     : file_holder_(file_holder),
       offset_(offset),
       buffer_(std::move(buffer)),
       bytes_to_write_(bytes_to_write),
       append_(append) {}
 
 FileIOResource::WriteOp::~WriteOp() {
 }
@@ skipping 198 matching lines @@
       if (max_offset >
           static_cast<uint64_t>(std::numeric_limits<int64_t>::max())) {
         return PP_ERROR_FAILED;  // amount calculation would overflow.
       }
       increase = static_cast<int64_t>(max_offset) - max_written_offset_;
     }
 
     if (increase > 0) {
       // Request a quota reservation. This makes the Write asynchronous, so we
       // must copy the plugin's buffer.
-      scoped_ptr<char[]> copy(new char[bytes_to_write]);
+      std::unique_ptr<char[]> copy(new char[bytes_to_write]);
       memcpy(copy.get(), buffer, bytes_to_write);
       int64_t result =
           file_system_resource_->AsPPB_FileSystem_API()->RequestQuota(
               increase,
               base::Bind(&FileIOResource::OnRequestWriteQuotaComplete,
                          this,
                          offset,
                          base::Passed(&copy),
                          bytes_to_write,
                          callback));
@@ skipping 193 matching lines @@
     }
     if (result < 0)
       result = PP_ERROR_FAILED;
 
     state_manager_.SetOperationFinished();
     return result;
   }
 
   // For the non-blocking case, post a task to the file thread. We must copy the
   // plugin's buffer at this point.
-  scoped_ptr<char[]> copy(new char[bytes_to_write]);
+  std::unique_ptr<char[]> copy(new char[bytes_to_write]);
   memcpy(copy.get(), buffer, bytes_to_write);
   scoped_refptr<WriteOp> write_op(new WriteOp(
       file_holder_, offset, std::move(copy), bytes_to_write, append));
   base::PostTaskAndReplyWithResult(
       PpapiGlobals::Get()->GetFileTaskRunner(),
       FROM_HERE,
       Bind(&FileIOResource::WriteOp::DoWork, write_op),
       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
   callback->set_completion_task(Bind(&FileIOResource::OnWriteComplete, this));
 
@@ skipping 46 matching lines @@
   } else {
     // The read operation failed.
     result = PP_ERROR_FAILED;
   }
   state_manager_.SetOperationFinished();
   return result;
 }
 
 void FileIOResource::OnRequestWriteQuotaComplete(
     int64_t offset,
-    scoped_ptr<char[]> buffer,
+    std::unique_ptr<char[]> buffer,
     int32_t bytes_to_write,
     scoped_refptr<TrackedCallback> callback,
     int64_t granted) {
   DCHECK(granted >= 0);
   if (granted == 0) {
     callback->Run(PP_ERROR_NOQUOTA);
     return;
   }
   if (open_flags_ & PP_FILEOPENFLAG_APPEND) {
     DCHECK_LE(bytes_to_write, granted);
@@ skipping 117 matching lines @@
   *output_handle = IPC::PlatformFileForTransitToPlatformFile(transit_file);
 
   // End this operation now, so the user's callback can execute another FileIO
   // operation, assuming there are no other pending operations.
   state_manager_.SetOperationFinished();
   callback->Run(result);
 }
 
 }  // namespace proxy
 }  // namespace ppapi