Convert //chrome/browser/sync from scoped_ptr to std::unique_ptr

chrome/browser/sync/profile_sync_service_android.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 "chrome/browser/sync/profile_sync_service_android.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
@@ skipping 19 matching lines @@
 using base::android::ScopedJavaLocalRef;
 using content::BrowserThread;
 
 namespace {
 
 // Native callback for the JNI GetAllNodes method. When
 // ProfileSyncService::GetAllNodes completes, this method is called and the
 // results are sent to the Java callback.
 void NativeGetAllNodesCallback(
     const base::android::ScopedJavaGlobalRef<jobject>& callback,
-    scoped_ptr<base::ListValue> result) {
+    std::unique_ptr<base::ListValue> result) {
   JNIEnv* env = base::android::AttachCurrentThread();
   std::string json_string;
   if (!result.get() || !base::JSONWriter::Write(*result, &json_string)) {
     DVLOG(1) << "Writing as JSON failed. Passing empty string to Java code.";
     json_string = std::string();
   }
 
   ScopedJavaLocalRef<jstring> java_json_string =
       ConvertUTF8ToJavaString(env, json_string);
   Java_ProfileSyncService_onGetAllNodesResult(env,
@@ skipping 269 matching lines @@
   return ConvertUTF8ToJavaString(env, status);
 }
 
 void ProfileSyncServiceAndroid::GetAllNodes(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobject>& callback) {
   base::android::ScopedJavaGlobalRef<jobject> java_callback;
   java_callback.Reset(env, callback);
 
-  base::Callback<void(scoped_ptr<base::ListValue>)> native_callback =
+  base::Callback<void(std::unique_ptr<base::ListValue>)> native_callback =
       base::Bind(&NativeGetAllNodesCallback, java_callback);
   sync_service_->GetAllNodes(native_callback);
 }
 
 jint ProfileSyncServiceAndroid::GetAuthError(JNIEnv* env,
                                              const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->GetAuthError().state();
 }
 
@@ skipping 89 matching lines @@
       env, l10n_util::GetStringUTF8(IDS_SYNC_ENTER_PASSPHRASE_BODY));
 }
 
 // Functionality only available for testing purposes.
 
 ScopedJavaLocalRef<jstring> ProfileSyncServiceAndroid::GetAboutInfoForTest(
     JNIEnv* env,
     const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  scoped_ptr<base::DictionaryValue> about_info =
+  std::unique_ptr<base::DictionaryValue> about_info =
       sync_driver::sync_ui_util::ConstructAboutInformation(
           sync_service_, sync_service_->signin(), chrome::GetChannel());
   std::string about_info_json;
   base::JSONWriter::Write(*about_info, &about_info_json);
 
   return ConvertUTF8ToJavaString(env, about_info_json);
 }
 
 jlong ProfileSyncServiceAndroid::GetLastSyncedTimeForTest(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
   // Use profile preferences here instead of SyncPrefs to avoid an extra
   // conversion, since SyncPrefs::GetLastSyncedTime() converts the stored value
   // to to base::Time.
   return static_cast<jlong>(
       profile_->GetPrefs()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime));
 }
 
 void ProfileSyncServiceAndroid::OverrideNetworkResourcesForTest(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     jlong network_resources) {
   syncer::NetworkResources* resources =
       reinterpret_cast<syncer::NetworkResources*>(network_resources);
   sync_service_->OverrideNetworkResourcesForTest(
-      make_scoped_ptr<syncer::NetworkResources>(resources));
+      base::WrapUnique<syncer::NetworkResources>(resources));
 }
 
 // static
 ProfileSyncServiceAndroid*
     ProfileSyncServiceAndroid::GetProfileSyncServiceAndroid() {
   return reinterpret_cast<ProfileSyncServiceAndroid*>(
       Java_ProfileSyncService_getProfileSyncServiceAndroid(
           AttachCurrentThread()));
 }
 
 // static
 bool ProfileSyncServiceAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   ProfileSyncServiceAndroid* profile_sync_service_android =
       new ProfileSyncServiceAndroid(env, obj);
   if (profile_sync_service_android->Init()) {
     return reinterpret_cast<intptr_t>(profile_sync_service_android);
   } else {
     delete profile_sync_service_android;
     return 0;
   }
 }