Convert //remoting to use std::unique_ptr

remoting/protocol/http_ice_config_request_unittest.cc

 // Copyright 2016 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 "remoting/protocol/http_ice_config_request.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "remoting/base/url_request.h"
 #include "remoting/protocol/ice_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 class FakeUrlRequest : public UrlRequest {
@@ skipping 21 matching lines @@
 class FakeUrlRequestFactory : public UrlRequestFactory {
  public:
   FakeUrlRequestFactory() {}
   ~FakeUrlRequestFactory() override {}
 
   void SetResult(const std::string& url, const UrlRequest::Result& result) {
     results_[url] = result;
   }
 
   // UrlRequestFactory interface.
-  scoped_ptr<UrlRequest> CreateUrlRequest(UrlRequest::Type type,
-                                          const std::string& url) override {
+  std::unique_ptr<UrlRequest> CreateUrlRequest(
+      UrlRequest::Type type,
+      const std::string& url) override {
     EXPECT_EQ(UrlRequest::Type::POST, type);
     CHECK(results_.count(url));
-    return make_scoped_ptr(new FakeUrlRequest(results_[url]));
+    return base::WrapUnique(new FakeUrlRequest(results_[url]));
   }
 
   std::map<std::string, UrlRequest::Result> results_;
 };
 
 bool operator==(const cricket::ProtocolAddress& a,
                 const cricket::ProtocolAddress& b) {
   return a.address == b.address && a.proto == b.proto && a.secure == b.secure;
 }
 bool operator==(const cricket::RelayServerConfig& a,
                 const cricket::RelayServerConfig& b) {
   if (a.ports.size() != b.ports.size())
     return false;
   for (size_t i = 0; i < a.ports.size(); ++i) {
     if (!(a.ports[i] == b.ports[i]))
       return false;
   }
   return a.type == b.type &&
          a.credentials.username == b.credentials.username &&
          a.credentials.password == b.credentials.password;
 }
 
 }  // namespace
 
 static const char kTestUrl[] = "http://host/ice_config";
 
 class HttpIceConfigRequestTest : public testing::Test {
  public:
   void OnResult(const IceConfig& config) {
-    received_config_ = make_scoped_ptr(new IceConfig(config));
+    received_config_ = base::WrapUnique(new IceConfig(config));
   }
 
  protected:
   FakeUrlRequestFactory url_request_factory_;
-  scoped_ptr<HttpIceConfigRequest> request_;
-  scoped_ptr<IceConfig> received_config_;
+  std::unique_ptr<HttpIceConfigRequest> request_;
+  std::unique_ptr<IceConfig> received_config_;
 };
 
 TEST_F(HttpIceConfigRequestTest, Parse) {
   const char kTestResponse[] =
       "{"
       "  \"lifetimeDuration\": \"43200.000s\","
       "  \"iceServers\": ["
       "    {"
       "      \"urls\": ["
       "        \"turn:8.8.8.8:19234\","
@@ skipping 101 matching lines @@
 TEST_F(HttpIceConfigRequestTest, FailedRequest) {
   url_request_factory_.SetResult(kTestUrl, UrlRequest::Result::Failed());
   request_.reset(new HttpIceConfigRequest(&url_request_factory_, kTestUrl));
   request_->Send(
       base::Bind(&HttpIceConfigRequestTest::OnResult, base::Unretained(this)));
   EXPECT_TRUE(received_config_->is_null());
 }
 
 }  // namespace protocol
 }  // namespace remoting