Update uses of UTF conversions in content/ to use the base:: namespace.

content/browser/accessibility/dump_accessibility_tree_browsertest.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 <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 70 matching lines @@
         diff_lines.push_back(j);
       ++i;
       ++j;
     }
 
     // Actual file has been fully checked.
     return diff_lines;
   }
 
   void AddDefaultFilters(std::vector<Filter>* filters) {
-    filters->push_back(Filter(ASCIIToUTF16("FOCUSABLE"), Filter::ALLOW));
-    filters->push_back(Filter(ASCIIToUTF16("READONLY"), Filter::ALLOW));
-    filters->push_back(Filter(ASCIIToUTF16("*=''"), Filter::DENY));
+    filters->push_back(Filter(base::ASCIIToUTF16("FOCUSABLE"), Filter::ALLOW));
+    filters->push_back(Filter(base::ASCIIToUTF16("READONLY"), Filter::ALLOW));
+    filters->push_back(Filter(base::ASCIIToUTF16("*=''"), Filter::DENY));
   }
 
   void ParseFilters(const std::string& test_html,
                     std::vector<Filter>* filters) {
     std::vector<std::string> lines;
     base::SplitString(test_html, '\n', &lines);
     for (std::vector<std::string>::const_iterator iter = lines.begin();
          iter != lines.end();
          ++iter) {
       const std::string& line = *iter;
       const std::string& allow_empty_str =
           AccessibilityTreeFormatter::GetAllowEmptyString();
       const std::string& allow_str =
           AccessibilityTreeFormatter::GetAllowString();
       const std::string& deny_str =
           AccessibilityTreeFormatter::GetDenyString();
       if (StartsWithASCII(line, allow_empty_str, true)) {
         filters->push_back(
-          Filter(UTF8ToUTF16(line.substr(allow_empty_str.size())),
+          Filter(base::UTF8ToUTF16(line.substr(allow_empty_str.size())),
                  Filter::ALLOW_EMPTY));
       } else if (StartsWithASCII(line, allow_str, true)) {
-        filters->push_back(Filter(UTF8ToUTF16(line.substr(allow_str.size())),
+        filters->push_back(Filter(base::UTF8ToUTF16(
+                                      line.substr(allow_str.size())),
                                   Filter::ALLOW));
       } else if (StartsWithASCII(line, deny_str, true)) {
-        filters->push_back(Filter(UTF8ToUTF16(line.substr(deny_str.size())),
+        filters->push_back(Filter(base::UTF8ToUTF16(
+                                      line.substr(deny_str.size())),
                                   Filter::DENY));
       }
     }
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     ContentBrowserTest::SetUpCommandLine(command_line);
     // Enable <dialog>, which is used in some tests.
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
@@ skipping 34 matching lines @@
   std::string expected_contents;
   base::RemoveChars(expected_contents_raw, "\r", &expected_contents);
 
   if (!expected_contents.compare(0, strlen(kMarkSkipFile), kMarkSkipFile)) {
     printf("Skipping this test on this platform.\n");
     return;
   }
 
   // Load the page.
   base::string16 html_contents16;
-  html_contents16 = UTF8ToUTF16(html_contents);
+  html_contents16 = base::UTF8ToUTF16(html_contents);
   GURL url = GetTestUrl("accessibility",
                         html_file.BaseName().MaybeAsASCII().c_str());
   AccessibilityNotificationWaiter waiter(
       shell(), AccessibilityModeComplete,
       blink::WebAXEventLoadComplete);
   NavigateToURL(shell(), url);
   waiter.WaitForNotification();
 
   RenderWidgetHostViewPort* host_view = RenderWidgetHostViewPort::FromRWHV(
       shell()->web_contents()->GetRenderWidgetHostView());
   AccessibilityTreeFormatter formatter(
       host_view->GetBrowserAccessibilityManager()->GetRoot());
 
   // Parse filters in the test file.
   std::vector<Filter> filters;
   AddDefaultFilters(&filters);
   ParseFilters(html_contents, &filters);
   formatter.SetFilters(filters);
 
   // Perform a diff (or write the initial baseline).
   base::string16 actual_contents_utf16;
   formatter.FormatAccessibilityTree(&actual_contents_utf16);
-  std::string actual_contents = UTF16ToUTF8(actual_contents_utf16);
+  std::string actual_contents = base::UTF16ToUTF8(actual_contents_utf16);
   std::vector<std::string> actual_lines, expected_lines;
   Tokenize(actual_contents, "\n", &actual_lines);
   Tokenize(expected_contents, "\n", &expected_lines);
   // Marking the end of the file with a line of text ensures that
   // file length differences are found.
   expected_lines.push_back(kMarkEndOfFile);
   actual_lines.push_back(kMarkEndOfFile);
 
   std::vector<int> diff_lines = DiffLines(expected_lines, actual_lines);
   bool is_different = diff_lines.size() > 0;
@@ skipping 282 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityUl) {
   RunTest(FILE_PATH_LITERAL("ul.html"));
 }
 
 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityWbr) {
   RunTest(FILE_PATH_LITERAL("wbr.html"));
 }
 
 }  // namespace content