Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/processor_entity_tracker.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/internal_api/public/processor_entity_tracker.h"
 
 #include <stdint.h>
 
 #include "base/base64.h"
 #include "base/sha1.h"
 #include "base/time/time.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/util/time.h"
 
 namespace syncer_v2 {
 
 namespace {
 
 void HashSpecifics(const sync_pb::EntitySpecifics& specifics,
                    std::string* hash) {
   base::Base64Encode(base::SHA1HashString(specifics.SerializeAsString()), hash);
 }
 
 }  // namespace
 
-scoped_ptr<ProcessorEntityTracker> ProcessorEntityTracker::CreateNew(
+std::unique_ptr<ProcessorEntityTracker> ProcessorEntityTracker::CreateNew(
     const std::string& client_tag,
     const std::string& client_tag_hash,
     const std::string& id,
     base::Time creation_time) {
   // Initialize metadata
   sync_pb::EntityMetadata metadata;
   metadata.set_client_tag_hash(client_tag_hash);
   if (!id.empty())
     metadata.set_server_id(id);
   metadata.set_sequence_number(0);
   metadata.set_acked_sequence_number(0);
   metadata.set_server_version(kUncommittedVersion);
   metadata.set_creation_time(syncer::TimeToProtoTime(creation_time));
 
-  return scoped_ptr<ProcessorEntityTracker>(
+  return std::unique_ptr<ProcessorEntityTracker>(
       new ProcessorEntityTracker(client_tag, &metadata));
 }
 
-scoped_ptr<ProcessorEntityTracker> ProcessorEntityTracker::CreateFromMetadata(
-    const std::string& client_tag,
-    sync_pb::EntityMetadata* metadata) {
-  return scoped_ptr<ProcessorEntityTracker>(
+std::unique_ptr<ProcessorEntityTracker>
+ProcessorEntityTracker::CreateFromMetadata(const std::string& client_tag,
+                                           sync_pb::EntityMetadata* metadata) {
+  return std::unique_ptr<ProcessorEntityTracker>(
       new ProcessorEntityTracker(client_tag, metadata));
 }
 
 ProcessorEntityTracker::ProcessorEntityTracker(
     const std::string& client_tag,
     sync_pb::EntityMetadata* metadata)
     : client_tag_(client_tag),
       commit_requested_sequence_number_(metadata->acked_sequence_number()) {
   DCHECK(metadata->has_client_tag_hash());
   DCHECK(metadata->has_creation_time());
@@ skipping 72 matching lines @@
 void ProcessorEntityTracker::RecordForcedUpdate(
     const UpdateResponseData& update) {
   DCHECK(IsUnsynced());
   // There was a conflict and the server just won it. Explicitly ack all
   // pending commits so they are never enqueued again.
   metadata_.set_acked_sequence_number(metadata_.sequence_number());
   commit_data_.reset();
   RecordAcceptedUpdate(update);
 }
 
-void ProcessorEntityTracker::MakeLocalChange(scoped_ptr<EntityData> data) {
+void ProcessorEntityTracker::MakeLocalChange(std::unique_ptr<EntityData> data) {
   DCHECK(!metadata_.client_tag_hash().empty());
   DCHECK_EQ(metadata_.client_tag_hash(), data->client_tag_hash);
 
   if (data->modification_time.is_null()) {
     data->modification_time = base::Time::Now();
   }
 
   metadata_.set_modification_time(
       syncer::TimeToProtoTime(data->modification_time));
   metadata_.set_is_deleted(false);
@@ skipping 81 matching lines @@
 void ProcessorEntityTracker::UpdateSpecificsHash(
     const sync_pb::EntitySpecifics& specifics) {
   if (specifics.ByteSize() > 0) {
     HashSpecifics(specifics, metadata_.mutable_specifics_hash());
   } else {
     metadata_.clear_specifics_hash();
   }
 }
 
 }  // namespace syncer_v2