Convert //ios from scoped_ptr to std::unique_ptr.

ios/net/http_cache_helper.cc

 // Copyright 2015 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 "ios/net/http_cache_helper.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 12 matching lines @@
 namespace {
 
 // Posts |callback| on |task_runner|.
 void PostCallback(const scoped_refptr<base::TaskRunner>& task_runner,
                   const net::CompletionCallback& callback,
                   int error) {
   task_runner->PostTask(FROM_HERE, base::Bind(callback, error));
 }
 
 // Clears the disk_cache::Backend on the IO thread and deletes |backend|.
-void DoomHttpCache(scoped_ptr<disk_cache::Backend*> backend,
+void DoomHttpCache(std::unique_ptr<disk_cache::Backend*> backend,
                    const scoped_refptr<base::TaskRunner>& client_task_runner,
                    const net::CompletionCallback& callback,
                    int error) {
   // |*backend| may be null in case of error.
   if (*backend) {
     (*backend)->DoomAllEntries(
         base::Bind(&PostCallback, client_task_runner, callback));
   } else {
     client_task_runner->PostTask(FROM_HERE, base::Bind(callback, error));
   }
@@ skipping 15 matching lines @@
 
   // Clear SDCH dictionary state.
   net::SdchManager* sdch_manager =
       getter->GetURLRequestContext()->sdch_manager();
   // The test is probably overkill, since chrome should always have an
   // SdchManager.  But in general the URLRequestContext  is *not*
   // guaranteed to have an SdchManager, so checking is wise.
   if (sdch_manager)
     sdch_manager->ClearData();
 
-  scoped_ptr<disk_cache::Backend*> backend(new disk_cache::Backend*(nullptr));
+  std::unique_ptr<disk_cache::Backend*> backend(
+      new disk_cache::Backend*(nullptr));
   disk_cache::Backend** backend_ptr = backend.get();
   net::CompletionCallback doom_callback =
       base::Bind(&DoomHttpCache, base::Passed(std::move(backend)),
                  client_task_runner, callback);
 
   int rv = http_cache->GetBackend(backend_ptr, doom_callback);
 
   if (rv != net::ERR_IO_PENDING) {
     // GetBackend doesn't call the callback if it completes synchronously, so
     // call it directly here.
     doom_callback.Run(rv);
   }
 }
 
 }  // namespace
 
 namespace net {
 
 void ClearHttpCache(const scoped_refptr<net::URLRequestContextGetter>& getter,
                     const scoped_refptr<base::TaskRunner>& network_task_runner,
                     const net::CompletionCallback& callback) {
   network_task_runner->PostTask(
       FROM_HERE, base::Bind(&ClearHttpCacheOnIOThread, getter,
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 }  // namespace net