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

components/sync/driver/generic_change_processor.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/driver/generic_change_processor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/base/unrecoverable_error_handler.h"
 #include "components/sync/driver/sync_api_component_factory.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/model/local_change_observer.h"
 #include "components/sync/model/sync_change.h"
 #include "components/sync/model/sync_error.h"
 #include "components/sync/model/syncable_service.h"
@@ skipping 100 matching lines @@
   if (attachment_store) {
     std::string store_birthday;
     {
       ReadTransaction trans(FROM_HERE, share_handle());
       store_birthday = trans.GetStoreBirthday();
     }
     attachment_service_ =
         sync_client->GetSyncApiComponentFactory()->CreateAttachmentService(
             std::move(attachment_store), *user_share, store_birthday, type,
             this);
-    attachment_service_weak_ptr_factory_.reset(
-        new base::WeakPtrFactory<AttachmentService>(attachment_service_.get()));
+    attachment_service_weak_ptr_factory_ =
+        base::MakeUnique<base::WeakPtrFactory<AttachmentService>>(
+            attachment_service_.get());
     attachment_service_proxy_ = AttachmentServiceProxy(
         base::ThreadTaskRunnerHandle::Get(),
         attachment_service_weak_ptr_factory_->GetWeakPtr());
     UploadAllAttachmentsNotOnServer();
   } else {
     attachment_service_proxy_ =
         AttachmentServiceProxy(base::ThreadTaskRunnerHandle::Get(),
                                base::WeakPtr<AttachmentService>());
   }
 }
 
 GenericChangeProcessor::~GenericChangeProcessor() {
   DCHECK(CalledOnValidThread());
 }
 
 void GenericChangeProcessor::ApplyChangesFromSyncModel(
     const BaseTransaction* trans,
     int64_t model_version,
     const ImmutableChangeRecordList& changes) {
   DCHECK(CalledOnValidThread());
   DCHECK(syncer_changes_.empty());
   for (ChangeRecordList::const_iterator it = changes.Get().begin();
        it != changes.Get().end(); ++it) {
     if (it->action == ChangeRecord::ACTION_DELETE) {
       std::unique_ptr<sync_pb::EntitySpecifics> specifics;
       if (it->specifics.has_password()) {
         DCHECK(it->extra.get());
-        specifics.reset(new sync_pb::EntitySpecifics(it->specifics));
+        specifics = base::MakeUnique<sync_pb::EntitySpecifics>(it->specifics);
         specifics->mutable_password()
             ->mutable_client_only_encrypted_data()
             ->CopyFrom(it->extra->unencrypted());
       }
       const AttachmentIdList empty_list_of_attachment_ids;
       syncer_changes_.push_back(SyncChange(
           FROM_HERE, SyncChange::ACTION_DELETE,
           SyncData::CreateRemoteData(
               it->id, specifics ? *specifics : it->specifics, base::Time(),
               empty_list_of_attachment_ids, attachment_service_proxy_)));
@@ skipping 524 matching lines @@
                     OnLocalChange(current_entry, change));
 }
 
 std::unique_ptr<AttachmentService>
 GenericChangeProcessor::GetAttachmentService() const {
   return std::unique_ptr<AttachmentService>(
       new AttachmentServiceProxy(attachment_service_proxy_));
 }
 
 }  // namespace syncer