Convert implicit scoped_refptr constructor calls to explicit ones, part 2

net/proxy/proxy_bypass_rules.cc

 // Copyright (c) 2010 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/proxy/proxy_bypass_rules.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "net/base/net_util.h"
@@ skipping 153 matching lines @@
     const std::string& raw) {
   ParseFromStringInternal(raw, true);
 }
 
 bool ProxyBypassRules::AddRuleForHostname(const std::string& optional_scheme,
                                           const std::string& hostname_pattern,
                                           int optional_port) {
   if (hostname_pattern.empty())
     return false;
 
-  rules_.push_back(new HostnamePatternRule(optional_scheme,
-                                           hostname_pattern,
-                                           optional_port));
+  rules_.push_back(make_scoped_refptr(new HostnamePatternRule(optional_scheme,
+                                                              hostname_pattern,
+                                                              optional_port)));
   return true;
 }
 
 void ProxyBypassRules::AddRuleToBypassLocal() {
-  rules_.push_back(new BypassLocalRule);
+  rules_.push_back(make_scoped_refptr(new BypassLocalRule));
 }
 
 bool ProxyBypassRules::AddRuleFromString(const std::string& raw) {
   return AddRuleFromStringInternalWithLogging(raw, false);
 }
 
 bool ProxyBypassRules::AddRuleFromStringUsingSuffixMatching(
     const std::string& raw) {
   return AddRuleFromStringInternalWithLogging(raw, true);
 }
@@ skipping 42 matching lines @@
 
   // If there is a forward slash in the input, it is probably a CIDR style
   // mask.
   if (raw.find('/') != std::string::npos) {
     IPAddressNumber ip_prefix;
     size_t prefix_length_in_bits;
 
     if (!ParseCIDRBlock(raw, &ip_prefix, &prefix_length_in_bits))
       return false;
 
-    rules_.push_back(
-        new BypassIPBlockRule(raw, scheme, ip_prefix, prefix_length_in_bits));
+    rules_.push_back(make_scoped_refptr(
+        new BypassIPBlockRule(raw, scheme, ip_prefix, prefix_length_in_bits)));
 
     return true;
   }
 
   // Check if we have an <ip-address>[:port] input. We need to treat this
   // separately since the IP literal may not be in a canonical form.
   std::string host;
   int port;
   if (ParseHostAndPort(raw, &host, &port)) {
     if (IsIPAddress(host)) {
@@ skipping 28 matching lines @@
   return AddRuleForHostname(scheme, raw, port);
 }
 
 bool ProxyBypassRules::AddRuleFromStringInternalWithLogging(
     const std::string& raw,
     bool use_hostname_suffix_matching) {
   return AddRuleFromStringInternal(raw, use_hostname_suffix_matching);
 }
 
 }  // namespace net