Convert //sync from scoped_ptr to std::unique_ptr

sync/engine/directory_commit_contribution.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/engine/directory_commit_contribution.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
 
 #include "sync/engine/commit_util.h"
 #include "sync/engine/get_commit_ids.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/internal_api/public/sessions/commit_counters.h"
 #include "sync/syncable/model_neutral_mutable_entry.h"
 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
 
 namespace syncer {
 
 using syncable::GET_BY_HANDLE;
 using syncable::SYNCER;
 
 DirectoryCommitContribution::~DirectoryCommitContribution() {
   DCHECK(!syncing_bits_set_);
 }
 
 // static.
-scoped_ptr<DirectoryCommitContribution> DirectoryCommitContribution::Build(
+std::unique_ptr<DirectoryCommitContribution> DirectoryCommitContribution::Build(
     syncable::Directory* dir,
     ModelType type,
     size_t max_entries,
     DirectoryTypeDebugInfoEmitter* debug_info_emitter) {
   DCHECK(debug_info_emitter);
 
   std::vector<int64_t> metahandles;
 
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir);
   GetCommitIdsForType(&trans, type, max_entries, &metahandles);
 
   if (metahandles.empty())
-    return scoped_ptr<DirectoryCommitContribution>();
+    return std::unique_ptr<DirectoryCommitContribution>();
 
   google::protobuf::RepeatedPtrField<sync_pb::SyncEntity> entities;
   for (std::vector<int64_t>::iterator it = metahandles.begin();
        it != metahandles.end(); ++it) {
     sync_pb::SyncEntity* entity = entities.Add();
     syncable::ModelNeutralMutableEntry entry(&trans, GET_BY_HANDLE, *it);
     commit_util::BuildCommitItem(entry, entity);
     entry.PutSyncing(true);
   }
 
   sync_pb::DataTypeContext context;
   dir->GetDataTypeContext(&trans, type, &context);
 
-  return scoped_ptr<DirectoryCommitContribution>(
-      new DirectoryCommitContribution(
-          metahandles,
-          entities,
-          context,
-          dir,
-          debug_info_emitter));
+  return std::unique_ptr<DirectoryCommitContribution>(
+      new DirectoryCommitContribution(metahandles, entities, context, dir,
+                                      debug_info_emitter));
 }
 
 void DirectoryCommitContribution::AddToCommitMessage(
     sync_pb::ClientToServerMessage* msg) {
   DCHECK(syncing_bits_set_);
   sync_pb::CommitMessage* commit_message = msg->mutable_commit();
   entries_start_index_ = commit_message->entries_size();
   std::copy(entities_.begin(),
             entities_.end(),
             RepeatedPtrFieldBackInserter(commit_message->mutable_entries()));
@@ skipping 120 matching lines @@
     // complete but the Cleanup method is called anyways. It appears these are
     // unset on the assumption that the sync cycle must have finished properly,
     // although that's actually up to the commit response handling logic.
     entry.PutDirtySync(false);
     entry.PutSyncing(false);
   }
   syncing_bits_set_ = false;
 }
 
 }  // namespace syncer