Convert string16 to base::string16 in content.

content/browser/accessibility/accessibility_tree_formatter.h

 // 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.
 
 #ifndef CONTENT_BROWSER_ACCESSIBILITY_ACCESSIBILITY_TREE_FORMATTER_H_
 #define CONTENT_BROWSER_ACCESSIBILITY_ACCESSIBILITY_TREE_FORMATTER_H_
 
 #include <vector>
 
 #include "base/files/file_path.h"
@@ skipping 34 matching lines @@
   //     "children": [ ]
   //   }, {
   //     "AXName": "child name 2",
   //     /* ... more attributes */
   //     "children": [ ]
   //   } ]
   // }
   scoped_ptr<base::DictionaryValue> BuildAccessibilityTree();
 
   // Dumps a BrowserAccessibility tree into a string.
-  void FormatAccessibilityTree(string16* contents);
+  void FormatAccessibilityTree(base::string16* contents);
 
   // A single filter specification. See GetAllowString() and GetDenyString()
   // for more information.
   struct Filter {
     enum Type {
       ALLOW,
       ALLOW_EMPTY,
       DENY
     };
-    string16 match_str;
+    base::string16 match_str;
     Type type;
 
-    Filter(string16 match_str, Type type)
+    Filter(base::string16 match_str, Type type)
         : match_str(match_str), type(type) {}
   };
 
   // Set regular expression filters that apply to each component of every
   // line before it's output.
   void SetFilters(const std::vector<Filter>& filters);
 
   // Suffix of the expectation file corresponding to html file.
   // Example:
   // HTML test:      test-file.html
@@ skipping 14 matching lines @@
   // @MAC-ALLOW:roleDescription*
   // @MAC-DENY:subrole*
   // -->
   // <p>Text</p>
   static const std::string GetAllowEmptyString();
   static const std::string GetAllowString();
   static const std::string GetDenyString();
 
  protected:
   void RecursiveFormatAccessibilityTree(const BrowserAccessibility& node,
-                                        string16* contents,
+                                        base::string16* contents,
                                         int indent);
   void RecursiveBuildAccessibilityTree(const BrowserAccessibility& node,
                                        base::DictionaryValue* tree_node);
   void RecursiveFormatAccessibilityTree(const base::DictionaryValue& tree_node,
-                                        string16* contents,
+                                        base::string16* contents,
                                         int depth = 0);
 
   // Overridden by each platform to add the required attributes for each node
   // into the given dict.
   void AddProperties(const BrowserAccessibility& node,
                      base::DictionaryValue* dict);
 
-  string16 FormatCoordinates(const char* name,
-                             const char* x_name,
-                             const char* y_name,
-                             const base::DictionaryValue& value);
+  base::string16 FormatCoordinates(const char* name,
+                                   const char* x_name,
+                                   const char* y_name,
+                                   const base::DictionaryValue& value);
 
   // Returns a platform specific representation of a BrowserAccessibility.
   // Should be zero or more complete lines, each with |prefix| prepended
   // (to indent each line).
-  string16 ToString(const base::DictionaryValue& node, const string16& indent);
+  base::string16 ToString(const base::DictionaryValue& node,
+                          const base::string16& indent);
 
   void Initialize();
 
-  bool MatchesFilters(const string16& text, bool default_result) const;
+  bool MatchesFilters(const base::string16& text, bool default_result) const;
 
   // Writes the given attribute string out to |line| if it matches the filters.
   void WriteAttribute(bool include_by_default,
-                      const string16& attr,
-                      string16* line);
+                      const base::string16& attr,
+                      base::string16* line);
   void WriteAttribute(bool include_by_default,
                       const std::string& attr,
-                      string16* line);
+                      base::string16* line);
 
   BrowserAccessibility* root_;
 
   // Filters used when formatting the accessibility tree as text.
   std::vector<Filter> filters_;
 
   DISALLOW_COPY_AND_ASSIGN(AccessibilityTreeFormatter);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_ACCESSIBILITY_ACCESSIBILITY_TREE_FORMATTER_H_