Convert //sync from scoped_ptr to std::unique_ptr

sync/test/fake_server/fake_server_verifier.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/test/fake_server/fake_server_verifier.h"
 
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <vector>
 
 #include "base/json/json_writer.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/test/fake_server/fake_server.h"
 #include "sync/test/fake_server/sessions_hierarchy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONWriter;
 using std::string;
 using testing::AssertionFailure;
 using testing::AssertionResult;
@@ skipping 44 matching lines @@
 }  // namespace
 
 FakeServerVerifier::FakeServerVerifier(FakeServer* fake_server)
     : fake_server_(fake_server) { }
 
 FakeServerVerifier::~FakeServerVerifier() {}
 
 AssertionResult FakeServerVerifier::VerifyEntityCountByType(
     size_t expected_count,
     syncer::ModelType model_type) const {
-  scoped_ptr<base::DictionaryValue> entities =
+  std::unique_ptr<base::DictionaryValue> entities =
       fake_server_->GetEntitiesAsDictionaryValue();
   if (!entities.get()) {
     return DictionaryCreationAssertionFailure();
   }
 
   string model_type_string = ModelTypeToString(model_type);
   base::ListValue* entity_list = NULL;
   if (!entities->GetList(model_type_string, &entity_list)) {
     return UnknownTypeAssertionFailure(model_type_string);
   } else if  (expected_count != entity_list->GetSize()) {
     return VerificationCountAssertionFailure(entity_list->GetSize(),
                                              expected_count)
         << "\n\n"
         << ConvertFakeServerContentsToString(*entities);
   }
 
   return AssertionSuccess();
 }
 
 AssertionResult FakeServerVerifier::VerifyEntityCountByTypeAndName(
     size_t expected_count,
     syncer::ModelType model_type,
     const string& name) const {
-  scoped_ptr<base::DictionaryValue> entities =
+  std::unique_ptr<base::DictionaryValue> entities =
       fake_server_->GetEntitiesAsDictionaryValue();
   if (!entities.get()) {
     return DictionaryCreationAssertionFailure();
   }
 
   string model_type_string = ModelTypeToString(model_type);
   base::ListValue* entity_list = NULL;
   size_t actual_count = 0;
   if (entities->GetList(model_type_string, &entity_list)) {
-    scoped_ptr<base::Value> name_value(new base::StringValue(name));
+    std::unique_ptr<base::Value> name_value(new base::StringValue(name));
     for (base::ListValue::const_iterator it = entity_list->begin();
          it != entity_list->end(); ++it) {
       if (name_value->Equals(*it)) {
         actual_count++;
       }
     }
   }
 
   if (!entity_list) {
     return UnknownTypeAssertionFailure(model_type_string);
@@ skipping 58 matching lines @@
         return AssertionFailure() << "Malformed data: Tab entity not found.";
       }
       tab_urls.insert(tab_ids_to_urls[tab_id]);
     }
     actual_sessions.AddWindow(tab_urls);
   }
   return VerifySessionsHierarchyEquality(expected_sessions, actual_sessions);
 }
 
 }  // namespace fake_server