Some scoped_ptr -> std::unique_ptr conversion, especially under //mojo.

mojo/android/system/core_impl.cc

 // Copyright 2014 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 "mojo/android/system/core_impl.h"
 
+#include <memory>
+
 #include "base/android/base_jni_registrar.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_registrar.h"
 #include "base/android/library_loader/library_loader_hooks.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "jni/CoreImpl_jni.h"
 #include "mojo/public/c/environment/async_waiter.h"
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/handle.h"
 #include "mojo/public/c/system/message_pipe.h"
 #include "mojo/public/c/system/result.h"
 #include "mojo/public/c/system/time.h"
 #include "mojo/public/c/system/wait.h"
 #include "mojo/public/cpp/environment/environment.h"
 
 namespace {
 
 // |AsyncWait| is guaranteed never to return 0.
 const MojoAsyncWaitID kInvalidHandleCancelID = 0;
 
 struct AsyncWaitCallbackData {
   base::android::ScopedJavaGlobalRef<jobject> core_impl;
   base::android::ScopedJavaGlobalRef<jobject> callback;
   base::android::ScopedJavaGlobalRef<jobject> cancellable;
 
   AsyncWaitCallbackData(JNIEnv* env, jobject core_impl, jobject callback) {
     this->core_impl.Reset(env, core_impl);
     this->callback.Reset(env, callback);
   }
 };
 
 void AsyncWaitCallback(void* data, MojoResult result) {
-  scoped_ptr<AsyncWaitCallbackData> callback_data(
+  std::unique_ptr<AsyncWaitCallbackData> callback_data(
       static_cast<AsyncWaitCallbackData*>(data));
   mojo::android::Java_CoreImpl_onAsyncWaitResult(
       base::android::AttachCurrentThread(),
       callback_data->core_impl.obj(),
       result,
       callback_data->callback.obj(),
       callback_data->cancellable.obj());
 }
 
 }  // namespace
@@ skipping 339 matching lines @@
 static void CancelAsyncWait(JNIEnv* env,
                             const JavaParamRef<jobject>& jcaller,
                             jlong id,
                             jlong data_ptr) {
   if (id == 0) {
     // If |id| is |kInvalidHandleCancelID|, the async wait was done on an
     // invalid handle, so the AsyncWaitCallback will be called and will clear
     // the data_ptr.
     return;
   }
-  scoped_ptr<AsyncWaitCallbackData> deleter(
+  std::unique_ptr<AsyncWaitCallbackData> deleter(
       reinterpret_cast<AsyncWaitCallbackData*>(data_ptr));
   Environment::GetDefaultAsyncWaiter()->CancelWait(id);
 }
 
 static jint GetNativeBufferOffset(JNIEnv* env,
                                   const JavaParamRef<jobject>& jcaller,
                                   const JavaParamRef<jobject>& buffer,
                                   jint alignment) {
   jint offset =
       reinterpret_cast<uintptr_t>(env->GetDirectBufferAddress(buffer)) %
@@ skipping 14 matching lines @@
   return Java_CoreImpl_newResultAndBufferInformation(
       env, result, buffer_information.flags, buffer_information.num_bytes);
 }
 
 bool RegisterCoreImpl(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android
 }  // namespace mojo