Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/sync_manager_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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include "sync/internal_api/sync_manager_impl.h"
 
 #include <stdint.h>
+
 #include <cstddef>
 #include <map>
+#include <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/location.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "sync/engine/sync_scheduler.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/internal_api/public/base/cancelation_signal.h"
@@ skipping 871 matching lines @@
 
     // This works only because all routing info types are GROUP_PASSIVE.
     // If we had types in other groups, we would need additional workers
     // to support them.
     scoped_refptr<ModelSafeWorker> worker = new FakeModelWorker(GROUP_PASSIVE);
     workers.push_back(worker);
 
     SyncManager::InitArgs args;
     args.database_location = temp_dir_.path();
     args.service_url = GURL("https://example.com/");
-    args.post_factory =
-        scoped_ptr<HttpPostProviderFactory>(new TestHttpPostProviderFactory());
+    args.post_factory = std::unique_ptr<HttpPostProviderFactory>(
+        new TestHttpPostProviderFactory());
     args.workers = workers;
     args.extensions_activity = extensions_activity_.get(),
     args.change_delegate = this;
     args.credentials = credentials;
     args.invalidator_client_id = "fake_invalidator_client_id";
     args.internal_components_factory.reset(GetFactory());
     args.encryptor = &encryptor_;
     args.unrecoverable_error_handler =
         MakeWeakHandle(mock_unrecoverable_error_handler_.GetWeakPtr());
     args.cancelation_signal = &cancelation_signal_;
@@ skipping 212 matching lines @@
   InternalComponentsFactory::Switches switches_;
   InternalComponentsFactory::StorageOption storage_used_;
   MockUnrecoverableErrorHandler mock_unrecoverable_error_handler_;
 };
 
 TEST_F(SyncManagerTest, GetAllNodesForTypeTest) {
   ModelSafeRoutingInfo routing_info;
   GetModelSafeRoutingInfo(&routing_info);
   sync_manager_.StartSyncingNormally(routing_info, base::Time());
 
-  scoped_ptr<base::ListValue> node_list(
+  std::unique_ptr<base::ListValue> node_list(
       sync_manager_.GetAllNodesForType(syncer::PREFERENCES));
 
   // Should have one node: the type root node.
   ASSERT_EQ(1U, node_list->GetSize());
 
   const base::DictionaryValue* first_result;
   ASSERT_TRUE(node_list->GetDictionary(0, &first_result));
   EXPECT_TRUE(first_result->HasKey("ID"));
   EXPECT_TRUE(first_result->HasKey("NON_UNIQUE_NAME"));
 }
@@ skipping 1380 matching lines @@
   ComponentsFactory(const Switches& switches,
                     SyncScheduler* scheduler_to_use,
                     sessions::SyncSessionContext** session_context,
                     InternalComponentsFactory::StorageOption* storage_used)
       : TestInternalComponentsFactory(
           switches, InternalComponentsFactory::STORAGE_IN_MEMORY, storage_used),
         scheduler_to_use_(scheduler_to_use),
         session_context_(session_context) {}
   ~ComponentsFactory() override {}
 
-  scoped_ptr<SyncScheduler> BuildScheduler(
+  std::unique_ptr<SyncScheduler> BuildScheduler(
       const std::string& name,
       sessions::SyncSessionContext* context,
       CancelationSignal* stop_handle) override {
     *session_context_ = context;
     return std::move(scheduler_to_use_);
   }
 
  private:
-  scoped_ptr<SyncScheduler> scheduler_to_use_;
+  std::unique_ptr<SyncScheduler> scheduler_to_use_;
   sessions::SyncSessionContext** session_context_;
 };
 
 class SyncManagerTestWithMockScheduler : public SyncManagerTest {
  public:
   SyncManagerTestWithMockScheduler() : scheduler_(NULL) {}
   InternalComponentsFactory* GetFactory() override {
     scheduler_ = new MockSyncScheduler();
     return new ComponentsFactory(GetSwitches(), scheduler_, &session_context_,
                                  &storage_used_);
@@ skipping 791 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer