Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/sync_manager_impl.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 "sync/internal_api/sync_manager_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
@@ skipping 242 matching lines @@
   sync_encryption_handler_.reset(new SyncEncryptionHandlerImpl(
       &share_, args->encryptor, args->restored_key_for_bootstrapping,
       args->restored_keystore_key_for_bootstrapping, args->clear_data_option));
   sync_encryption_handler_->AddObserver(this);
   sync_encryption_handler_->AddObserver(&debug_info_event_listener_);
   sync_encryption_handler_->AddObserver(&js_sync_encryption_handler_observer_);
 
   base::FilePath absolute_db_path = database_path_;
   DCHECK(absolute_db_path.IsAbsolute());
 
-  scoped_ptr<syncable::DirectoryBackingStore> backing_store =
+  std::unique_ptr<syncable::DirectoryBackingStore> backing_store =
       args->internal_components_factory->BuildDirectoryBackingStore(
           InternalComponentsFactory::STORAGE_ON_DISK,
           args->credentials.account_id, absolute_db_path);
 
   DCHECK(backing_store.get());
   share_.directory.reset(
       new syncable::Directory(
           backing_store.release(),
           args->unrecoverable_error_handler,
           report_unrecoverable_error_function_,
@@ skipping 453 matching lines @@
     Cryptographer* cryptographer,
     const syncable::EntryKernel& original,
     bool existed_before,
     bool exists_now) {
   // If this is a deletion and the datatype was encrypted, we need to decrypt it
   // and attach it to the buffer.
   if (!exists_now && existed_before) {
     sync_pb::EntitySpecifics original_specifics(original.ref(SPECIFICS));
     if (type == PASSWORDS) {
       // Passwords must use their own legacy ExtraPasswordChangeRecordData.
-      scoped_ptr<sync_pb::PasswordSpecificsData> data(
+      std::unique_ptr<sync_pb::PasswordSpecificsData> data(
           DecryptPasswordSpecifics(original_specifics, cryptographer));
       if (!data) {
         NOTREACHED();
         return;
       }
       buffer->SetExtraDataForId(id, new ExtraPasswordChangeRecordData(*data));
     } else if (original_specifics.has_encrypted()) {
       // All other datatypes can just create a new unencrypted specifics and
       // attach it.
       const sync_pb::EncryptedData& encrypted = original_specifics.encrypted();
@@ skipping 125 matching lines @@
                     OnProtocolEvent(event));
 }
 
 void SyncManagerImpl::SetJsEventHandler(
     const WeakHandle<JsEventHandler>& event_handler) {
   js_sync_manager_observer_.SetJsEventHandler(event_handler);
   js_mutation_event_observer_.SetJsEventHandler(event_handler);
   js_sync_encryption_handler_observer_.SetJsEventHandler(event_handler);
 }
 
-scoped_ptr<base::ListValue> SyncManagerImpl::GetAllNodesForType(
+std::unique_ptr<base::ListValue> SyncManagerImpl::GetAllNodesForType(
     syncer::ModelType type) {
   DirectoryTypeDebugInfoEmitterMap* emitter_map =
       model_type_registry_->directory_type_debug_info_emitter_map();
   DirectoryTypeDebugInfoEmitterMap::iterator it = emitter_map->find(type);
 
   if (it == emitter_map->end()) {
     // This can happen in some cases.  The UI thread makes requests of us
     // when it doesn't really know which types are enabled or disabled.
     DLOG(WARNING) << "Asked to return debug info for invalid type "
                   << ModelTypeToString(type);
-    return scoped_ptr<base::ListValue>(new base::ListValue());
+    return std::unique_ptr<base::ListValue>(new base::ListValue());
   }
 
   return it->second->GetAllNodes();
 }
 
 void SyncManagerImpl::SetInvalidatorEnabled(bool invalidator_enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Invalidator enabled state is now: " << invalidator_enabled;
   allstatus_.SetNotificationsEnabled(invalidator_enabled);
   scheduler_->SetNotificationsEnabled(invalidator_enabled);
 }
 
 void SyncManagerImpl::OnIncomingInvalidation(
     syncer::ModelType type,
-    scoped_ptr<InvalidationInterface> invalidation) {
+    std::unique_ptr<InvalidationInterface> invalidation) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   allstatus_.IncrementNotificationsReceived();
   scheduler_->ScheduleInvalidationNudge(type, std::move(invalidation),
                                         FROM_HERE);
 }
 
 void SyncManagerImpl::RefreshTypes(ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (types.Empty()) {
@@ skipping 111 matching lines @@
   ClearParams params(callback);
   scheduler_->ScheduleClearServerData(params);
 }
 
 void SyncManagerImpl::OnCookieJarChanged(bool account_mismatch) {
   DCHECK(thread_checker_.CalledOnValidThread());
   session_context_->set_cookie_jar_mismatch(account_mismatch);
 }
 
 }  // namespace syncer