Move TrimWhitespace to the base namespace.

chrome/common/net/url_fixer_upper.cc

 // Copyright (c) 2012 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 "chrome/common/net/url_fixer_upper.h"
 
 #include <algorithm>
 
 #if defined(OS_POSIX)
 #include "base/environment.h"
@@ skipping 56 matching lines @@
   parts->port =
       UTF8ComponentToUTF16Component(text_utf8, parts_utf8.port);
   parts->path =
       UTF8ComponentToUTF16Component(text_utf8, parts_utf8.path);
   parts->query =
       UTF8ComponentToUTF16Component(text_utf8, parts_utf8.query);
   parts->ref =
       UTF8ComponentToUTF16Component(text_utf8, parts_utf8.ref);
 }
 
-TrimPositions TrimWhitespaceUTF8(const std::string& input,
-                                 TrimPositions positions,
-                                 std::string* output) {
+base::TrimPositions TrimWhitespaceUTF8(const std::string& input,
+                                       base::TrimPositions positions,
+                                       std::string* output) {
   // This implementation is not so fast since it converts the text encoding
   // twice. Please feel free to file a bug if this function hurts the
   // performance of Chrome.
   DCHECK(IsStringUTF8(input));
   base::string16 input16 = base::UTF8ToUTF16(input);
   base::string16 output16;
-  TrimPositions result = TrimWhitespace(input16, positions, &output16);
+  base::TrimPositions result =
+      base::TrimWhitespace(input16, positions, &output16);
   *output = base::UTF16ToUTF8(output16);
   return result;
 }
 
 // does some basic fixes for input that we want to test for file-ness
 void PrepareStringForFileOps(const base::FilePath& text,
                              base::FilePath::StringType* output) {
 #if defined(OS_WIN)
-  TrimWhitespace(text.value(), TRIM_ALL, output);
+  base::TrimWhitespace(text.value(), base::TRIM_ALL, output);
   replace(output->begin(), output->end(), '/', '\\');
 #else
-  TrimWhitespaceUTF8(text.value(), TRIM_ALL, output);
+  TrimWhitespaceUTF8(text.value(), base::TRIM_ALL, output);
 #endif
 }
 
 // Tries to create a full path from |text|.  If the result is valid and the
 // file exists, returns true and sets |full_path| to the result.  Otherwise,
 // returns false and leaves |full_path| unchanged.
 bool ValidPathForFile(const base::FilePath::StringType& text,
                       base::FilePath* full_path) {
   base::FilePath file_path = base::MakeAbsoluteFilePath(base::FilePath(text));
   if (file_path.empty())
@@ skipping 273 matching lines @@
 }
 
 // Performs the work for URLFixerUpper::SegmentURL. |text| may be modified on
 // output on success: a semicolon following a valid scheme is replaced with a
 // colon.
 std::string SegmentURLInternal(std::string* text, url_parse::Parsed* parts) {
   // Initialize the result.
   *parts = url_parse::Parsed();
 
   std::string trimmed;
-  TrimWhitespaceUTF8(*text, TRIM_ALL, &trimmed);
+  TrimWhitespaceUTF8(*text, base::TRIM_ALL, &trimmed);
   if (trimmed.empty())
     return std::string();  // Nothing to segment.
 
 #if defined(OS_WIN)
   int trimmed_length = static_cast<int>(trimmed.length());
   if (url_parse::DoesBeginWindowsDriveSpec(trimmed.data(), 0, trimmed_length) ||
       url_parse::DoesBeginUNCPath(trimmed.data(), 0, trimmed_length, true))
     return "file";
 #elif defined(OS_POSIX)
   if (base::FilePath::IsSeparator(trimmed.data()[0]) ||
@@ skipping 91 matching lines @@
   std::string text_utf8 = base::UTF16ToUTF8(text);
   url_parse::Parsed parts_utf8;
   std::string scheme_utf8 = SegmentURL(text_utf8, &parts_utf8);
   UTF8PartsToUTF16Parts(text_utf8, parts_utf8, parts);
   return base::UTF8ToUTF16(scheme_utf8);
 }
 
 GURL URLFixerUpper::FixupURL(const std::string& text,
                              const std::string& desired_tld) {
   std::string trimmed;
-  TrimWhitespaceUTF8(text, TRIM_ALL, &trimmed);
+  TrimWhitespaceUTF8(text, base::TRIM_ALL, &trimmed);
   if (trimmed.empty())
     return GURL();  // Nothing here.
 
   // Segment the URL.
   url_parse::Parsed parts;
   std::string scheme(SegmentURLInternal(&trimmed, &parts));
 
   // For view-source: URLs, we strip "view-source:", do fixup, and stick it back
   // on.  This allows us to handle things like "view-source:google.com".
   if (scheme == content::kViewSourceScheme) {
@@ skipping 128 matching lines @@
 
   if (part->is_valid()) {
     // Offset the location of this component.
     part->begin += offset;
 
     // This part might not have existed in the original text.
     if (part->begin < 0)
       part->reset();
   }
 }