Include base/win/scoped_comptr.h instead of base/scoped_comptr_win.h.

chrome/browser/accessibility/accessibility_win_browsertest.cc

 // Copyright (c) 2011 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/scoped_comptr_win.h"
+#include "base/win/scoped_comptr.h"
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_win.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_type.h"
 #include "ia2_api_all.h"  // Generated    NOLINT
@@ skipping 99 matching lines @@
       break;
     }
   }
 
   return NULL;
 }
 
 HRESULT QueryIAccessible2(IAccessible* accessible, IAccessible2** accessible2) {
   // TODO(ctguil): For some reason querying the IAccessible2 interface from
   // IAccessible fails.
-  ScopedComPtr<IServiceProvider> service_provider;
+  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;
 }
 
 // Sets result to true if the child is located in the parent's tree. An
 // exhustive search is perform here because we determine equality using
 // IAccessible2::get_unique_id which is only supported by the child node.
 void AccessibleContainsAccessible(
     IAccessible* parent, IAccessible2* child, bool* result) {
-  vector<ScopedComPtr<IAccessible>> accessible_list;
-  accessible_list.push_back(ScopedComPtr<IAccessible>(parent));
+  vector<base::win::ScopedComPtr<IAccessible>> accessible_list;
+  accessible_list.push_back(base::win::ScopedComPtr<IAccessible>(parent));
 
   LONG unique_id;
   HRESULT hr = child->get_uniqueID(&unique_id);
   ASSERT_EQ(S_OK, hr);
   *result = false;
 
   while (accessible_list.size()) {
-    ScopedComPtr<IAccessible> accessible = accessible_list.back();
+    base::win::ScopedComPtr<IAccessible> accessible = accessible_list.back();
     accessible_list.pop_back();
 
-    ScopedComPtr<IAccessible2> accessible2;
+    base::win::ScopedComPtr<IAccessible2> accessible2;
     hr = QueryIAccessible2(accessible, accessible2.Receive());
     if (SUCCEEDED(hr)) {
       LONG child_id;
       accessible2->get_uniqueID(&child_id);
       if (child_id == unique_id) {
         *result = true;
         break;
       }
     }
 
     LONG child_count;
     hr = accessible->get_accChildCount(&child_count);
     ASSERT_EQ(S_OK, hr);
     if (child_count == 0)
       continue;
 
     auto_ptr<VARIANT> child_array(new VARIANT[child_count]);
     LONG obtained_count = 0;
     hr = AccessibleChildren(
         accessible, 0, child_count, child_array.get(), &obtained_count);
     ASSERT_EQ(S_OK, hr);
     ASSERT_EQ(child_count, obtained_count);
 
     for (int index = 0; index < obtained_count; index++) {
-      ScopedComPtr<IAccessible> child_accessible(
+      base::win::ScopedComPtr<IAccessible> child_accessible(
         GetAccessibleFromResultVariant(accessible, &child_array.get()[index]));
-      if (child_accessible.get())
-        accessible_list.push_back(ScopedComPtr<IAccessible>(child_accessible));
+      if (child_accessible.get()) {
+        accessible_list.push_back(
+            base::win::ScopedComPtr<IAccessible>(child_accessible));
+      }
     }
   }
 }
 
 // Retrieve the MSAA client accessibility object for the Render Widget Host View
 // of the selected tab.
 IAccessible*
 AccessibilityWinBrowserTest::GetRendererAccessible() {
   HWND hwnd_render_widget_host_view =
       browser()->GetSelectedTabContents()->GetRenderWidgetHostView()->
@@ skipping 114 matching lines @@
   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) {
-    ScopedComPtr<IAccessible> child_accessible;
+    base::win::ScopedComPtr<IAccessible> child_accessible;
     child_accessible.Attach(GetAccessibleFromResultVariant(parent, child));
     ASSERT_TRUE(child_accessible.get());
     (*child_checker)->CheckAccessible(child_accessible);
   }
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestRendererAccessibilityTree) {
   // The initial accessible returned should have state STATE_SYSTEM_BUSY while
   // the accessibility tree is being requested from the renderer.
@@ skipping 23 matching lines @@
   AccessibleChecker checkbox_checker(L"", ROLE_SYSTEM_CHECKBUTTON, L"");
   AccessibleChecker body_checker(L"", L"body", L"");
   AccessibleChecker document2_checker(
     L"Accessibility Win Test", ROLE_SYSTEM_DOCUMENT, L"");
   body_checker.AppendExpectedChild(&button_checker);
   body_checker.AppendExpectedChild(&checkbox_checker);
   document2_checker.AppendExpectedChild(&body_checker);
   document2_checker.CheckAccessible(GetRendererAccessible());
 
   // Check that document accessible has a parent accessible.
-  ScopedComPtr<IAccessible> document_accessible(GetRendererAccessible());
+  base::win::ScopedComPtr<IAccessible> document_accessible(
+      GetRendererAccessible());
   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
-  ScopedComPtr<IDispatch> parent_dispatch;
+  base::win::ScopedComPtr<IDispatch> parent_dispatch;
   HRESULT hr = document_accessible->get_accParent(parent_dispatch.Receive());
   EXPECT_EQ(S_OK, hr);
   EXPECT_NE(parent_dispatch, reinterpret_cast<IDispatch*>(NULL));
 
   // Navigate to another page.
   GURL about_url("about:");
   ui_test_utils::NavigateToURL(browser(), about_url);
 
   // Verify that the IAccessible reference still points to a valid object and
   // that calls to its methods fail since the tree is no longer valid after
@@ skipping 158 matching lines @@
   ExecuteScript(L"document.body.children[0].focus()");
   ui_test_utils::WaitForNotification(
       NotificationType::RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED);
 
   // Check that the accessibility tree of the browser has been updated.
   div_checker.SetExpectedState(
       STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_READONLY | STATE_SYSTEM_FOCUSED);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Focus the document accessible. This will un-focus the current node.
-  ScopedComPtr<IAccessible> document_accessible(GetRendererAccessible());
+  base::win::ScopedComPtr<IAccessible> document_accessible(
+      GetRendererAccessible());
   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
   HRESULT hr = document_accessible->accSelect(
     SELFLAG_TAKEFOCUS, CreateI4Variant(CHILDID_SELF));
   ASSERT_EQ(S_OK, hr);
   ui_test_utils::WaitForNotification(
       NotificationType::RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED);
 
   // Check that the accessibility tree of the browser has been updated.
   div_checker.SetExpectedState(
       STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_READONLY);
@@ skipping 39 matching lines @@
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        DISABLED_ContainsRendererAccessibilityTree) {
   GURL tree_url("data:text/html,<body><input type='checkbox' /></body>");
   browser()->OpenURL(tree_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
   GetRendererAccessible();
   ui_test_utils::WaitForNotification(
       NotificationType::RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED);
 
   // Get the accessibility object for the browser window.
   HWND browser_hwnd = browser()->window()->GetNativeHandle();
-  ScopedComPtr<IAccessible> browser_accessible;
+  base::win::ScopedComPtr<IAccessible> browser_accessible;
   HRESULT hr = AccessibleObjectFromWindow(
       browser_hwnd,
       OBJID_WINDOW,
       IID_IAccessible,
       reinterpret_cast<void**>(browser_accessible.Receive()));
   ASSERT_EQ(S_OK, hr);
 
   // Get the accessibility object for the renderer client document.
-  ScopedComPtr<IAccessible> document_accessible(GetRendererAccessible());
+  base::win::ScopedComPtr<IAccessible> document_accessible(
+      GetRendererAccessible());
   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
-  ScopedComPtr<IAccessible2> document_accessible2;
+  base::win::ScopedComPtr<IAccessible2> document_accessible2;
   hr = QueryIAccessible2(document_accessible, document_accessible2.Receive());
   ASSERT_EQ(S_OK, hr);
 
   // TODO(ctguil): Pointer comparison of retrieved IAccessible pointers dosen't
   // seem to work for here. Perhaps make IAccessible2 available in views to make
   // unique id comparison available.
   bool found = false;
-  ScopedComPtr<IAccessible> parent = document_accessible;
+  base::win::ScopedComPtr<IAccessible> parent = document_accessible;
   while (parent.get()) {
-    ScopedComPtr<IDispatch> parent_dispatch;
+    base::win::ScopedComPtr<IDispatch> parent_dispatch;
     hr = parent->get_accParent(parent_dispatch.Receive());
     ASSERT_TRUE(SUCCEEDED(hr));
     if (!parent_dispatch.get()) {
       ASSERT_EQ(hr, S_FALSE);
       break;
     }
 
     parent.Release();
     hr = parent_dispatch.QueryInterface(parent.Receive());
     ASSERT_EQ(S_OK, hr);
@@ skipping 16 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        SupportsISimpleDOM) {
   GURL tree_url("data:text/html,<body><input type='checkbox' /></body>");
   browser()->OpenURL(tree_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
   GetRendererAccessible();
   ui_test_utils::WaitForNotification(
       NotificationType::RENDER_VIEW_HOST_ACCESSIBILITY_TREE_UPDATED);
 
   // Get the IAccessible object for the document.
-  ScopedComPtr<IAccessible> document_accessible(GetRendererAccessible());
+  base::win::ScopedComPtr<IAccessible> document_accessible(
+      GetRendererAccessible());
   ASSERT_NE(document_accessible.get(), reinterpret_cast<IAccessible*>(NULL));
 
   // Get the ISimpleDOM object for the document.
-  ScopedComPtr<IServiceProvider> service_provider;
+  base::win::ScopedComPtr<IServiceProvider> service_provider;
   HRESULT hr = static_cast<IAccessible*>(document_accessible)->QueryInterface(
       service_provider.Receive());
   ASSERT_EQ(S_OK, hr);
   const GUID refguid = {0x0c539790, 0x12e4, 0x11cf,
                         0xb6, 0x61, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8};
-  ScopedComPtr<ISimpleDOMNode> document_isimpledomnode;
+  base::win::ScopedComPtr<ISimpleDOMNode> document_isimpledomnode;
   hr = static_cast<IServiceProvider *>(service_provider)->QueryService(
       refguid, IID_ISimpleDOMNode,
       reinterpret_cast<void**>(document_isimpledomnode.Receive()));
   ASSERT_EQ(S_OK, hr);
 
   BSTR node_name;
   short name_space_id;  // NOLINT
   BSTR node_value;
   unsigned int num_children;
   unsigned int unique_id;
   unsigned short node_type;  // NOLINT
   hr = document_isimpledomnode->get_nodeInfo(
       &node_name, &name_space_id, &node_value, &num_children, &unique_id,
       &node_type);
   ASSERT_EQ(S_OK, hr);
   EXPECT_EQ(NODETYPE_DOCUMENT, node_type);
   EXPECT_EQ(1, num_children);
 
-  ScopedComPtr<ISimpleDOMNode> body_isimpledomnode;
+  base::win::ScopedComPtr<ISimpleDOMNode> body_isimpledomnode;
   hr = document_isimpledomnode->get_firstChild(
       body_isimpledomnode.Receive());
   ASSERT_EQ(S_OK, hr);
   hr = body_isimpledomnode->get_nodeInfo(
       &node_name, &name_space_id, &node_value, &num_children, &unique_id,
       &node_type);
   ASSERT_EQ(S_OK, hr);
   EXPECT_STREQ(L"body", wstring(node_name, SysStringLen(node_name)).c_str());
   EXPECT_EQ(NODETYPE_ELEMENT, node_type);
   EXPECT_EQ(1, num_children);
 
-  ScopedComPtr<ISimpleDOMNode> checkbox_isimpledomnode;
+  base::win::ScopedComPtr<ISimpleDOMNode> checkbox_isimpledomnode;
   hr = body_isimpledomnode->get_firstChild(
       checkbox_isimpledomnode.Receive());
   ASSERT_EQ(S_OK, hr);
   hr = checkbox_isimpledomnode->get_nodeInfo(
       &node_name, &name_space_id, &node_value, &num_children, &unique_id,
       &node_type);
   ASSERT_EQ(S_OK, hr);
   EXPECT_STREQ(L"input", wstring(node_name, SysStringLen(node_name)).c_str());
   EXPECT_EQ(NODETYPE_ELEMENT, node_type);
   EXPECT_EQ(0, num_children);
 }
 }  // namespace.