Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

net/dns/host_resolver_impl_unittest.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/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 418 matching lines @@
       return test->CreateRequest(hostname);
     }
     ScopedVector<Request>& requests() { return test->requests_; }
 
     void DeleteResolver() { test->resolver_.reset(); }
 
     HostResolverImplTest* test;
   };
 
   void CreateResolver() {
-    resolver_.reset(new HostResolverImpl(
-        HostCache::CreateDefaultCache(),
-        DefaultLimits(),
-        DefaultParams(proc_),
-        NULL));
+    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
+                                         DefaultLimits(),
+                                         DefaultParams(proc_.get()),
+                                         NULL));
   }
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time and
   // perform no retries.
   void CreateSerialResolver() {
-    HostResolverImpl::ProcTaskParams params = DefaultParams(proc_);
+    HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get());
     params.max_retry_attempts = 0u;
     PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
     resolver_.reset(new HostResolverImpl(
         HostCache::CreateDefaultCache(),
         limits,
         params,
         NULL));
   }
 
   // The Request will not be made until a call to |Resolve()|, and the Job will
@@ skipping 314 matching lines @@
       if (req->index() == 0) {
         // On completing the first request, start another request for "a".
         // Since caching is disabled, this will result in another async request.
         EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 70)->Resolve());
       }
     }
   };
   set_handler(new MyHandler());
 
   // Turn off caching for this host resolver.
-  resolver_.reset(new HostResolverImpl(
-      scoped_ptr<HostCache>(),
-      DefaultLimits(),
-      DefaultParams(proc_),
-      NULL));
+  resolver_.reset(new HostResolverImpl(scoped_ptr<HostCache>(),
+                                       DefaultLimits(),
+                                       DefaultParams(proc_.get()),
+                                       NULL));
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(2u);  // One for "a". One for the second "a".
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   ASSERT_EQ(5u, requests_.size());
   EXPECT_EQ(OK, requests_.back()->WaitForResult());
@@ skipping 464 matching lines @@
     AddDnsRule("4ok", dns_protocol::kTypeA, MockDnsClientRule::OK);
     AddDnsRule("4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY);
     AddDnsRule("6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY);
     AddDnsRule("6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK);
     AddDnsRule("4nx", dns_protocol::kTypeA, MockDnsClientRule::OK);
     AddDnsRule("4nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL_ASYNC);
     CreateResolver();
   }
 
   void CreateResolver() {
-    resolver_.reset(new HostResolverImpl(
-        HostCache::CreateDefaultCache(),
-        DefaultLimits(),
-        DefaultParams(proc_),
-        NULL));
+    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
+                                         DefaultLimits(),
+                                         DefaultParams(proc_.get()),
+                                         NULL));
     resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_));
   }
 
   // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
   void AddDnsRule(const std::string& prefix,
                   uint16 qtype,
                   MockDnsClientRule::Result result) {
     dns_rules_.push_back(MockDnsClientRule(prefix, qtype, result));
   }
 
@@ skipping 219 matching lines @@
 }
 
 // Confirm that resolving "localhost" is unrestricted even if there are no
 // global IPv6 address. See SystemHostResolverCall for rationale.
 // Test both the DnsClient and system host resolver paths.
 TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   // Use regular SystemHostResolverCall!
   scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc());
   resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
                                        DefaultLimits(),
-                                       DefaultParams(proc),
+                                       DefaultParams(proc.get()),
                                        NULL));
   resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_));
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
   // Get the expected output.
   AddressList addrlist;
   int rv = proc->Resolve("localhost", ADDRESS_FAMILY_UNSPECIFIED, 0, &addrlist,
                          NULL);
   if (rv != OK)
     return;
@@ skipping 35 matching lines @@
   ChangeDnsConfig(config);
   req = CreateRequest(info);
   // Expect synchronous resolution from DnsHosts.
   EXPECT_EQ(OK, req->Resolve());
 
   EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80));
   EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80));
 }
 
 }  // namespace net