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

components/sync/engine_impl/model_type_worker_unittest.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_worker.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 167 matching lines @@
     DCHECK(!worker_);
 
     // We don't get to own this object. The |worker_| keeps a unique_ptr to it.
     auto processor = base::MakeUnique<MockModelTypeProcessor>();
     mock_type_processor_ = processor.get();
     processor->SetDisconnectCallback(base::Bind(
         &ModelTypeWorkerTest::DisconnectProcessor, base::Unretained(this)));
 
     std::unique_ptr<Cryptographer> cryptographer_copy;
     if (cryptographer_) {
-      cryptographer_copy.reset(new Cryptographer(*cryptographer_));
+      cryptographer_copy = base::MakeUnique<Cryptographer>(*cryptographer_);
     }
 
     // TODO(maxbogue): crbug.com/529498: Inject pending updates somehow.
-    worker_.reset(
-        new ModelTypeWorker(kModelType, state, std::move(cryptographer_copy),
-                            &mock_nudge_handler_, std::move(processor)));
+    worker_ = base::MakeUnique<ModelTypeWorker>(
+        kModelType, state, std::move(cryptographer_copy), &mock_nudge_handler_,
+        std::move(processor));
   }
 
   // Introduce a new key that the local cryptographer can't decrypt.
   void NewForeignEncryptionKey() {
     if (!cryptographer_) {
-      cryptographer_.reset(new Cryptographer(&fake_encryptor_));
+      cryptographer_ = base::MakeUnique<Cryptographer>(&fake_encryptor_);
     }
 
     foreign_encryption_key_index_++;
 
     sync_pb::NigoriKeyBag bag;
 
     for (int i = 0; i <= foreign_encryption_key_index_; ++i) {
       Nigori nigori;
       KeyParams params = GetNthKeyParams(i);
       nigori.InitByDerivation(params.hostname, params.username,
@@ skipping 26 matching lines @@
     // Update the worker with the latest cryptographer.
     if (worker_) {
       worker_->UpdateCryptographer(
           base::MakeUnique<Cryptographer>(*cryptographer_));
     }
   }
 
   // Update the local cryptographer with all relevant keys.
   void UpdateLocalCryptographer() {
     if (!cryptographer_) {
-      cryptographer_.reset(new Cryptographer(&fake_encryptor_));
+      cryptographer_ = base::MakeUnique<Cryptographer>(&fake_encryptor_);
     }
 
     KeyParams params = GetNthKeyParams(foreign_encryption_key_index_);
     bool success = cryptographer_->DecryptPendingKeys(params);
     DCHECK(success);
 
     // Update the worker with the latest cryptographer.
     if (worker_) {
       worker_->UpdateCryptographer(
           base::MakeUnique<Cryptographer>(*cryptographer_));
@@ skipping 760 matching lines @@
 // disconnected.
 TEST_F(ModelTypeWorkerTest, DisconnectProcessorFromSyncTest) {
   // Initialize the worker with basic state.
   NormalInitialize();
   EXPECT_FALSE(IsProcessorDisconnected());
   ResetWorker();
   EXPECT_TRUE(IsProcessorDisconnected());
 }
 
 }  // namespace syncer