net: Append base:: in the StringPrintf calls.

net/http/partial_data.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/partial_data.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 
 namespace net {
 
 namespace {
 
 // The headers that we have to process.
 const char kLengthHeader[] = "Content-Length";
 const char kRangeHeader[] = "Content-Range";
 const int kDataStream = 1;
 
 void AddRangeHeader(int64 start, int64 end, HttpRequestHeaders* headers) {
   DCHECK(start >= 0 || end >= 0);
   std::string my_start, my_end;
   if (start >= 0)
     my_start = base::Int64ToString(start);
   if (end >= 0)
     my_end = base::Int64ToString(end);
 
   headers->SetHeader(
       HttpRequestHeaders::kRange,
-      StringPrintf("bytes=%s-%s", my_start.c_str(), my_end.c_str()));
+      base::StringPrintf("bytes=%s-%s", my_start.c_str(), my_end.c_str()));
 }
 
 }  // namespace
 
 // A core object that can be detached from the Partialdata object at destruction
 // so that asynchronous operations cleanup can be performed.
 class PartialData::Core {
  public:
   // Build a new core object. Lifetime management is automatic.
   static Core* CreateCore(PartialData* owner) {
@@ skipping 296 matching lines @@
   headers->RemoveHeader(kRangeHeader);
 
   int64 range_len;
   if (byte_range_.IsValid()) {
     if (!sparse_entry_)
       headers->ReplaceStatusLine("HTTP/1.1 206 Partial Content");
 
     DCHECK(byte_range_.HasFirstBytePosition());
     DCHECK(byte_range_.HasLastBytePosition());
     headers->AddHeader(
-        StringPrintf("%s: bytes %" PRId64 "-%" PRId64 "/%" PRId64,
-                     kRangeHeader,
-                     byte_range_.first_byte_position(),
-                     byte_range_.last_byte_position(),
-                     resource_size_));
+        base::StringPrintf("%s: bytes %" PRId64 "-%" PRId64 "/%" PRId64,
+                           kRangeHeader,
+                           byte_range_.first_byte_position(),
+                           byte_range_.last_byte_position(),
+                           resource_size_));
     range_len = byte_range_.last_byte_position() -
                 byte_range_.first_byte_position() + 1;
   } else {
     // TODO(rvargas): Is it safe to change the protocol version?
     headers->ReplaceStatusLine("HTTP/1.1 200 OK");
     DCHECK_NE(resource_size_, 0);
     range_len = resource_size_;
   }
 
-  headers->AddHeader(StringPrintf("%s: %" PRId64, kLengthHeader, range_len));
+  headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader,
+                                        range_len));
 }
 
 void PartialData::FixContentLength(HttpResponseHeaders* headers) {
   headers->RemoveHeader(kLengthHeader);
-  headers->AddHeader(StringPrintf("%s: %" PRId64, kLengthHeader,
-                                  resource_size_));
+  headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader,
+                                        resource_size_));
 }
 
 int PartialData::CacheRead(disk_cache::Entry* entry, IOBuffer* data,
                            int data_len, CompletionCallback* callback) {
   int read_len = std::min(data_len, cached_min_len_);
   if (!read_len)
     return 0;
 
   int rv = 0;
   if (sparse_entry_) {
@@ skipping 54 matching lines @@
   cached_min_len_ = result;
   if (result >= 0)
     result = 1;  // Return success, go ahead and validate the entry.
 
   CompletionCallback* cb = callback_;
   callback_ = NULL;
   cb->Run(result);
 }
 
 }  // namespace net