[Sync] Rewriting ".reset(new" pattern to use "= base::MakeUnique" instead.

components/sync/engine_impl/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 "components/sync/engine_impl/model_type_registry.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 128 matching lines @@
 void ModelTypeRegistry::ConnectType(
     ModelType type,
     std::unique_ptr<ActivationContext> activation_context) {
   DVLOG(1) << "Enabling an off-thread sync type: " << ModelTypeToString(type);
 
   // Initialize Worker -> Processor communication channel.
   ModelTypeProcessor* type_processor = activation_context->type_processor.get();
 
   std::unique_ptr<Cryptographer> cryptographer_copy;
   if (encrypted_types_.Has(type))
-    cryptographer_copy.reset(new Cryptographer(*cryptographer_));
+    cryptographer_copy = base::MakeUnique<Cryptographer>(*cryptographer_);
 
   std::unique_ptr<ModelTypeWorker> worker(new ModelTypeWorker(
       type, activation_context->model_type_state, std::move(cryptographer_copy),
       nudge_handler_, std::move(activation_context->type_processor)));
 
   // Initialize Processor -> Worker communication channel.
   std::unique_ptr<CommitQueue> commit_queue_proxy(new CommitQueueProxy(
       worker->AsWeakPtr(), scoped_refptr<base::SequencedTaskRunner>(
                                base::ThreadTaskRunnerHandle::Get())));
 
@@ skipping 109 matching lines @@
 void ModelTypeRegistry::OnEncryptedTypesChanged(ModelTypeSet encrypted_types,
                                                 bool encrypt_everything) {
   encrypted_types_ = encrypted_types;
   OnEncryptionStateChanged();
 }
 
 void ModelTypeRegistry::OnEncryptionComplete() {}
 
 void ModelTypeRegistry::OnCryptographerStateChanged(
     Cryptographer* cryptographer) {
-  cryptographer_.reset(new Cryptographer(*cryptographer));
+  cryptographer_ = base::MakeUnique<Cryptographer>(*cryptographer);
   OnEncryptionStateChanged();
 }
 
 void ModelTypeRegistry::OnPassphraseTypeChanged(PassphraseType type,
                                                 base::Time passphrase_time) {}
 
 void ModelTypeRegistry::OnLocalSetPassphraseEncryption(
     const SyncEncryptionHandler::NigoriState& nigori_state) {}
 
 ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const {
@@ skipping 14 matching lines @@
   ModelTypeSet enabled_non_blocking_types;
   for (ScopedVector<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