Convert //sync from scoped_ptr to std::unique_ptr

sync/util/cryptographer.cc

 // Copyright (c) 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/util/cryptographer.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 146 matching lines @@
                       key->mutable_encryption_key(),
                       key->mutable_mac_key());
   }
 
   // Encrypt the bag with the default Nigori.
   return Encrypt(bag, encrypted);
 }
 
 bool Cryptographer::AddKey(const KeyParams& params) {
   // Create the new Nigori and make it the default encryptor.
-  scoped_ptr<Nigori> nigori(new Nigori);
+  std::unique_ptr<Nigori> nigori(new Nigori);
   if (!nigori->InitByDerivation(params.hostname,
                                 params.username,
                                 params.password)) {
     NOTREACHED();  // Invalid username or password.
     return false;
   }
   return AddKeyImpl(std::move(nigori), true);
 }
 
 bool Cryptographer::AddNonDefaultKey(const KeyParams& params) {
   DCHECK(is_initialized());
   // Create the new Nigori and add it to the keybag.
-  scoped_ptr<Nigori> nigori(new Nigori);
+  std::unique_ptr<Nigori> nigori(new Nigori);
   if (!nigori->InitByDerivation(params.hostname,
                                 params.username,
                                 params.password)) {
     NOTREACHED();  // Invalid username or password.
     return false;
   }
   return AddKeyImpl(std::move(nigori), false);
 }
 
 bool Cryptographer::AddKeyFromBootstrapToken(
     const std::string& restored_bootstrap_token) {
   // Create the new Nigori and make it the default encryptor.
   std::string serialized_nigori_key = UnpackBootstrapToken(
       restored_bootstrap_token);
   return ImportNigoriKey(serialized_nigori_key);
 }
 
-bool Cryptographer::AddKeyImpl(scoped_ptr<Nigori> initialized_nigori,
+bool Cryptographer::AddKeyImpl(std::unique_ptr<Nigori> initialized_nigori,
                                bool set_as_default) {
   std::string name;
   if (!initialized_nigori->Permute(Nigori::Password, kNigoriKeyName, &name)) {
     NOTREACHED();
     return false;
   }
 
   nigoris_[name] = make_linked_ptr(initialized_nigori.release());
 
   // Check if the key we just added can decrypt the pending keys and add them
@@ skipping 95 matching lines @@
   }
   return unencrypted_token;
 }
 
 void Cryptographer::InstallKeyBag(const sync_pb::NigoriKeyBag& bag) {
   int key_size = bag.key_size();
   for (int i = 0; i < key_size; ++i) {
     const sync_pb::NigoriKey key = bag.key(i);
     // Only use this key if we don't already know about it.
     if (nigoris_.end() == nigoris_.find(key.name())) {
-      scoped_ptr<Nigori> new_nigori(new Nigori);
+      std::unique_ptr<Nigori> new_nigori(new Nigori);
       if (!new_nigori->InitByImport(key.user_key(),
                                     key.encryption_key(),
                                     key.mac_key())) {
         NOTREACHED();
         continue;
       }
       nigoris_[key.name()] = make_linked_ptr(new_nigori.release());
     }
   }
 }
@@ skipping 38 matching lines @@
 }
 
 bool Cryptographer::ImportNigoriKey(const std::string& serialized_nigori_key) {
   if (serialized_nigori_key.empty())
     return false;
 
   sync_pb::NigoriKey key;
   if (!key.ParseFromString(serialized_nigori_key))
     return false;
 
-  scoped_ptr<Nigori> nigori(new Nigori);
+  std::unique_ptr<Nigori> nigori(new Nigori);
   if (!nigori->InitByImport(key.user_key(), key.encryption_key(),
                             key.mac_key())) {
     NOTREACHED();
     return false;
   }
 
   if (!AddKeyImpl(std::move(nigori), true))
     return false;
   return true;
 }
 
 }  // namespace syncer