Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/sync_encryption_handler_impl_unittest.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/internal_api/sync_encryption_handler_impl.h"
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/base64.h"
 #include "base/json/json_string_value_serializer.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/tracked_objects.h"
 #include "sync/internal_api/public/base/model_type_test_util.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/test/test_user_share.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
@@ skipping 337 matching lines @@
     encryption_handler()->RestoreNigori(nigori_state);
     encryption_handler()->Init();
     Mock::VerifyAndClearExpectations(observer());
     VerifyMigratedNigoriWithTimestamp(migration_time, passphrase_type,
                                       passphrase);
   }
 
  protected:
   TestUserShare test_user_share_;
   FakeEncryptor encryptor_;
-  scoped_ptr<SyncEncryptionHandlerImpl> encryption_handler_;
+  std::unique_ptr<SyncEncryptionHandlerImpl> encryption_handler_;
   StrictMock<SyncEncryptionHandlerObserverMock> observer_;
   TestIdFactory ids_;
   base::MessageLoop message_loop_;
 };
 
 // Verify that the encrypted types are being written to and read from the
 // nigori node properly.
 TEST_F(SyncEncryptionHandlerImplTest, NigoriEncryptionTypes) {
   sync_pb::NigoriSpecifics nigori;
 
@@ skipping 310 matching lines @@
 
   // Ensure the bootstrap is encoded properly (a base64 encoded encrypted blob
   // of list values containing the keystore keys).
   std::string decoded_bootstrap;
   ASSERT_TRUE(base::Base64Decode(keystore_bootstrap, &decoded_bootstrap));
   std::string decrypted_bootstrap;
   ASSERT_TRUE(
       GetCryptographer()->encryptor()->DecryptString(decoded_bootstrap,
                                                      &decrypted_bootstrap));
   JSONStringValueDeserializer json(decrypted_bootstrap);
-  scoped_ptr<base::Value> deserialized_keystore_keys(
+  std::unique_ptr<base::Value> deserialized_keystore_keys(
       json.Deserialize(NULL, NULL));
   ASSERT_TRUE(deserialized_keystore_keys.get());
   base::ListValue* keystore_list = NULL;
   deserialized_keystore_keys->GetAsList(&keystore_list);
   ASSERT_TRUE(keystore_list);
   ASSERT_EQ(2U, keystore_list->GetSize());
   std::string test_string;
   keystore_list->GetString(0, &test_string);
   ASSERT_EQ(old_keystore_key, test_string);
   keystore_list->GetString(1, &test_string);
@@ skipping 1782 matching lines @@
               OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
   {
     ReadTransaction trans(FROM_HERE, user_share());
     encryption_handler()->SetKeystoreKeys(BuildEncryptionKeyProto(
                                               kRawKeystoreKey),
                                           trans.GetWrappedTrans());
   }
 }
 
 }  // namespace syncer