Convert //sync from scoped_ptr to std::unique_ptr

sync/sessions/model_type_registry.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 "sync/sessions/model_type_registry.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/observer_list.h"
 #include "base/thread_task_runner_handle.h"
 #include "sync/engine/commit_queue.h"
 #include "sync/engine/directory_commit_contributor.h"
 #include "sync/engine/directory_update_handler.h"
 #include "sync/engine/model_type_worker.h"
 #include "sync/internal_api/public/activation_context.h"
 #include "sync/internal_api/public/model_type_processor.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/util/cryptographer.h"
@@ skipping 111 matching lines @@
     DCHECK(inserted2) << "Attempt to override existing type handler in map";
     enabled_directory_types_.Put(type);
   }
 
   DCHECK(Intersection(GetEnabledDirectoryTypes(),
                       GetEnabledNonBlockingTypes()).Empty());
 }
 
 void ModelTypeRegistry::ConnectSyncTypeToWorker(
     ModelType type,
-    scoped_ptr<syncer_v2::ActivationContext> activation_context) {
+    std::unique_ptr<syncer_v2::ActivationContext> activation_context) {
   DVLOG(1) << "Enabling an off-thread sync type: " << ModelTypeToString(type);
 
   // Initialize Worker -> Processor communication channel.
   syncer_v2::ModelTypeProcessor* type_processor =
       activation_context->type_processor.get();
 
-  scoped_ptr<Cryptographer> cryptographer_copy;
+  std::unique_ptr<Cryptographer> cryptographer_copy;
   if (encrypted_types_.Has(type))
     cryptographer_copy.reset(new Cryptographer(*cryptographer_));
 
-  scoped_ptr<syncer_v2::ModelTypeWorker> worker(new syncer_v2::ModelTypeWorker(
-      type, activation_context->data_type_state, std::move(cryptographer_copy),
-      nudge_handler_, std::move(activation_context->type_processor)));
+  std::unique_ptr<syncer_v2::ModelTypeWorker> worker(
+      new syncer_v2::ModelTypeWorker(
+          type, activation_context->data_type_state,
+          std::move(cryptographer_copy), nudge_handler_,
+          std::move(activation_context->type_processor)));
 
   // Initialize Processor -> Worker communication channel.
-  scoped_ptr<syncer_v2::CommitQueue> commit_queue_proxy(new CommitQueueProxy(
-      worker->AsWeakPtr(), scoped_refptr<base::SequencedTaskRunner>(
+  std::unique_ptr<syncer_v2::CommitQueue> commit_queue_proxy(
+      new CommitQueueProxy(worker->AsWeakPtr(),
+                           scoped_refptr<base::SequencedTaskRunner>(
                                base::ThreadTaskRunnerHandle::Get())));
 
   type_processor->ConnectSync(std::move(commit_queue_proxy));
 
   DCHECK(update_handler_map_.find(type) == update_handler_map_.end());
   DCHECK(commit_contributor_map_.find(type) == commit_contributor_map_.end());
 
   update_handler_map_.insert(std::make_pair(type, worker.get()));
   commit_contributor_map_.insert(std::make_pair(type, worker.get()));
 
@@ skipping 112 matching lines @@
 ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const {
   return enabled_directory_types_;
 }
 
 void ModelTypeRegistry::OnEncryptionStateChanged() {
   for (ScopedVector<syncer_v2::ModelTypeWorker>::iterator it =
            model_type_workers_.begin();
        it != model_type_workers_.end(); ++it) {
     if (encrypted_types_.Has((*it)->GetModelType())) {
       (*it)->UpdateCryptographer(
-          make_scoped_ptr(new Cryptographer(*cryptographer_)));
+          base::WrapUnique(new Cryptographer(*cryptographer_)));
     }
   }
 }
 
 ModelTypeSet ModelTypeRegistry::GetEnabledNonBlockingTypes() const {
   ModelTypeSet enabled_non_blocking_types;
   for (ScopedVector<syncer_v2::ModelTypeWorker>::const_iterator it =
            model_type_workers_.begin();
        it != model_type_workers_.end(); ++it) {
     enabled_non_blocking_types.Put((*it)->GetModelType());
   }
   return enabled_non_blocking_types;
 }
 
 }  // namespace syncer