[net] Change factory methods for HostResolver and HostCache to return a scoped_ptr

net/base/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/base/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 417 matching lines @@
     void DeleteResolver() { test->resolver_.reset(); }
 
     HostResolverImplTest* test;
   };
 
   void CreateResolver() {
     resolver_.reset(new HostResolverImpl(
         HostCache::CreateDefaultCache(),
         DefaultLimits(),
         DefaultParams(proc_),
-        scoped_ptr<DnsClient>(NULL),
+        scoped_ptr<DnsClient>(),
         NULL));
   }
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time and
   // perform no retries.
   void CreateSerialResolver() {
     HostResolverImpl::ProcTaskParams params = DefaultParams(proc_);
     params.max_retry_attempts = 0u;
     PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
     resolver_.reset(new HostResolverImpl(
         HostCache::CreateDefaultCache(),
         limits,
         params,
-        scoped_ptr<DnsClient>(NULL),
+        scoped_ptr<DnsClient>(),
         NULL));
   }
 
   // The Request will not be made until a call to |Resolve()|, and the Job will
   // not start until released by |proc_->SignalXXX|.
   Request* CreateRequest(const HostResolver::RequestInfo& info) {
     Request* req = new Request(info, requests_.size(), resolver_.get(),
                                handler_.get());
     requests_.push_back(req);
     return req;
@@ skipping 288 matching lines @@
         // 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(
-      NULL,
+      scoped_ptr<HostCache>(),
       DefaultLimits(),
       DefaultParams(proc_),
-      scoped_ptr<DnsClient>(NULL),
+      scoped_ptr<DnsClient>(),
       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());
@@ skipping 416 matching lines @@
 
   // Specify smaller interval for unresponsive_delay_ for HostResolverImpl so
   // that unit test runs faster. For example, this test finishes in 1.5 secs
   // (500ms * 3).
   params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
 
   resolver_.reset(
       new HostResolverImpl(HostCache::CreateDefaultCache(),
                            DefaultLimits(),
                            params,
-                           scoped_ptr<DnsClient>(NULL),
+                           scoped_ptr<DnsClient>(),
                            NULL));
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   Request* req = CreateRequest(info);
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
 
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   EXPECT_EQ(-4, req->WaitForResult());
 
@@ skipping 198 matching lines @@
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 0; i < 2; ++i)
     EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[i]->WaitForResult()) << i;
 
   for (size_t i = 2; i < requests_.size(); ++i)
     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
 }
 
 }  // namespace net