Convert //sync from scoped_ptr to std::unique_ptr

sync/syncable/directory_backing_store.cc

 // Copyright 2012 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/directory_backing_store.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 108 matching lines @@
       prev_length = length;
       prev_index = *index;
       ++(*total_entry_copies);
     }
   }
 }
 
 // The caller owns the returned EntryKernel*.  Assumes the statement currently
 // points to a valid row in the metas table. Returns NULL to indicate that
 // it detected a corruption in the data on unpacking.
-scoped_ptr<EntryKernel> UnpackEntry(sql::Statement* statement,
-                                    int* total_specifics_copies) {
-  scoped_ptr<EntryKernel> kernel(new EntryKernel());
+std::unique_ptr<EntryKernel> UnpackEntry(sql::Statement* statement,
+                                         int* total_specifics_copies) {
+  std::unique_ptr<EntryKernel> kernel(new EntryKernel());
   DCHECK_EQ(statement->ColumnCount(), static_cast<int>(FIELD_COUNT));
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     kernel->put(static_cast<Int64Field>(i), statement->ColumnInt64(i));
   }
   for ( ; i < TIME_FIELDS_END; ++i) {
     kernel->put(static_cast<TimeField>(i),
                 ProtoTimeToTime(statement->ColumnInt64(i)));
   }
   for ( ; i < ID_FIELDS_END; ++i) {
     kernel->mutable_ref(static_cast<IdField>(i)).s_ =
         statement->ColumnString(i);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     kernel->put(static_cast<BitField>(i), (0 != statement->ColumnInt(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     kernel->put(static_cast<StringField>(i),
                 statement->ColumnString(i));
   }
   UnpackProtoFields<sync_pb::EntitySpecifics, ProtoField>(
       statement, kernel.get(), &i, PROTO_FIELDS_END, total_specifics_copies);
   for ( ; i < UNIQUE_POSITION_FIELDS_END; ++i) {
     std::string temp;
     statement->ColumnBlobAsString(i, &temp);
 
     sync_pb::UniquePosition proto;
     if (!proto.ParseFromString(temp)) {
       DVLOG(1) << "Unpacked invalid position.  Assuming the DB is corrupt";
-      return scoped_ptr<EntryKernel>();
+      return std::unique_ptr<EntryKernel>();
     }
 
     kernel->mutable_ref(static_cast<UniquePositionField>(i)) =
         UniquePosition::FromProto(proto);
   }
   int attachemnt_specifics_counts = 0;
   UnpackProtoFields<sync_pb::AttachmentMetadata, AttachmentMetadataField>(
       statement, kernel.get(), &i, ATTACHMENT_METADATA_FIELDS_END,
       &attachemnt_specifics_counts);
 
   // Sanity check on positions.  We risk strange and rare crashes if our
   // assumptions about unique position values are broken.
   if (kernel->ShouldMaintainPosition() &&
       !kernel->ref(UNIQUE_POSITION).IsValid()) {
     DVLOG(1) << "Unpacked invalid position on an entity that should have a "
              << "valid position.  Assuming the DB is corrupt.";
-    return scoped_ptr<EntryKernel>();
+    return std::unique_ptr<EntryKernel>();
   }
 
   return kernel;
 }
 
 namespace {
 
 // This just has to be big enough to hold an UPDATE or INSERT statement that
 // modifies all the columns in the entry table.
 static const string::size_type kUpdateStatementBufferSize = 2048;
@@ skipping 468 matching lines @@
   select.append(" FROM metas");
   int total_specifics_copies = 0;
   int model_type_entry_count[MODEL_TYPE_COUNT];
   for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
     model_type_entry_count[i] = 0;
   }
 
   sql::Statement s(db_->GetUniqueStatement(select.c_str()));
 
   while (s.Step()) {
-    scoped_ptr<EntryKernel> kernel = UnpackEntry(&s, &total_specifics_copies);
+    std::unique_ptr<EntryKernel> kernel =
+        UnpackEntry(&s, &total_specifics_copies);
     // A null kernel is evidence of external data corruption.
     if (!kernel)
       return false;
 
     int64_t handle = kernel->ref(META_HANDLE);
     if (SafeToPurgeOnLoading(*kernel)) {
       metahandles_to_purge->insert(handle);
     } else {
       ModelType model_type = kernel->GetModelType();
       if (!IsRealDataType(model_type)) {
@@ skipping 25 matching lines @@
   string select;
   select.reserve(kUpdateStatementBufferSize);
   select.append("SELECT ");
   AppendColumnList(&select);
   select.append(" FROM deleted_metas");
 
   sql::Statement s(db_->GetUniqueStatement(select.c_str()));
 
   while (s.Step()) {
     int total_entry_copies;
-    scoped_ptr<EntryKernel> kernel = UnpackEntry(&s, &total_entry_copies);
+    std::unique_ptr<EntryKernel> kernel = UnpackEntry(&s, &total_entry_copies);
     // A null kernel is evidence of external data corruption.
     if (!kernel)
       return false;
     delete_journals->insert(kernel.release());
   }
   return s.Succeeded();
 }
 
 bool DirectoryBackingStore::LoadInfo(Directory::KernelLoadInfo* info) {
   {
@@ skipping 1034 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(!catastrophic_error_handler.is_null());
   catastrophic_error_handler_ = catastrophic_error_handler;
   sql::Connection::ErrorCallback error_callback =
       base::Bind(&OnSqliteError, catastrophic_error_handler_);
   db_->set_error_callback(error_callback);
 }
 
 }  // namespace syncable
 }  // namespace syncer