Move remaining content test code into the content namespace.

chrome/browser/accessibility/accessibility_win_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 <atlbase.h>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 332 matching lines @@
 
 void AccessibleChecker::CheckIA2Role(IAccessible* accessible) {
   base::win::ScopedComPtr<IAccessible2> accessible2;
   HRESULT hr = QueryIAccessible2(accessible, accessible2.Receive());
   ASSERT_EQ(S_OK, hr);
   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);
+    LOG(ERROR) << "Expected ia2 role: " <<
+        content::IAccessible2RoleToString(ia2_role_);
+    LOG(ERROR) << "Got ia2 role: " <<
+        content::IAccessible2RoleToString(ia2_role);
   }
 }
 
 void AccessibleChecker::CheckAccessibleValue(IAccessible* accessible) {
   CComBSTR value;
   HRESULT hr =
       accessible->get_accValue(CreateI4Variant(CHILDID_SELF), &value);
   EXPECT_EQ(S_OK, hr);
 
   // Test that the correct string was returned.
   EXPECT_STREQ(value_.c_str(),
                wstring(value.m_str, SysStringLen(value)).c_str());
 }
 
 void AccessibleChecker::CheckAccessibleState(IAccessible* accessible) {
   if (state_ < 0)
     return;
 
   VARIANT var_state = {0};
   HRESULT hr =
       accessible->get_accState(CreateI4Variant(CHILDID_SELF), &var_state);
   EXPECT_EQ(S_OK, hr);
   ASSERT_EQ(VT_I4, V_VT(&var_state));
   EXPECT_EQ(state_, V_I4(&var_state));
   if (state_ != V_I4(&var_state)) {
-    LOG(ERROR) << "Expected state: " << IAccessibleStateToString(state_);
-    LOG(ERROR) << "Got state: " << IAccessibleStateToString(V_I4(&var_state));
+    LOG(ERROR) << "Expected state: " <<
+        content::IAccessibleStateToString(state_);
+    LOG(ERROR) << "Got state: " <<
+        content::IAccessibleStateToString(V_I4(&var_state));
   }
 }
 
 void AccessibleChecker::CheckAccessibleChildren(IAccessible* parent) {
   LONG child_count = 0;
   HRESULT hr = parent->get_accChildCount(&child_count);
   EXPECT_EQ(S_OK, hr);
   ASSERT_EQ(child_count, children_.size());
 
   auto_ptr<VARIANT> child_array(new VARIANT[child_count]);
   LONG obtained_count = 0;
   hr = AccessibleChildren(parent, 0, child_count,
                           child_array.get(), &obtained_count);
   ASSERT_EQ(S_OK, hr);
   ASSERT_EQ(child_count, obtained_count);
 
   VARIANT* child = child_array.get();
   for (AccessibleCheckerVector::iterator child_checker = children_.begin();
        child_checker != children_.end();
        ++child_checker, ++child) {
     base::win::ScopedComPtr<IAccessible> child_accessible;
     child_accessible.Attach(GetAccessibleFromResultVariant(parent, child));
     ASSERT_TRUE(child_accessible.get());
     (*child_checker)->CheckAccessible(child_accessible);
   }
 }
 
 string16 AccessibleChecker::RoleVariantToString(VARIANT* role_variant) {
   if (V_VT(role_variant) == VT_I4)
-    return IAccessibleRoleToString(V_I4(role_variant));
+    return content::IAccessibleRoleToString(V_I4(role_variant));
   else if (V_VT(role_variant) == VT_BSTR)
     return string16(V_BSTR(role_variant), SysStringLen(V_BSTR(role_variant)));
   return string16();
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestBusyAccessibilityTree) {
   // 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"");
@@ skipping 408 matching lines @@
 
   // 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"");
   document_checker.AppendExpectedChild(&grouping1_checker);
   document_checker.AppendExpectedChild(&grouping2_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 }  // namespace.