Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/http_bridge_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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bit_cast.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/stringprintf.h"
@@ skipping 457 matching lines @@
   io_thread()->Stop();
 }
 
 void HttpBridgeRunOnSyncThread(
     net::URLRequestContextGetter* baseline_context_getter,
     CancelationSignal* factory_cancelation_signal,
     syncer::HttpPostProviderFactory** bridge_factory_out,
     syncer::HttpPostProviderInterface** bridge_out,
     base::WaitableEvent* signal_when_created,
     base::WaitableEvent* wait_for_shutdown) {
-  scoped_ptr<syncer::HttpBridgeFactory> bridge_factory(
+  std::unique_ptr<syncer::HttpBridgeFactory> bridge_factory(
       new syncer::HttpBridgeFactory(baseline_context_getter,
                                     NetworkTimeUpdateCallback(),
                                     factory_cancelation_signal));
   bridge_factory->Init("test", BindToTrackerCallback());
   *bridge_factory_out = bridge_factory.get();
 
   HttpPostProviderInterface* bridge = bridge_factory->Create();
   *bridge_out = bridge;
 
   signal_when_created->Signal();
@@ skipping 66 matching lines @@
 TEST_F(MAYBE_SyncHttpBridgeTest, EarlyAbortFactory) {
   // In a real scenario, the following would happen on many threads.  For
   // simplicity, this test uses only one thread.
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   CancelationSignal release_request_context_signal;
 
   // UI Thread: Initialize the HttpBridgeFactory.  The next step would be to
   // post a task to SBH::Core to have it initialized.
-  scoped_ptr<syncer::HttpBridgeFactory> factory(
-      new HttpBridgeFactory(baseline_context_getter.get(),
-                            NetworkTimeUpdateCallback(),
-                            &release_request_context_signal));
+  std::unique_ptr<syncer::HttpBridgeFactory> factory(new HttpBridgeFactory(
+      baseline_context_getter.get(), NetworkTimeUpdateCallback(),
+      &release_request_context_signal));
 
   // UI Thread: A very early shutdown request arrives and executes on the UI
   // thread before the posted sync thread task is run.
   release_request_context_signal.Signal();
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent", BindToTrackerCallback());
 
   // At this point, attempting to use the factory would trigger a crash.  Both
   // this test and the real world code should make sure this never happens.
 }
 
 }  // namespace syncer