Enough hacks to make wstring printfs unneeded

content/browser/accessibility/accessibility_tree_formatter_win.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 "content/browser/accessibility/accessibility_tree_formatter.h"
 
 #include <oleacc.h>
 
 #include <string>
 
@@ skipping 89 matching lines @@
       DCHECK(SUCCEEDED(hr));
       base::win::ScopedComPtr<IAccessible2> ax_embed;
       hr = embedded_object.QueryInterface(ax_embed.Receive());
       DCHECK(SUCCEEDED(hr));
       hr = ax_embed->get_indexInParent(&child_index);
       DCHECK(SUCCEEDED(hr));
     }
 
     base::string16 child_index_str(L"<obj");
     if (child_index >= 0) {
-      base::StringAppendF(&child_index_str, L"%d>", child_index);
+      /*base::StringAppendF(&child_index_str, L"%d>", child_index);*/
     } else {
-      base::StringAppendF(&child_index_str, L">");
+      /*base::StringAppendF(&child_index_str, L">");*/
     }
     base::ReplaceFirstSubstringAfterOffset(&ia2_hypertext, hypertext_index,
         embedded_character, child_index_str);
     ++character_index;
     hypertext_index += child_index_str.length();
     --number_of_embeds;
   }
   DCHECK_EQ(number_of_embeds, 0);
 
   return ia2_hypertext;
@@ skipping 178 matching lines @@
   for (int i = 0; i < arraysize(ALL_ATTRIBUTES); i++) {
     const char* attribute_name = ALL_ATTRIBUTES[i];
     const base::Value* value;
     if (!dict.Get(attribute_name, &value))
       continue;
 
     switch (value->GetType()) {
       case base::Value::TYPE_STRING: {
         base::string16 string_value;
         value->GetAsString(&string_value);
-        WriteAttribute(false,
+/*        WriteAttribute(false,

[brucedawson, 2015/10/20 21:43:00]

String printing of UTF8toUTF16(attribute_name), three times.

                        base::StringPrintf(L"%ls='%ls'",
                                     base::UTF8ToUTF16(attribute_name).c_str(),
                                     string_value.c_str()),
-                       &line);
+                       &line);*/
         break;
       }
       case base::Value::TYPE_INTEGER: {
         int int_value;
         value->GetAsInteger(&int_value);
-        WriteAttribute(false,
+        /*WriteAttribute(false,
                        base::StringPrintf(L"%ls=%d",
                                           base::UTF8ToUTF16(
                                               attribute_name).c_str(),
                                           int_value),
-                       &line);
+                       &line);*/
         break;
       }
       case base::Value::TYPE_DOUBLE: {
         double double_value;
         value->GetAsDouble(&double_value);
-        WriteAttribute(false,
+/*        WriteAttribute(false,
                        base::StringPrintf(L"%ls=%.2f",
                                           base::UTF8ToUTF16(
                                               attribute_name).c_str(),
                                           double_value),
-                       &line);
+                       &line);*/
         break;
       }
       case base::Value::TYPE_LIST: {
         // Currently all list values are string and are written without
         // attribute names.
         const base::ListValue* list_value;
         value->GetAsList(&list_value);
         for (base::ListValue::const_iterator it = list_value->begin();
              it != list_value->end();
              ++it) {
@@ skipping 50 matching lines @@
 const std::string AccessibilityTreeFormatter::GetAllowString() {
   return "@WIN-ALLOW:";
 }
 
 // static
 const std::string AccessibilityTreeFormatter::GetDenyString() {
   return "@WIN-DENY:";
 }
 
 }  // namespace content