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

content/browser/resolve_proxy_msg_helper_unittest.cc

 // Copyright (c) 2011 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 "content/browser/resolve_proxy_msg_helper.h"
 
+#include "base/memory/ptr_util.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/common/view_messages.h"
 #include "ipc/ipc_test_sink.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ skipping 36 matching lines @@
         : result(result), proxy_list(proxy_list) {
     }
 
     bool result;
     std::string proxy_list;
   };
 
   ResolveProxyMsgHelperTest()
       : resolver_factory_(new net::MockAsyncProxyResolverFactory(false)),
         service_(
-            new net::ProxyService(make_scoped_ptr(new MockProxyConfigService),
-                                  make_scoped_ptr(resolver_factory_),
+            new net::ProxyService(base::WrapUnique(new MockProxyConfigService),
+                                  base::WrapUnique(resolver_factory_),
                                   NULL)),
         helper_(new TestResolveProxyMsgHelper(service_.get(), this)),
         io_thread_(BrowserThread::IO, &message_loop_) {
     test_sink_.AddFilter(this);
   }
 
  protected:
   const PendingResult* pending_result() const { return pending_result_.get(); }
 
   void clear_pending_result() {
     pending_result_.reset();
   }
 
   IPC::Message* GenerateReply() {
     bool temp_bool;
     std::string temp_string;
     ViewHostMsg_ResolveProxy message(GURL(), &temp_bool, &temp_string);
     return IPC::SyncMessage::GenerateReply(&message);
   }
 
   net::MockAsyncProxyResolverFactory* resolver_factory_;
   net::MockAsyncProxyResolver resolver_;
-  scoped_ptr<net::ProxyService> service_;
+  std::unique_ptr<net::ProxyService> service_;
   scoped_refptr<ResolveProxyMsgHelper> helper_;
-  scoped_ptr<PendingResult> pending_result_;
+  std::unique_ptr<PendingResult> pending_result_;
 
  private:
   bool OnMessageReceived(const IPC::Message& msg) override {
     ViewHostMsg_ResolveProxy::ReplyParam reply_data;
     EXPECT_TRUE(ViewHostMsg_ResolveProxy::ReadReplyParam(&msg, &reply_data));
     DCHECK(!pending_result_.get());
     pending_result_.reset(
         new PendingResult(base::get<0>(reply_data), base::get<1>(reply_data)));
     test_sink_.ClearMessages();
     return true;
@@ skipping 156 matching lines @@
 
   EXPECT_EQ(0u, resolver_.pending_requests().size());
 
   EXPECT_TRUE(pending_result() == NULL);
 
   // It should also be the case that msg1, msg2, msg3 were deleted by the
   // cancellation. (Else will show up as a leak in Valgrind).
 }
 
 }  // namespace content