Misc. cleanup:

content/browser/accessibility/accessibility_win_browsertest.cc

Index: content/browser/accessibility/accessibility_win_browsertest.cc
===================================================================
--- content/browser/accessibility/accessibility_win_browsertest.cc	(revision 194255)
+++ content/browser/accessibility/accessibility_win_browsertest.cc	(working copy)
@@ -5,7 +5,6 @@
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
-#include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
@@ -25,11 +24,6 @@
 #include "third_party/iaccessible2/ia2_api_all.h"
 #include "third_party/isimpledom/ISimpleDOMNode.h"
 
-using std::auto_ptr;
-using std::string;
-using std::vector;
-using std::wstring;
-
 // TODO(dmazzoni): Disabled accessibility tests on Win64. crbug.com/179717
 #if defined(ARCH_CPU_X86_64)
 #define MAYBE(x) DISABLED_##x
@@ -41,83 +35,12 @@
 
 namespace {
 
-class AccessibilityWinBrowserTest : public ContentBrowserTest {
- public:
-  AccessibilityWinBrowserTest() {}
 
- protected:
-  void LoadInitialAccessibilityTreeFromHtml(string html);
-  IAccessible* GetRendererAccessible();
-  void ExecuteScript(wstring script);
-};
+// Helpers --------------------------------------------------------------------
 
-class AccessibleChecker {
- public:
-  AccessibleChecker(
-      wstring expected_name,
-      int32 expected_role,
-      wstring expected_value);
-  AccessibleChecker(
-      wstring expected_name,
-      wstring expected_role,
-      int32 expected_ia2_role,
-      wstring expected_value);
-  AccessibleChecker(
-      wstring expected_name,
-      int32 expected_role,
-      int32 expected_ia2_role,
-      wstring expected_value);
-
-  // Append an AccessibleChecker that verifies accessibility information for
-  // a child IAccessible. Order is important.
-  void AppendExpectedChild(AccessibleChecker* expected_child);
-
-  // Check that the name and role of the given IAccessible instance and its
-  // descendants match the expected names and roles that this object was
-  // initialized with.
-  void CheckAccessible(IAccessible* accessible);
-
-  // Set the expected value for this AccessibleChecker.
-  void SetExpectedValue(wstring expected_value);
-
-  // Set the expected state for this AccessibleChecker.
-  void SetExpectedState(LONG expected_state);
-
- private:
-  void CheckAccessibleName(IAccessible* accessible);
-  void CheckAccessibleRole(IAccessible* accessible);
-  void CheckIA2Role(IAccessible* accessible);
-  void CheckAccessibleValue(IAccessible* accessible);
-  void CheckAccessibleState(IAccessible* accessible);
-  void CheckAccessibleChildren(IAccessible* accessible);
-  string16 RoleVariantToString(const base::win::ScopedVariant& role_variant);
-
- private:
-  typedef vector<AccessibleChecker*> AccessibleCheckerVector;
-
-  // Expected accessible name. Checked against IAccessible::get_accName.
-  wstring name_;
-
-  // Expected accessible role. Checked against IAccessible::get_accRole.
-  base::win::ScopedVariant role_;
-
-  // Expected IAccessible2 role. Checked against IAccessible2::role.
-  int32 ia2_role_;
-
-  // Expected accessible value. Checked against IAccessible::get_accValue.
-  wstring value_;
-
-  // Expected accessible state. Checked against IAccessible::get_accState.
-  LONG state_;
-
-  // Expected accessible children. Checked using IAccessible::get_accChildCount
-  // and ::AccessibleChildren.
-  AccessibleCheckerVector children_;
-};
-
 base::win::ScopedComPtr<IAccessible> GetAccessibleFromResultVariant(
     IAccessible* parent,
-    VARIANT *var) {
+    VARIANT* var) {
   base::win::ScopedComPtr<IAccessible> ptr;
   switch (V_VT(var)) {
     case VT_DISPATCH: {
@@ -144,35 +67,30 @@
   // IAccessible fails.
   base::win::ScopedComPtr<IServiceProvider> service_provider;
   HRESULT hr = accessible->QueryInterface(service_provider.Receive());
-  if (FAILED(hr))
-    return hr;
-
-  hr = service_provider->QueryService(IID_IAccessible2, accessible2);
-  return hr;
+  return SUCCEEDED(hr) ?
+      service_provider->QueryService(IID_IAccessible2, accessible2) : hr;
 }
 
 // Recursively search through all of the descendants reachable from an
 // IAccessible node and return true if we find one with the given role
 // and name.
-void RecursiveFindNodeInAccessibilityTree(
-    IAccessible* node,
-    int32 expected_role,
-    const wstring& expected_name,
-    int32 depth,
-    bool* found) {
+void RecursiveFindNodeInAccessibilityTree(IAccessible* node,
+                                          int32 expected_role,
+                                          const std::wstring& expected_name,
+                                          int32 depth,
+                                          bool* found) {
   base::win::ScopedBstr name_bstr;
   base::win::ScopedVariant childid_self(CHILDID_SELF);
   node->get_accName(childid_self, name_bstr.Receive());
-  wstring name(name_bstr, name_bstr.Length());
+  std::wstring name(name_bstr, name_bstr.Length());
   base::win::ScopedVariant role;
   node->get_accRole(childid_self, role.Receive());
   ASSERT_EQ(VT_I4, role.type());
 
   // Print the accessibility tree as we go, because if this test fails
   // on the bots, this is really helpful in figuring out why.
-  for (int i = 0; i < depth; i++) {
+  for (int i = 0; i < depth; i++)
     printf("  ");
-  }
   printf("role=%d name=%s\n", V_I4(&role), WideToUTF8(name).c_str());
 
   if (expected_role == V_I4(&role) && expected_name == name) {
@@ -204,10 +122,33 @@
   }
 }
 
+
+// AccessibilityWinBrowserTest ------------------------------------------------
+
+class AccessibilityWinBrowserTest : public ContentBrowserTest {
+ public:
+  AccessibilityWinBrowserTest();
+  virtual ~AccessibilityWinBrowserTest();
+
+ protected:
+  void LoadInitialAccessibilityTreeFromHtml(const std::string& html);
+  IAccessible* GetRendererAccessible();
+  void ExecuteScript(const std::wstring& script);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AccessibilityWinBrowserTest);
+};
+
+AccessibilityWinBrowserTest::AccessibilityWinBrowserTest() {
+}
+
+AccessibilityWinBrowserTest::~AccessibilityWinBrowserTest() {
+}
+
 void AccessibilityWinBrowserTest::LoadInitialAccessibilityTreeFromHtml(
-    string html) {
+    const std::string& html) {
   // Load the html using a data url and wait for the navigation to finish.
-  GURL html_data_url(string("data:text/html,") + html);
+  GURL html_data_url("data:text/html," + html);
   NavigateToURL(shell(), html_data_url);
 
   // At this point, renderer accessibility is off and the page has completed
@@ -229,8 +170,7 @@
 
 // Retrieve the MSAA client accessibility object for the Render Widget Host View
 // of the selected tab.
-IAccessible*
-AccessibilityWinBrowserTest::GetRendererAccessible() {
+IAccessible* AccessibilityWinBrowserTest::GetRendererAccessible() {
   HWND hwnd_render_widget_host_view =
       shell()->web_contents()->GetRenderWidgetHostView()->GetNativeView();
 
@@ -251,41 +191,106 @@
   return accessible;
 }
 
-void AccessibilityWinBrowserTest::ExecuteScript(wstring script) {
-  shell()->web_contents()->GetRenderViewHost()->
-      ExecuteJavascriptInWebFrame(L"", script);
+void AccessibilityWinBrowserTest::ExecuteScript(const std::wstring& script) {
+  shell()->web_contents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
+      std::wstring(), script);
 }
 
-// This constructor can be used if IA2 role will be the same as MSAA role
-AccessibleChecker::AccessibleChecker(
-    wstring expected_name, int32 expected_role, wstring expected_value) :
-    name_(expected_name),
-    role_(expected_role),
-    ia2_role_(expected_role),
-    value_(expected_value),
-    state_(-1) {
+
+// AccessibleChecker ----------------------------------------------------------
+
+class AccessibleChecker {
+ public:
+  // This constructor can be used if the IA2 role will be the same as the MSAA
+  // role.
+  AccessibleChecker(const std::wstring& expected_name,
+                    int32 expected_role,
+                    const std::wstring& expected_value);
+  AccessibleChecker(const std::wstring& expected_name,
+                    int32 expected_role,
+                    int32 expected_ia2_role,
+                    const std::wstring& expected_value);
+  AccessibleChecker(const std::wstring& expected_name,
+                    const std::wstring& expected_role,
+                    int32 expected_ia2_role,
+                    const std::wstring& expected_value);
+
+  // Append an AccessibleChecker that verifies accessibility information for
+  // a child IAccessible. Order is important.
+  void AppendExpectedChild(AccessibleChecker* expected_child);
+
+  // Check that the name and role of the given IAccessible instance and its
+  // descendants match the expected names and roles that this object was
+  // initialized with.
+  void CheckAccessible(IAccessible* accessible);
+
+  // Set the expected value for this AccessibleChecker.
+  void SetExpectedValue(const std::wstring& expected_value);
+
+  // Set the expected state for this AccessibleChecker.
+  void SetExpectedState(LONG expected_state);
+
+ private:
+  typedef std::vector<AccessibleChecker*> AccessibleCheckerVector;
+
+  void CheckAccessibleName(IAccessible* accessible);
+  void CheckAccessibleRole(IAccessible* accessible);
+  void CheckIA2Role(IAccessible* accessible);
+  void CheckAccessibleValue(IAccessible* accessible);
+  void CheckAccessibleState(IAccessible* accessible);
+  void CheckAccessibleChildren(IAccessible* accessible);
+  string16 RoleVariantToString(const base::win::ScopedVariant& role);
+
+  // Expected accessible name. Checked against IAccessible::get_accName.
+  std::wstring name_;
+
+  // Expected accessible role. Checked against IAccessible::get_accRole.
+  base::win::ScopedVariant role_;
+
+  // Expected IAccessible2 role. Checked against IAccessible2::role.
+  int32 ia2_role_;
+
+  // Expected accessible value. Checked against IAccessible::get_accValue.
+  std::wstring value_;
+
+  // Expected accessible state. Checked against IAccessible::get_accState.
+  LONG state_;
+
+  // Expected accessible children. Checked using IAccessible::get_accChildCount
+  // and ::AccessibleChildren.
+  AccessibleCheckerVector children_;
+};
+
+AccessibleChecker::AccessibleChecker(const std::wstring& expected_name,
+                                     int32 expected_role,
+                                     const std::wstring& expected_value)
+    : name_(expected_name),
+      role_(expected_role),
+      ia2_role_(expected_role),
+      value_(expected_value),
+      state_(-1) {
 }
 
-AccessibleChecker::AccessibleChecker(wstring expected_name,
+AccessibleChecker::AccessibleChecker(const std::wstring& expected_name,
                                      int32 expected_role,
                                      int32 expected_ia2_role,
-                                     wstring expected_value) :
-    name_(expected_name),
-    role_(expected_role),
-    ia2_role_(expected_ia2_role),
-    value_(expected_value),
-    state_(-1) {
+                                     const std::wstring& expected_value)
+    : name_(expected_name),
+      role_(expected_role),
+      ia2_role_(expected_ia2_role),
+      value_(expected_value),
+      state_(-1) {
 }
 
-AccessibleChecker::AccessibleChecker(wstring expected_name,
-                                     wstring expected_role,
+AccessibleChecker::AccessibleChecker(const std::wstring& expected_name,
+                                     const std::wstring& expected_role,
                                      int32 expected_ia2_role,
-                                     wstring expected_value) :
-    name_(expected_name),
-    role_(expected_role.c_str()),
-    ia2_role_(expected_ia2_role),
-    value_(expected_value),
-    state_(-1) {
+                                     const std::wstring& expected_value)
+    : name_(expected_name),
+      role_(expected_role.c_str()),
+      ia2_role_(expected_ia2_role),
+      value_(expected_value),
+      state_(-1) {
 }
 
 void AccessibleChecker::AppendExpectedChild(
@@ -294,9 +299,7 @@
 }
 
 void AccessibleChecker::CheckAccessible(IAccessible* accessible) {
-  SCOPED_TRACE(base::StringPrintf(
-      "while checking %s",
-      UTF16ToUTF8(RoleVariantToString(role_)).c_str()));
+  SCOPED_TRACE("while checking " + UTF16ToUTF8(RoleVariantToString(role_)));
   CheckAccessibleName(accessible);
   CheckAccessibleRole(accessible);
   CheckIA2Role(accessible);
@@ -305,7 +308,7 @@
   CheckAccessibleChildren(accessible);
 }
 
-void AccessibleChecker::SetExpectedValue(wstring expected_value) {
+void AccessibleChecker::SetExpectedValue(const std::wstring& expected_value) {
   value_ = expected_value;
 }
 
@@ -320,23 +323,22 @@
 
   if (name_.empty()) {
     // If the object doesn't have name S_FALSE should be returned.
-    EXPECT_EQ(hr, S_FALSE);
+    EXPECT_EQ(S_FALSE, hr);
   } else {
     // Test that the correct string was returned.
     EXPECT_EQ(S_OK, hr);
-    EXPECT_STREQ(name_.c_str(),
-                 wstring(name, name.Length()).c_str());
+    EXPECT_EQ(name_, std::wstring(name, name.Length()));
   }
 }
 
 void AccessibleChecker::CheckAccessibleRole(IAccessible* accessible) {
-  base::win::ScopedVariant var_role;
+  base::win::ScopedVariant role;
   base::win::ScopedVariant childid_self(CHILDID_SELF);
-  HRESULT hr = accessible->get_accRole(childid_self, var_role.Receive());
+  HRESULT hr = accessible->get_accRole(childid_self, role.Receive());
   ASSERT_EQ(S_OK, hr);
-  EXPECT_EQ(0, role_.Compare(var_role))
+  EXPECT_EQ(0, role_.Compare(role))
       << "Expected role: " << RoleVariantToString(role_)
-      << "\nGot role: " << RoleVariantToString(var_role);
+      << "\nGot role: " << RoleVariantToString(role);
 }
 
 void AccessibleChecker::CheckIA2Role(IAccessible* accessible) {
@@ -346,27 +348,21 @@
   long ia2_role = 0;
   hr = accessible2->role(&ia2_role);
   ASSERT_EQ(S_OK, hr);
-  EXPECT_EQ(ia2_role_, ia2_role);
-  if (ia2_role_ != ia2_role) {
-    LOG(ERROR) << "Expected ia2 role: " <<
-        IAccessible2RoleToString(ia2_role_);
-    LOG(ERROR) << "Got ia2 role: " <<
-        IAccessible2RoleToString(ia2_role);
-  }
+  EXPECT_EQ(ia2_role_, ia2_role)
+    << "Expected ia2 role: " << IAccessible2RoleToString(ia2_role_)
+    << "\nGot ia2 role: " << IAccessible2RoleToString(ia2_role);
 }
 
 void AccessibleChecker::CheckAccessibleValue(IAccessible* accessible) {
   // Don't check the value if if's a DOCUMENT role, because the value
   // is supposed to be the url (and we don't keep track of that in the
   // test expectations).
-  base::win::ScopedVariant var_role;
+  base::win::ScopedVariant role;
   base::win::ScopedVariant childid_self(CHILDID_SELF);
-  HRESULT hr = accessible->get_accRole(childid_self, var_role.Receive());
+  HRESULT hr = accessible->get_accRole(childid_self, role.Receive());
   ASSERT_EQ(S_OK, hr);
-  if (var_role.type() == VT_I4 &&
-      V_I4(&var_role) == ROLE_SYSTEM_DOCUMENT) {
+  if (role.type() == VT_I4 && V_I4(&role) == ROLE_SYSTEM_DOCUMENT)
     return;
-  }
 
   // Get the value.
   base::win::ScopedBstr value;
@@ -374,30 +370,26 @@
   EXPECT_EQ(S_OK, hr);
 
   // Test that the correct string was returned.
-  EXPECT_STREQ(value_.c_str(),
-               wstring(value, value.Length()).c_str());
+  EXPECT_EQ(value_, std::wstring(value, value.Length()));
 }
 
 void AccessibleChecker::CheckAccessibleState(IAccessible* accessible) {
   if (state_ < 0)
     return;
 
-  base::win::ScopedVariant var_state;
+  base::win::ScopedVariant state;
   base::win::ScopedVariant childid_self(CHILDID_SELF);
-  HRESULT hr = accessible->get_accState(childid_self, var_state.Receive());
+  HRESULT hr = accessible->get_accState(childid_self, state.Receive());
   EXPECT_EQ(S_OK, hr);
-  ASSERT_EQ(VT_I4, var_state.type());
-  LONG obj_state = V_I4(&var_state);
+  ASSERT_EQ(VT_I4, state.type());
+  LONG obj_state = V_I4(&state);
   // Avoid flakiness. The "offscreen" state depends on whether the browser
   // window is frontmost or not, and "hottracked" depends on whether the
   // mouse cursor happens to be over the element.
-  obj_state &= ~STATE_SYSTEM_OFFSCREEN;
-  obj_state &= ~STATE_SYSTEM_HOTTRACKED;
-  EXPECT_EQ(state_, obj_state);
-  if (state_ != obj_state) {
-    LOG(ERROR) << "Expected state: " << IAccessibleStateToString(state_);
-    LOG(ERROR) << "Got state: " << IAccessibleStateToString(V_I4(&var_state));
-  }
+  obj_state &= ~(STATE_SYSTEM_OFFSCREEN | STATE_SYSTEM_HOTTRACKED);
+  EXPECT_EQ(state_, obj_state)
+    << "Expected state: " << IAccessibleStateToString(state_)
+    << "\nGot state: " << IAccessibleStateToString(obj_state);
 }
 
 void AccessibleChecker::CheckAccessibleChildren(IAccessible* parent) {
@@ -406,7 +398,7 @@
   EXPECT_EQ(S_OK, hr);
   ASSERT_EQ(child_count, children_.size());
 
-  auto_ptr<VARIANT> child_array(new VARIANT[child_count]);
+  scoped_ptr<VARIANT[]> child_array(new VARIANT[child_count]);
   LONG obtained_count = 0;
   hr = AccessibleChildren(parent, 0, child_count,
                           child_array.get(), &obtained_count);
@@ -425,21 +417,27 @@
 }
 
 string16 AccessibleChecker::RoleVariantToString(
-    const base::win::ScopedVariant& role_variant) {
-  if (role_variant.type() == VT_I4)
-    return IAccessibleRoleToString(V_I4(&role_variant));
-  else if (role_variant.type() == VT_BSTR)
-    return string16(V_BSTR(&role_variant), SysStringLen(V_BSTR(&role_variant)));
+    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();
 }
 
+}  // namespace
+
+
+// Tests ----------------------------------------------------------------------
+
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        MAYBE(TestBusyAccessibilityTree)) {
   NavigateToURL(shell(), GURL(chrome::kAboutBlankURL));
 
   // The initial accessible returned should have state STATE_SYSTEM_BUSY while
   // the accessibility tree is being requested from the renderer.
-  AccessibleChecker document1_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker document1_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                      std::wstring());
   document1_checker.SetExpectedState(
       STATE_SYSTEM_READONLY | STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED |
       STATE_SYSTEM_BUSY);
@@ -455,11 +453,14 @@
       "</body></html>");
 
   // Check the browser's copy of the renderer accessibility tree.
-  AccessibleChecker button_checker(L"push", ROLE_SYSTEM_PUSHBUTTON, L"");
-  AccessibleChecker checkbox_checker(L"", ROLE_SYSTEM_CHECKBUTTON, L"");
-  AccessibleChecker body_checker(L"", L"body", IA2_ROLE_SECTION, L"");
-  AccessibleChecker document2_checker(
-      L"Accessibility Win Test", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker button_checker(L"push", ROLE_SYSTEM_PUSHBUTTON,
+                                   std::wstring());
+  AccessibleChecker checkbox_checker(std::wstring(), ROLE_SYSTEM_CHECKBUTTON,
+                                     std::wstring());
+  AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
+                                 std::wstring());
+  AccessibleChecker document2_checker(L"Accessibility Win Test",
+                                      ROLE_SYSTEM_DOCUMENT, std::wstring());
   body_checker.AppendExpectedChild(&button_checker);
   body_checker.AppendExpectedChild(&checkbox_checker);
   document2_checker.AppendExpectedChild(&body_checker);
@@ -494,15 +495,18 @@
       "<li id='li'>li</li></ul>");
 
   // Check the browser's copy of the renderer accessibility tree.
-  AccessibleChecker list_marker_checker(L"\x2022", ROLE_SYSTEM_TEXT, L"");
-  AccessibleChecker static_text_checker(L"li", ROLE_SYSTEM_TEXT, L"");
-  AccessibleChecker list_item_checker(L"", ROLE_SYSTEM_LISTITEM, L"");
-  list_item_checker.SetExpectedState(
-      STATE_SYSTEM_READONLY);
+  AccessibleChecker list_marker_checker(L"\x2022", ROLE_SYSTEM_TEXT,
+                                        std::wstring());
+  AccessibleChecker static_text_checker(L"li", ROLE_SYSTEM_TEXT,
+                                        std::wstring());
+  AccessibleChecker list_item_checker(std::wstring(), ROLE_SYSTEM_LISTITEM,
+                                      std::wstring());
+  list_item_checker.SetExpectedState(STATE_SYSTEM_READONLY);
   AccessibleChecker radio_group_checker(L"ul", ROLE_SYSTEM_GROUPING,
-      IA2_ROLE_SECTION, L"");
+                                        IA2_ROLE_SECTION, std::wstring());
   radio_group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
-  AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                     std::wstring());
   list_item_checker.AppendExpectedChild(&list_marker_checker);
   list_item_checker.AppendExpectedChild(&static_text_checker);
   radio_group_checker.AppendExpectedChild(&list_item_checker);
@@ -545,10 +549,13 @@
       "<body><input type='checkbox' /></body>");
 
   // Check the browser's copy of the renderer accessibility tree.
-  AccessibleChecker checkbox_checker(L"", ROLE_SYSTEM_CHECKBUTTON, L"");
+  AccessibleChecker checkbox_checker(std::wstring(), ROLE_SYSTEM_CHECKBUTTON,
+                                     std::wstring());
   checkbox_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
-  AccessibleChecker body_checker(L"", L"body", IA2_ROLE_SECTION, L"");
-  AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
+                                 std::wstring());
+  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                     std::wstring());
   body_checker.AppendExpectedChild(&checkbox_checker);
   document_checker.AppendExpectedChild(&body_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
@@ -575,8 +582,10 @@
   LoadInitialAccessibilityTreeFromHtml("<body role=group></body>");
 
   // Check the browser's copy of the renderer accessibility tree.
-  AccessibleChecker group_checker(L"", ROLE_SYSTEM_GROUPING, L"");
-  AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
+                                  std::wstring());
+  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                     std::wstring());
   document_checker.AppendExpectedChild(&group_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
@@ -591,7 +600,7 @@
   loop_runner->Run();
 
   // Check that the accessibility tree of the browser has been updated.
-  AccessibleChecker text_checker(L"new text", ROLE_SYSTEM_TEXT, L"");
+  AccessibleChecker text_checker(L"new text", ROLE_SYSTEM_TEXT, std::wstring());
   group_checker.AppendExpectedChild(&text_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
@@ -603,7 +612,8 @@
       "<div role=group style='visibility: hidden'>text</div>");
 
   // Check the accessible tree of the browser.
-  AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                     std::wstring());
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Change the children of the document body.
@@ -617,8 +627,10 @@
   loop_runner->Run();
 
   // Check that the accessibility tree of the browser has been updated.
-  AccessibleChecker static_text_checker(L"text", ROLE_SYSTEM_TEXT, L"");
-  AccessibleChecker group_checker(L"", ROLE_SYSTEM_GROUPING, L"");
+  AccessibleChecker static_text_checker(L"text", ROLE_SYSTEM_TEXT,
+                                        std::wstring());
+  AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
+                                  std::wstring());
   document_checker.AppendExpectedChild(&group_checker);
   group_checker.AppendExpectedChild(&static_text_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
@@ -631,9 +643,11 @@
 
   // Check the browser's copy of the renderer accessibility tree.
   SCOPED_TRACE("Check initial tree");
-  AccessibleChecker group_checker(L"", ROLE_SYSTEM_GROUPING, L"");
+  AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
+                                  std::wstring());
   group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
-  AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                     std::wstring());
   document_checker.AppendExpectedChild(&group_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
@@ -677,10 +691,13 @@
       "<body><input type='text' value='old value'/></body>");
 
   // Check the browser's copy of the renderer accessibility tree.
-  AccessibleChecker text_field_checker(L"", ROLE_SYSTEM_TEXT, L"old value");
+  AccessibleChecker text_field_checker(std::wstring(), ROLE_SYSTEM_TEXT,
+                                       L"old value");
   text_field_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
-  AccessibleChecker body_checker(L"", L"body", IA2_ROLE_SECTION, L"");
-  AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
+                                 std::wstring());
+  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                     std::wstring());
   body_checker.AppendExpectedChild(&text_field_checker);
   document_checker.AppendExpectedChild(&body_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
@@ -735,15 +752,17 @@
                        DISABLED_TestToggleButtonRoleAndStates) {
   AccessibleChecker* button_checker;
   std::string button_html("data:text/html,");
-  AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
-  AccessibleChecker body_checker(L"", L"body", IA2_ROLE_SECTION, L"");
+  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                     std::wstring());
+  AccessibleChecker body_checker(std::wstring(), L"body", IA2_ROLE_SECTION,
+                                 std::wstring());
   document_checker.AppendExpectedChild(&body_checker);
 
 // Temporary macro
 #define ADD_BUTTON(html, ia2_role, state) \
     button_html += html; \
     button_checker = new AccessibleChecker(L"x", ROLE_SYSTEM_PUSHBUTTON, \
-      ia2_role, L""); \
+      ia2_role, std::wstring()); \
     button_checker->SetExpectedState(state); \
     body_checker.AppendExpectedChild(button_checker)
 
@@ -849,7 +868,7 @@
       node_name.Receive(), &name_space_id, node_value.Receive(), &num_children,
       &unique_id, &node_type);
   ASSERT_EQ(S_OK, hr);
-  EXPECT_STREQ(L"body", wstring(node_name, node_name.Length()).c_str());
+  EXPECT_EQ(L"body", std::wstring(node_name, node_name.Length()));
   EXPECT_EQ(NODETYPE_ELEMENT, node_type);
   EXPECT_EQ(1, num_children);
   node_name.Reset();
@@ -863,7 +882,7 @@
       node_name.Receive(), &name_space_id, node_value.Receive(), &num_children,
       &unique_id, &node_type);
   ASSERT_EQ(S_OK, hr);
-  EXPECT_STREQ(L"input", wstring(node_name, node_name.Length()).c_str());
+  EXPECT_EQ(L"input", std::wstring(node_name, node_name.Length()));
   EXPECT_EQ(NODETYPE_ELEMENT, node_type);
   EXPECT_EQ(0, num_children);
 }
@@ -873,13 +892,15 @@
       "<fieldset></fieldset><div role=group></div>");
 
   // Check the browser's copy of the renderer accessibility tree.
-  AccessibleChecker grouping1_checker(L"", ROLE_SYSTEM_GROUPING, L"");
-  AccessibleChecker grouping2_checker(L"", ROLE_SYSTEM_GROUPING, L"");
-  AccessibleChecker document_checker(L"", ROLE_SYSTEM_DOCUMENT, L"");
+  AccessibleChecker grouping1_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
+                                      std::wstring());
+  AccessibleChecker grouping2_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
+                                      std::wstring());
+  AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
+                                     std::wstring());
   document_checker.AppendExpectedChild(&grouping1_checker);
   document_checker.AppendExpectedChild(&grouping2_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
-}  // namespace.
 
 }  // namespace content