Move StringPiece into the base namespace. It is colliding

base/string_util.cc

 // Copyright (c) 2006-2008 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 "base/string_util.h"
 
 #include "build/build_config.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ skipping 488 matching lines @@
 std::string CollapseWhitespaceASCII(const std::string& text,
                                     bool trim_sequences_with_line_breaks) {
   return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
 }
 
 std::string WideToASCII(const std::wstring& wide) {
   DCHECK(IsStringASCII(wide)) << wide;
   return std::string(wide.begin(), wide.end());
 }
 
-std::wstring ASCIIToWide(const StringPiece& ascii) {
+std::wstring ASCIIToWide(const base::StringPiece& ascii) {
   DCHECK(IsStringASCII(ascii)) << ascii;
   return std::wstring(ascii.begin(), ascii.end());
 }
 
 std::string UTF16ToASCII(const string16& utf16) {
   DCHECK(IsStringASCII(utf16)) << utf16;
   return std::string(utf16.begin(), utf16.end());
 }
 
-string16 ASCIIToUTF16(const StringPiece& ascii) {
+string16 ASCIIToUTF16(const base::StringPiece& ascii) {
   DCHECK(IsStringASCII(ascii)) << ascii;
   return string16(ascii.begin(), ascii.end());
 }
 
 // Latin1 is just the low range of Unicode, so we can copy directly to convert.
 bool WideToLatin1(const std::wstring& wide, std::string* latin1) {
   std::string output;
   output.resize(wide.size());
   latin1->clear();
   for (size_t i = 0; i < wide.size(); i++) {
@@ skipping 26 matching lines @@
 bool IsStringASCII(const std::wstring& str) {
   return DoIsStringASCII(str);
 }
 
 #if !defined(WCHAR_T_IS_UTF16)
 bool IsStringASCII(const string16& str) {
   return DoIsStringASCII(str);
 }
 #endif
 
-bool IsStringASCII(const StringPiece& str) {
+bool IsStringASCII(const base::StringPiece& str) {
   return DoIsStringASCII(str);
 }
 
 // Helper functions that determine whether the given character begins a
 // UTF-8 sequence of bytes with the given length. A character satisfies
 // "IsInUTF8Sequence" if it is anything but the first byte in a multi-byte
 // character.
 static inline bool IsBegin2ByteUTF8(int c) {
   return (c & 0xE0) == 0xC0;
 }
@@ skipping 161 matching lines @@
                           const char* a_end,
                           const char* b) {
   return DoLowerCaseEqualsASCII(a_begin, a_end, b);
 }
 bool LowerCaseEqualsASCII(const wchar_t* a_begin,
                           const wchar_t* a_end,
                           const char* b) {
   return DoLowerCaseEqualsASCII(a_begin, a_end, b);
 }
 
-bool EqualsASCII(const string16& a, const StringPiece& b) {
+bool EqualsASCII(const string16& a, const base::StringPiece& b) {
   if (a.length() != b.length())
     return false;
   return std::equal(b.begin(), b.end(), a.begin());
 }
 
 bool StartsWithASCII(const std::string& str,
                      const std::string& search,
                      bool case_sensitive) {
   if (case_sensitive)
     return str.compare(0, search.length(), search) == 0;
@@ skipping 922 matching lines @@
   // Each input byte creates two output hex characters.
   std::string ret(size * 2, '\0');
 
   for (size_t i = 0; i < size; ++i) {
     char b = reinterpret_cast<const char*>(bytes)[i];
     ret[(i * 2)] = kHexChars[(b >> 4) & 0xf];
     ret[(i * 2) + 1] = kHexChars[b & 0xf];
   }
   return ret;
 }