Remove ScopedVector from address_sorter_posix

net/dns/address_sorter_posix.cc

 // Copyright (c) 2012 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 "net/dns/address_sorter_posix.h"
 
 #include <netinet/in.h>
 
+#include <vector>

[mmenke, 2015/12/11 14:32:49]

I think this should go down with <algorithm>  (Include order is a bit weird
because of the sys/socket.h include order requirements)

+
+#include "base/memory/scoped_ptr.h"

[mmenke, 2015/12/11 14:32:49]

I think these should go just above logging.h

+
 #if defined(OS_MACOSX) || defined(OS_BSD)
 #include <sys/socket.h>  // Must be included before ifaddrs.h.
 #include <ifaddrs.h>
 #include <net/if.h>
 #include <netinet/in_var.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #endif
 
 #include <algorithm>
 
 #include "base/logging.h"
-#include "base/memory/scoped_vector.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/udp/datagram_client_socket.h"
 
 #if defined(OS_LINUX)
 #include "net/base/address_tracker_linux.h"
 #endif
 
 namespace net {
 
@@ skipping 147 matching lines @@
   IPAddressNumber address;
   AddressSorterPosix::AddressScope scope;
   unsigned precedence;
   unsigned label;
   const AddressSorterPosix::SourceAddressInfo* src;
   unsigned common_prefix_length;
 };
 
 // Returns true iff |dst_a| should precede |dst_b| in the address list.
 // RFC 3484, section 6.
-bool CompareDestinations(const DestinationInfo* dst_a,
-                         const DestinationInfo* dst_b) {
+bool CompareDestinations(const scoped_ptr<DestinationInfo>& dst_a,
+                         const scoped_ptr<DestinationInfo>& dst_b) {
   // Rule 1: Avoid unusable destinations.
   // Unusable destinations are already filtered out.
   DCHECK(dst_a->src);
   DCHECK(dst_b->src);
 
   // Rule 2: Prefer matching scope.
   bool scope_match1 = (dst_a->src->scope == dst_a->scope);
   bool scope_match2 = (dst_b->src->scope == dst_b->scope);
   if (scope_match1 != scope_match2)
     return scope_match1;
@@ skipping 49 matching lines @@
   OnIPAddressChanged();
 }
 
 AddressSorterPosix::~AddressSorterPosix() {
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void AddressSorterPosix::Sort(const AddressList& list,
                               const CallbackType& callback) const {
   DCHECK(CalledOnValidThread());
-  ScopedVector<DestinationInfo> sort_list;
+  std::vector<scoped_ptr<DestinationInfo>> sort_list;
 
   for (size_t i = 0; i < list.size(); ++i) {
     scoped_ptr<DestinationInfo> info(new DestinationInfo());
     info->address = list[i].address();
     info->scope = GetScope(ipv4_scope_table_, info->address);
     info->precedence = GetPolicyValue(precedence_table_, info->address);
     info->label = GetPolicyValue(label_table_, info->address);
 
     // Each socket can only be bound once.
     scoped_ptr<DatagramClientSocket> socket(
@@ skipping 122 matching lines @@
 }
 
 // static
 scoped_ptr<AddressSorter> AddressSorter::CreateAddressSorter() {
   return scoped_ptr<AddressSorter>(
       new AddressSorterPosix(ClientSocketFactory::GetDefaultFactory()));
 }
 
 }  // namespace net