Move the number conversions from string_util to a new file....

net/http/http_network_transaction.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/http/http_network_transaction.h"
 
 #include <set>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/format_macros.h"
 #include "base/histogram.h"
 #include "base/scoped_ptr.h"
 #include "base/stats_counters.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
+#include "base/string_number_conversions.h"
 #include "build/build_config.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_connection_status_flags.h"
@@ skipping 615 matching lines @@
                            request_->url.EffectiveIntPort());
 
   // Extra URL we might be attempting to resolve to.
   GURL alternate_endpoint_url;
 
   // Tracks whether we are using |request_->url| or |alternate_endpoint_url|.
   const GURL *curr_endpoint_url = &request_->url;
 
   if (g_host_mapping_rules && g_host_mapping_rules->RewriteHost(&endpoint_)) {
     url_canon::Replacements<char> replacements;
-    const std::string port_str = IntToString(endpoint_.port());
+    const std::string port_str = base::IntToString(endpoint_.port());
     replacements.SetPort(port_str.c_str(),
                          url_parse::Component(0, port_str.size()));
     replacements.SetHost(endpoint_.host().c_str(),
                          url_parse::Component(0, endpoint_.host().size()));
     alternate_endpoint_url = curr_endpoint_url->ReplaceComponents(replacements);
     curr_endpoint_url = &alternate_endpoint_url;
   }
 
   const HttpAlternateProtocols& alternate_protocols =
       session_->alternate_protocols();
   if (alternate_protocols.HasAlternateProtocolFor(endpoint_)) {
     response_.was_alternate_protocol_available = true;
     if (alternate_protocol_mode_ == kUnspecified) {
       HttpAlternateProtocols::PortProtocolPair alternate =
           alternate_protocols.GetAlternateProtocolFor(endpoint_);
       if (alternate.protocol != HttpAlternateProtocols::BROKEN) {
         DCHECK_LE(HttpAlternateProtocols::NPN_SPDY_1, alternate.protocol);
         DCHECK_GT(HttpAlternateProtocols::NUM_ALTERNATE_PROTOCOLS,
                   alternate.protocol);
         endpoint_.set_port(alternate.port);
         alternate_protocol_ = alternate.protocol;
         alternate_protocol_mode_ = kUsingAlternateProtocol;
 
         url_canon::Replacements<char> replacements;
         replacements.SetScheme("https",
                                url_parse::Component(0, strlen("https")));
-        const std::string port_str = IntToString(endpoint_.port());
+        const std::string port_str = base::IntToString(endpoint_.port());
         replacements.SetPort(port_str.c_str(),
                              url_parse::Component(0, port_str.size()));
         alternate_endpoint_url =
             curr_endpoint_url->ReplaceComponents(replacements);
         curr_endpoint_url = &alternate_endpoint_url;
       }
     }
   }
 
   if (request_->load_flags & LOAD_BYPASS_PROXY) {
@@ skipping 1138 matching lines @@
     default:
       description = StringPrintf("Unknown state 0x%08X (%u)", state, state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net