Convert string16 to base::string16 in content.

BUG=

Review URL: https://codereview.chromium.org/102593002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@238447 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/accessibility/accessibility_tree_formatter.cc

@@ -55,7 +55,7 @@ AccessibilityTreeFormatter::BuildAccessibilityTree() {
 }
 
 void AccessibilityTreeFormatter::FormatAccessibilityTree(
-    string16* contents) {
+    base::string16* contents) {
   scoped_ptr<base::DictionaryValue> dict = BuildAccessibilityTree();
   RecursiveFormatAccessibilityTree(*(dict.get()), contents);
 }
@@ -76,9 +76,10 @@ void AccessibilityTreeFormatter::RecursiveBuildAccessibilityTree(
 }
 
 void AccessibilityTreeFormatter::RecursiveFormatAccessibilityTree(
-    const base::DictionaryValue& dict, string16* contents, int depth) {
-  string16 line = ToString(dict, string16(depth * kIndentSpaces, ' '));
-  if (line.find(ASCIIToUTF16(kSkipString)) != string16::npos)
+    const base::DictionaryValue& dict, base::string16* contents, int depth) {
+  base::string16 line =
+      ToString(dict, base::string16(depth * kIndentSpaces, ' '));
+  if (line.find(ASCIIToUTF16(kSkipString)) != base::string16::npos)
     return;
 
   *contents += line;
@@ -98,8 +99,9 @@ void AccessibilityTreeFormatter::AddProperties(const BrowserAccessibility& node,
   dict->SetInteger("id", node.renderer_id());
 }
 
-string16 AccessibilityTreeFormatter::ToString(const base::DictionaryValue& node,
-                                              const string16& indent) {
+base::string16 AccessibilityTreeFormatter::ToString(
+    const base::DictionaryValue& node,
+    const base::string16& indent) {
   int id_value;
   node.GetInteger("id", &id_value);
   return indent + base::IntToString16(id_value) +
@@ -142,7 +144,7 @@ void AccessibilityTreeFormatter::SetFilters(
 }
 
 bool AccessibilityTreeFormatter::MatchesFilters(
-    const string16& text, bool default_result) const {
+    const base::string16& text, bool default_result) const {
   std::vector<Filter>::const_iterator iter = filters_.begin();
   bool allow = default_result;
   for (iter = filters_.begin(); iter != filters_.end(); ++iter) {
@@ -158,7 +160,7 @@ bool AccessibilityTreeFormatter::MatchesFilters(
   return allow;
 }
 
-string16 AccessibilityTreeFormatter::FormatCoordinates(
+base::string16 AccessibilityTreeFormatter::FormatCoordinates(
     const char* name, const char* x_name, const char* y_name,
     const base::DictionaryValue& value) {
   int x, y;
@@ -170,12 +172,12 @@ string16 AccessibilityTreeFormatter::FormatCoordinates(
 }
 
 void AccessibilityTreeFormatter::WriteAttribute(
-    bool include_by_default, const std::string& attr, string16* line) {
+    bool include_by_default, const std::string& attr, base::string16* line) {
   WriteAttribute(include_by_default, UTF8ToUTF16(attr), line);
 }
 
 void AccessibilityTreeFormatter::WriteAttribute(
-    bool include_by_default, const string16& attr, string16* line) {
+    bool include_by_default, const base::string16& attr, base::string16* line) {
   if (attr.empty())
     return;
   if (!MatchesFilters(attr, include_by_default))

content/browser/accessibility/accessibility_tree_formatter.h

@@ -52,7 +52,7 @@ class CONTENT_EXPORT AccessibilityTreeFormatter {
   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.
@@ -62,10 +62,10 @@ class CONTENT_EXPORT AccessibilityTreeFormatter {
       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) {}
   };
 
@@ -100,40 +100,41 @@ class CONTENT_EXPORT AccessibilityTreeFormatter {
 
  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_;
 

content/browser/accessibility/accessibility_tree_formatter_android.cc

@@ -77,11 +77,12 @@ void AccessibilityTreeFormatter::AddProperties(
   dict->SetInteger("item_count", android_node->GetItemCount());
 }
 
-string16 AccessibilityTreeFormatter::ToString(const DictionaryValue& dict,
-                                              const string16& indent) {
-  string16 line;
+base::string16 AccessibilityTreeFormatter::ToString(
+    const DictionaryValue& dict,
+    const base::string16& indent) {
+  base::string16 line;
 
-  string16 class_value;
+  base::string16 class_value;
   dict.GetString("class", &class_value);
   WriteAttribute(true, UTF16ToUTF8(class_value), &line);
 

content/browser/accessibility/accessibility_tree_formatter_gtk.cc

@@ -37,9 +37,10 @@ void AccessibilityTreeFormatter::AddProperties(const BrowserAccessibility& node,
   dict->SetInteger("id", node.renderer_id());
 }
 
-string16 AccessibilityTreeFormatter::ToString(const base::DictionaryValue& node,
-                                              const string16& indent) {
-  string16 line;
+base::string16 AccessibilityTreeFormatter::ToString(
+    const base::DictionaryValue& node,
+    const base::string16& indent) {
+  base::string16 line;
   std::string role_value;
   node.GetString("role", &role_value);
   if (!role_value.empty())

content/browser/accessibility/accessibility_tree_formatter_mac.mm

@@ -161,9 +161,10 @@ bool IsRangeValue(id value) {
   dict->Set(kSizeDictAttr, PopulateSize(cocoa_node).release());
 }
 
-string16 AccessibilityTreeFormatter::ToString(const base::DictionaryValue& dict,
-                                              const string16& indent) {
-  string16 line;
+base::string16 AccessibilityTreeFormatter::ToString(
+    const base::DictionaryValue& dict,
+    const base::string16& indent) {
+  base::string16 line;
   NSArray* defaultAttributes =
       [NSArray arrayWithObjects:NSAccessibilityTitleAttribute,
                                 NSAccessibilityValueAttribute,

content/browser/accessibility/accessibility_tree_formatter_utils_win.cc

@@ -20,10 +20,10 @@ class AccessibilityRoleStateMap {
  public:
   static AccessibilityRoleStateMap* GetInstance();
 
-  std::map<int32, string16> ia_role_string_map;
-  std::map<int32, string16> ia2_role_string_map;
-  std::map<int32, string16> ia_state_string_map;
-  std::map<int32, string16> ia2_state_string_map;
+  std::map<int32, base::string16> ia_role_string_map;
+  std::map<int32, base::string16> ia2_role_string_map;
+  std::map<int32, base::string16> ia_state_string_map;
+  std::map<int32, base::string16> ia2_state_string_map;
 
  private:
   AccessibilityRoleStateMap();
@@ -220,44 +220,44 @@ AccessibilityRoleStateMap::AccessibilityRoleStateMap() {
 
 }  // namespace.
 
-string16 IAccessibleRoleToString(int32 ia_role) {
+base::string16 IAccessibleRoleToString(int32 ia_role) {
   return AccessibilityRoleStateMap::GetInstance()->ia_role_string_map[ia_role];
 }
 
-string16 IAccessible2RoleToString(int32 ia_role) {
+base::string16 IAccessible2RoleToString(int32 ia_role) {
   return AccessibilityRoleStateMap::GetInstance()->ia2_role_string_map[ia_role];
 }
 
 void IAccessibleStateToStringVector(int32 ia_state,
-                                    std::vector<string16>* result) {
-  const std::map<int32, string16>& state_string_map =
+                                    std::vector<base::string16>* result) {
+  const std::map<int32, base::string16>& state_string_map =
       AccessibilityRoleStateMap::GetInstance()->ia_state_string_map;
-  std::map<int32, string16>::const_iterator it;
+  std::map<int32, base::string16>::const_iterator it;
   for (it = state_string_map.begin(); it != state_string_map.end(); ++it) {
     if (it->first & ia_state)
       result->push_back(it->second);
   }
 }
 
-string16 IAccessibleStateToString(int32 ia_state) {
-  std::vector<string16> strings;
+base::string16 IAccessibleStateToString(int32 ia_state) {
+  std::vector<base::string16> strings;
   IAccessibleStateToStringVector(ia_state, &strings);
   return JoinString(strings, ',');
 }
 
 void IAccessible2StateToStringVector(int32 ia2_state,
-                                     std::vector<string16>* result) {
-  const std::map<int32, string16>& state_string_map =
+                                     std::vector<base::string16>* result) {
+  const std::map<int32, base::string16>& state_string_map =
       AccessibilityRoleStateMap::GetInstance()->ia2_state_string_map;
-  std::map<int32, string16>::const_iterator it;
+  std::map<int32, base::string16>::const_iterator it;
   for (it = state_string_map.begin(); it != state_string_map.end(); ++it) {
     if (it->first & ia2_state)
       result->push_back(it->second);
   }
 }
 
-string16 IAccessible2StateToString(int32 ia2_state) {
-  std::vector<string16> strings;
+base::string16 IAccessible2StateToString(int32 ia2_state) {
+  std::vector<base::string16> strings;
   IAccessible2StateToStringVector(ia2_state, &strings);
   return JoinString(strings, ',');
 }

content/browser/accessibility/accessibility_tree_formatter_utils_win.h

@@ -13,14 +13,14 @@
 
 namespace content {
 
-CONTENT_EXPORT string16 IAccessibleRoleToString(int32 ia_role);
-CONTENT_EXPORT string16 IAccessible2RoleToString(int32 ia_role);
-CONTENT_EXPORT string16 IAccessibleStateToString(int32 ia_state);
+CONTENT_EXPORT base::string16 IAccessibleRoleToString(int32 ia_role);
+CONTENT_EXPORT base::string16 IAccessible2RoleToString(int32 ia_role);
+CONTENT_EXPORT base::string16 IAccessibleStateToString(int32 ia_state);
 CONTENT_EXPORT void IAccessibleStateToStringVector(
-    int32 ia_state, std::vector<string16>* result);
-CONTENT_EXPORT string16 IAccessible2StateToString(int32 ia2_state);
+    int32 ia_state, std::vector<base::string16>* result);
+CONTENT_EXPORT base::string16 IAccessible2StateToString(int32 ia2_state);
 CONTENT_EXPORT void IAccessible2StateToStringVector(
-  int32 ia_state, std::vector<string16>* result);
+  int32 ia_state, std::vector<base::string16>* result);
 
 }  // namespace content
 

content/browser/accessibility/accessibility_tree_formatter_win.cc

@@ -76,7 +76,7 @@ void AccessibilityTreeFormatter::AddProperties(
   if (hresult == S_OK)
     dict->SetString("value", msaa_variant.m_str);
 
-  std::vector<string16> state_strings;
+  std::vector<base::string16> state_strings;
   int32 ia_state = acc_obj->ia_state();
 
   // Avoid flakiness: these states depend on whether the window is focused
@@ -87,16 +87,16 @@ void AccessibilityTreeFormatter::AddProperties(
   IAccessibleStateToStringVector(ia_state, &state_strings);
   IAccessible2StateToStringVector(acc_obj->ia2_state(), &state_strings);
   base::ListValue* states = new base::ListValue;
-  for (std::vector<string16>::const_iterator it = state_strings.begin();
+  for (std::vector<base::string16>::const_iterator it = state_strings.begin();
        it != state_strings.end();
        ++it) {
     states->AppendString(UTF16ToUTF8(*it));
   }
   dict->Set("states", states);
 
-  const std::vector<string16>& ia2_attributes = acc_obj->ia2_attributes();
+  const std::vector<base::string16>& ia2_attributes = acc_obj->ia2_attributes();
   base::ListValue* attributes = new base::ListValue;
-  for (std::vector<string16>::const_iterator it = ia2_attributes.begin();
+  for (std::vector<base::string16>::const_iterator it = ia2_attributes.begin();
        it != ia2_attributes.end();
        ++it) {
     attributes->AppendString(UTF16ToUTF8(*it));
@@ -199,15 +199,16 @@ void AccessibilityTreeFormatter::AddProperties(
   }
 }
 
-string16 AccessibilityTreeFormatter::ToString(const base::DictionaryValue& dict,
-                                              const string16& indent) {
-  string16 line;
+base::string16 AccessibilityTreeFormatter::ToString(
+    const base::DictionaryValue& dict,
+    const base::string16& indent) {
+  base::string16 line;
 
-  string16 role_value;
+  base::string16 role_value;
   dict.GetString("role", &role_value);
   WriteAttribute(true, UTF16ToUTF8(role_value), &line);
 
-  string16 name_value;
+  base::string16 name_value;
   dict.GetString("name", &name_value);
   WriteAttribute(true, base::StringPrintf(L"name='%ls'", name_value.c_str()),
                  &line);
@@ -220,7 +221,7 @@ string16 AccessibilityTreeFormatter::ToString(const base::DictionaryValue& dict,
 
     switch (value->GetType()) {
       case base::Value::TYPE_STRING: {
-        string16 string_value;
+        base::string16 string_value;
         value->GetAsString(&string_value);
         WriteAttribute(false,
                        StringPrintf(L"%ls='%ls'",
@@ -257,7 +258,7 @@ string16 AccessibilityTreeFormatter::ToString(const base::DictionaryValue& dict,
         for (base::ListValue::const_iterator it = list_value->begin();
              it != list_value->end();
              ++it) {
-          string16 string_value;
+          base::string16 string_value;
           if ((*it)->GetAsString(&string_value))
             WriteAttribute(false, string_value, &line);
         }

content/browser/accessibility/accessibility_ui.cc

@@ -233,7 +233,7 @@ void AccessibilityUI::RequestAccessibilityTree(const base::ListValue* args) {
   }
   scoped_ptr<AccessibilityTreeFormatter> formatter(
       AccessibilityTreeFormatter::Create(rvh));
-  string16 accessibility_contents_utf16;
+  base::string16 accessibility_contents_utf16;
   BrowserAccessibilityManager* manager =
       host_view->GetBrowserAccessibilityManager();
   if (!manager) {

content/browser/accessibility/accessibility_win_browsertest.cc

@@ -226,7 +226,7 @@ class AccessibleChecker {
   void CheckAccessibleValue(IAccessible* accessible);
   void CheckAccessibleState(IAccessible* accessible);
   void CheckAccessibleChildren(IAccessible* accessible);
-  string16 RoleVariantToString(const base::win::ScopedVariant& role);
+  base::string16 RoleVariantToString(const base::win::ScopedVariant& role);
 
   // Expected accessible name. Checked against IAccessible::get_accName.
   std::wstring name_;
@@ -403,13 +403,13 @@ void AccessibleChecker::CheckAccessibleChildren(IAccessible* parent) {
   }
 }
 
-string16 AccessibleChecker::RoleVariantToString(
+base::string16 AccessibleChecker::RoleVariantToString(
     const base::win::ScopedVariant& role) {
   if (role.type() == VT_I4)
     return IAccessibleRoleToString(V_I4(&role));
   if (role.type() == VT_BSTR)
-    return string16(V_BSTR(&role), SysStringLen(V_BSTR(&role)));
-  return string16();
+    return base::string16(V_BSTR(&role), SysStringLen(V_BSTR(&role)));
+  return base::string16();
 }
 
 }  // namespace