Convert //sync from scoped_ptr to std::unique_ptr

sync/syncable/model_neutral_mutable_entry.cc

 // Copyright 2013 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/syncable/model_neutral_mutable_entry.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 13 matching lines @@
 
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(BaseWriteTransaction* trans,
                                                    CreateNewUpdateItem,
                                                    const Id& id)
     : Entry(trans), base_write_transaction_(trans) {
   Entry same_id(trans, GET_BY_ID, id);
   kernel_ = NULL;
   if (same_id.good()) {
     return;  // already have an item with this ID.
   }
-  scoped_ptr<EntryKernel> kernel(new EntryKernel());
+  std::unique_ptr<EntryKernel> kernel(new EntryKernel());
 
   kernel->put(ID, id);
   kernel->put(META_HANDLE, trans->directory()->NextMetahandle());
   kernel->mark_dirty(&trans->directory()->kernel()->dirty_metahandles);
   kernel->put(IS_DEL, true);
   // We match the database defaults here
   kernel->put(BASE_VERSION, CHANGES_VERSION);
   if (!trans->directory()->InsertEntry(trans, kernel.get())) {
     return;  // Failed inserting.
   }
   trans->TrackChangesTo(kernel.get());
 
   kernel_ = kernel.release();
 }
 
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(BaseWriteTransaction* trans,
                                                    CreateNewTypeRoot,
                                                    ModelType type)
     : Entry(trans), base_write_transaction_(trans) {
   // We allow NIGORI because we allow SyncEncryptionHandler to restore a nigori
   // across Directory instances (see SyncEncryptionHandler::RestoreNigori).
   if (type != NIGORI)
     DCHECK(IsTypeWithClientGeneratedRoot(type));
   Entry same_type_root(trans, GET_TYPE_ROOT, type);
   kernel_ = NULL;
   if (same_type_root.good()) {
     return;  // already have a type root for the given type
   }
 
-  scoped_ptr<EntryKernel> kernel(new EntryKernel());
+  std::unique_ptr<EntryKernel> kernel(new EntryKernel());
 
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(type, &specifics);
   kernel->put(SPECIFICS, specifics);
 
   kernel->put(ID,
               syncable::Id::CreateFromClientString(ModelTypeToString(type)));
   kernel->put(META_HANDLE, trans->directory()->NextMetahandle());
   kernel->put(PARENT_ID, syncable::Id::GetRoot());
   kernel->put(BASE_VERSION, CHANGES_VERSION);
@@ skipping 382 matching lines @@
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(BaseWriteTransaction* trans)
   : Entry(trans), base_write_transaction_(trans) {}
 
 void ModelNeutralMutableEntry::MarkDirty() {
   kernel_->mark_dirty(&dir()->kernel()->dirty_metahandles);
 }
 
 }  // namespace syncable
 
 }  // namespace syncer