Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/browser_render_view_browsertest.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.
 
 // Browser tests targeted at the RenderView that run in browser context.
 // Note that these tests rely on single-process mode, and hence may be
 // disabled in some configurations (check gyp files).
 
 #include <utility>
 
@@ skipping 66 matching lines @@
   bool latest_error_stale_copy_in_cache_;
 };
 
 // Must be called on IO thread.
 void InterceptNetworkTransactions(net::URLRequestContextGetter* getter,
                                   net::Error error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::HttpCache* cache(
       getter->GetURLRequestContext()->http_transaction_factory()->GetCache());
   DCHECK(cache);
-  scoped_ptr<net::FailingHttpTransactionFactory> factory(
+  std::unique_ptr<net::FailingHttpTransactionFactory> factory(
       new net::FailingHttpTransactionFactory(cache->GetSession(), error));
   // Throw away old version; since this is a browser test, there is no
   // need to restore the old state.
   cache->SetHttpNetworkTransactionFactoryForTesting(std::move(factory));
 }
 
 void CallOnUIThreadValidatingReturn(const base::Closure& callback,
                                     int rv) {
   DCHECK_EQ(net::OK, rv);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, callback);
 }
 
 // Must be called on IO thread.  The callback will be called on
 // completion of cache clearing on the UI thread.
-void BackendClearCache(scoped_ptr<disk_cache::Backend*> backend,
+void BackendClearCache(std::unique_ptr<disk_cache::Backend*> backend,
                        const base::Closure& callback,
                        int rv) {
   DCHECK(*backend);
   DCHECK_EQ(net::OK, rv);
   (*backend)->DoomAllEntries(
       base::Bind(&CallOnUIThreadValidatingReturn, callback));
 }
 
 // Must be called on IO thread.  The callback will be called on
 // completion of cache clearing on the UI thread.
 void ClearCache(net::URLRequestContextGetter* getter,
                 const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::HttpCache* cache(
       getter->GetURLRequestContext()->http_transaction_factory()->GetCache());
   DCHECK(cache);
-  scoped_ptr<disk_cache::Backend*> backend(new disk_cache::Backend*);
+  std::unique_ptr<disk_cache::Backend*> backend(new disk_cache::Backend*);
   *backend = NULL;
   disk_cache::Backend** backend_ptr = backend.get();
 
   net::CompletionCallback backend_callback(base::Bind(
       &BackendClearCache, base::Passed(std::move(backend)), callback));
 
   // backend_ptr is valid until all copies of backend_callback go out
   // of scope.
   if (net::OK == cache->GetBackend(backend_ptr, backend_callback)) {
     // The call completed synchronously, so GetBackend didn't run the callback.
@@ skipping 103 matching lines @@
 
   error_code = net::OK;
   stale_cache_entry_present = true;
   ASSERT_TRUE(GetLatestErrorFromRendererClient(
       &error_code, &stale_cache_entry_present));
   EXPECT_EQ(net::ERR_FAILED, error_code);
   EXPECT_FALSE(stale_cache_entry_present);
 }
 
 }  // namespace content