Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/network.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 14 matching lines @@
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/win32.h"
 #include <Iphlpapi.h>
 #elif !defined(__native_client__)
 #include "webrtc/base/ifaddrs_converter.h"
 #endif
 
 #include <stdio.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/networkmonitor.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socket.h"  // includes something that makes windows happy
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 namespace {
 
 // Turning on IPv6 could make many IPv6 interfaces available for connectivity
 // check and delay the call setup time. kMaxIPv6Networks is the default upper
@@ skipping 415 matching lines @@
       } else if (network_monitor_) {
         adapter_type = network_monitor_->GetAdapterType(cursor->ifa_name);
       }
 #if defined(WEBRTC_IOS)
       // Cell networks are pdp_ipN on iOS.
       if (strncmp(cursor->ifa_name, "pdp_ip", 6) == 0) {
         adapter_type = ADAPTER_TYPE_CELLULAR;
       }
 #endif
       // TODO(phoglund): Need to recognize other types as well.
-      scoped_ptr<Network> network(new Network(cursor->ifa_name,
-                                              cursor->ifa_name, prefix,
-                                              prefix_length, adapter_type));
+      std::unique_ptr<Network> network(
+          new Network(cursor->ifa_name, cursor->ifa_name, prefix, prefix_length,
+                      adapter_type));
       network->set_default_local_address_provider(this);
       network->set_scope_id(scope_id);
       network->AddIP(ip);
       network->set_ignored(IsIgnoredNetwork(*network));
       if (include_ignored || !network->ignored()) {
         current_networks[key] = network.get();
         networks->push_back(network.release());
       }
     } else {
       (*existing_network).second->AddIP(ip);
     }
   }
 }
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
                                          NetworkList* networks) const {
   struct ifaddrs* interfaces;
   int error = getifaddrs(&interfaces);
   if (error != 0) {
     LOG_ERR(LERROR) << "getifaddrs failed to gather interface data: " << error;
     return false;
   }
 
-  rtc::scoped_ptr<IfAddrsConverter> ifaddrs_converter(CreateIfAddrsConverter());
+  std::unique_ptr<IfAddrsConverter> ifaddrs_converter(CreateIfAddrsConverter());
   ConvertIfAddrs(interfaces, ifaddrs_converter.get(), include_ignored,
                  networks);
 
   freeifaddrs(interfaces);
   return true;
 }
 
 #elif defined(WEBRTC_WIN)
 
 unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist,
@@ skipping 35 matching lines @@
   }
   *prefix = best_prefix;
   return best_length;
 }
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
                                          NetworkList* networks) const {
   NetworkMap current_networks;
   // MSDN recommends a 15KB buffer for the first try at GetAdaptersAddresses.
   size_t buffer_size = 16384;
-  scoped_ptr<char[]> adapter_info(new char[buffer_size]);
+  std::unique_ptr<char[]> adapter_info(new char[buffer_size]);
   PIP_ADAPTER_ADDRESSES adapter_addrs =
       reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
   int adapter_flags = (GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_ANYCAST |
                        GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_INCLUDE_PREFIX);
   int ret = 0;
   do {
     adapter_info.reset(new char[buffer_size]);
     adapter_addrs = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
     ret = GetAdaptersAddresses(AF_UNSPEC, adapter_flags,
                                0, adapter_addrs,
@@ skipping 15 matching lines @@
 #endif
       description = ToUtf8(adapter_addrs->Description,
                            wcslen(adapter_addrs->Description));
       for (; address; address = address->Next) {
 #if defined(NDEBUG)
         name = rtc::ToString(count);
 #endif
 
         IPAddress ip;
         int scope_id = 0;
-        scoped_ptr<Network> network;
+        std::unique_ptr<Network> network;
         switch (address->Address.lpSockaddr->sa_family) {
           case AF_INET: {
             sockaddr_in* v4_addr =
                 reinterpret_cast<sockaddr_in*>(address->Address.lpSockaddr);
             ip = IPAddress(v4_addr->sin_addr);
             break;
           }
           case AF_INET6: {
             if (ipv6_enabled()) {
               sockaddr_in6* v6_addr =
@@ skipping 18 matching lines @@
         IPAddress prefix;
         int prefix_length = GetPrefix(prefixlist, ip, &prefix);
         std::string key = MakeNetworkKey(name, prefix, prefix_length);
         auto existing_network = current_networks.find(key);
         if (existing_network == current_networks.end()) {
           AdapterType adapter_type = ADAPTER_TYPE_UNKNOWN;
           if (adapter_addrs->IfType == IF_TYPE_SOFTWARE_LOOPBACK) {
             // TODO(phoglund): Need to recognize other types as well.
             adapter_type = ADAPTER_TYPE_LOOPBACK;
           }
-          scoped_ptr<Network> network(new Network(name, description, prefix,
-                                                  prefix_length, adapter_type));
+          std::unique_ptr<Network> network(new Network(
+              name, description, prefix, prefix_length, adapter_type));
           network->set_default_local_address_provider(this);
           network->set_scope_id(scope_id);
           network->AddIP(ip);
           bool ignored = IsIgnoredNetwork(*network);
           network->set_ignored(ignored);
           if (include_ignored || !network->ignored()) {
             current_networks[key] = network.get();
             networks->push_back(network.release());
           }
         } else {
@@ skipping 142 matching lines @@
     default:
       ASSERT(false);
   }
 }
 
 IPAddress BasicNetworkManager::QueryDefaultLocalAddress(int family) const {
   ASSERT(thread_ == Thread::Current());
   ASSERT(thread_->socketserver() != nullptr);
   ASSERT(family == AF_INET || family == AF_INET6);
 
-  scoped_ptr<AsyncSocket> socket(
+  std::unique_ptr<AsyncSocket> socket(
       thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
   if (!socket) {
     LOG_ERR(LERROR) << "Socket creation failed";
     return IPAddress();
   }
 
   if (socket->Connect(SocketAddress(
           family == AF_INET ? kPublicIPv4Host : kPublicIPv6Host, kPublicPort)) <
       0) {
     LOG(LS_INFO) << "Connect failed with " << socket->GetError();
@@ skipping 132 matching lines @@
   std::stringstream ss;
   // Print out the first space-terminated token of the network desc, plus
   // the IP address.
   ss << "Net[" << description_.substr(0, description_.find(' '))
      << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
      << ":" << AdapterTypeToString(type_) << "]";
   return ss.str();
 }
 
 }  // namespace rtc