Move EmptyString, kWhitespace and the BOM to base.

base/strings/string_util.cc

 // Copyright 2013 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/strings/string_util.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <math.h>
 #include <stdarg.h>
@@ skipping 82 matching lines @@
           // Portable, keep scanning the rest of the format string.
           in_specification = false;
         }
       }
     }
   }
 
   return true;
 }
 
-}  // namespace base
-
-
 const std::string& EmptyString() {
   return EmptyStrings::GetInstance()->s;
 }
 
 const std::wstring& EmptyWString() {
   return EmptyStrings::GetInstance()->ws;
 }
 
 const string16& EmptyString16() {
   return EmptyStrings::GetInstance()->s16;
 }
 
+}  // namespace base
+
 template<typename STR>
 bool ReplaceCharsT(const STR& input,
                    const typename STR::value_type replace_chars[],
                    const STR& replace_with,
                    STR* output) {
   bool removed = false;
   size_t replace_length = replace_with.length();
 
   *output = input;
 
@@ skipping 106 matching lines @@
       break;
     }
   }
 
   if (char_index >= 0 )
     *output = input.substr(0, char_index);
   else
     output->clear();
 }
 
-TrimPositions TrimWhitespace(const string16& input,
+TrimPositions TrimWhitespace(const base::string16& input,
                              TrimPositions positions,
-                             string16* output) {
-  return TrimStringT(input, kWhitespaceUTF16, positions, output);
+                             base::string16* output) {
+  return TrimStringT(input, base::kWhitespaceUTF16, positions, output);
 }
 
 TrimPositions TrimWhitespaceASCII(const std::string& input,
                                   TrimPositions positions,
                                   std::string* output) {
-  return TrimStringT(input, kWhitespaceASCII, positions, output);
+  return TrimStringT(input, base::kWhitespaceASCII, positions, output);
 }
 
 // This function is only for backward-compatibility.
 // To be removed when all callers are updated.
 TrimPositions TrimWhitespace(const std::string& input,
                              TrimPositions positions,
                              std::string* output) {
   return TrimWhitespaceASCII(input, positions, output);
 }
 
@@ skipping 50 matching lines @@
 }
 
 bool ContainsOnlyWhitespaceASCII(const std::string& str) {
   for (std::string::const_iterator i(str.begin()); i != str.end(); ++i) {
     if (!IsAsciiWhitespace(*i))
       return false;
   }
   return true;
 }
 
-bool ContainsOnlyWhitespace(const string16& str) {
-  return str.find_first_not_of(kWhitespaceUTF16) == string16::npos;
+bool ContainsOnlyWhitespace(const base::string16& str) {
+  return str.find_first_not_of(base::kWhitespaceUTF16) == string16::npos;
 }
 
 template<typename STR>
 static bool ContainsOnlyCharsT(const STR& input, const STR& characters) {
   for (typename STR::const_iterator iter = input.begin();
        iter != input.end(); ++iter) {
     if (characters.find(*iter) == STR::npos)
       return false;
   }
   return true;
@@ skipping 589 matching lines @@
 }
 
 }  // namespace
 
 size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
   return lcpyT<char>(dst, src, dst_size);
 }
 size_t base::wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }