Convert //content/browser from scoped_ptr to std::unique_ptr

content/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 <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_variant.h"
 #include "content/browser/accessibility/accessibility_mode_helper.h"
 #include "content/browser/accessibility/accessibility_tree_formatter.h"
 #include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
 #include "content/browser/accessibility/browser_accessibility_win.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
@@ skipping 338 matching lines @@
 
 std::vector<base::win::ScopedVariant>
 AccessibilityWinBrowserTest::GetAllAccessibleChildren(
     IAccessible* element) {
   LONG child_count = 0;
   HRESULT hr = element->get_accChildCount(&child_count);
   EXPECT_EQ(S_OK, hr);
   if (child_count <= 0)
       return std::vector<base::win::ScopedVariant>();
 
-  scoped_ptr<VARIANT[]> children_array(new VARIANT[child_count]);
+  std::unique_ptr<VARIANT[]> children_array(new VARIANT[child_count]);
   LONG obtained_count = 0;
   hr = AccessibleChildren(
       element, 0, child_count, children_array.get(), &obtained_count);
   EXPECT_EQ(S_OK, hr);
   EXPECT_EQ(child_count, obtained_count);
 
   std::vector<base::win::ScopedVariant> children(
       static_cast<size_t>(child_count));
   for (size_t i = 0; i < children.size(); i++) {
     children[i].Reset(children_array[i]);
@@ skipping 279 matching lines @@
   radio_group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   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);
   document_checker.AppendExpectedChild(&radio_group_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Set focus to the radio group.
-  scoped_ptr<AccessibilityNotificationWaiter> waiter(
-      new AccessibilityNotificationWaiter(
-          shell(), AccessibilityModeComplete,
-          ui::AX_EVENT_FOCUS));
+  std::unique_ptr<AccessibilityNotificationWaiter> waiter(
+      new AccessibilityNotificationWaiter(shell(), AccessibilityModeComplete,
+                                          ui::AX_EVENT_FOCUS));
   ExecuteScript(L"document.body.children[0].focus()");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   radio_group_checker.SetExpectedState(
       STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Set the active descendant of the radio group
   waiter.reset(new AccessibilityNotificationWaiter(
@@ skipping 21 matching lines @@
   checkbox_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   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());
 
   // Check the checkbox.
-  scoped_ptr<AccessibilityNotificationWaiter> waiter(
-      new AccessibilityNotificationWaiter(
-          shell(), AccessibilityModeComplete,
-          ui::AX_EVENT_CHECKED_STATE_CHANGED));
+  std::unique_ptr<AccessibilityNotificationWaiter> waiter(
+      new AccessibilityNotificationWaiter(shell(), AccessibilityModeComplete,
+                                          ui::AX_EVENT_CHECKED_STATE_CHANGED));
   ExecuteScript(L"document.body.children[0].checked=true");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   checkbox_checker.SetExpectedState(
       STATE_SYSTEM_CHECKED | STATE_SYSTEM_FOCUSABLE);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestNotificationChildrenChanged) {
   // The role attribute causes the node to be in the accessibility tree.
   LoadInitialAccessibilityTreeFromHtml("<body role=group></body>");
 
   // Check the browser's copy of the renderer accessibility tree.
   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());
 
   // Change the children of the document body.
-  scoped_ptr<AccessibilityNotificationWaiter> waiter(
-      new AccessibilityNotificationWaiter(
-          shell(),
-          AccessibilityModeComplete,
-          ui::AX_EVENT_CHILDREN_CHANGED));
+  std::unique_ptr<AccessibilityNotificationWaiter> waiter(
+      new AccessibilityNotificationWaiter(shell(), AccessibilityModeComplete,
+                                          ui::AX_EVENT_CHILDREN_CHANGED));
   ExecuteScript(L"document.body.innerHTML='<b>new text</b>'");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   AccessibleChecker text_checker(
       L"new text", ROLE_SYSTEM_STATICTEXT, std::wstring());
   group_checker.AppendExpectedChild(&text_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestNotificationChildrenChanged2) {
   // The role attribute causes the node to be in the accessibility tree.
   LoadInitialAccessibilityTreeFromHtml(
       "<div role=group style='visibility: hidden'>text</div>");
 
   // Check the accessible tree of the browser.
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Change the children of the document body.
-  scoped_ptr<AccessibilityNotificationWaiter> waiter(
-      new AccessibilityNotificationWaiter(
-          shell(), AccessibilityModeComplete,
-          ui::AX_EVENT_CHILDREN_CHANGED));
+  std::unique_ptr<AccessibilityNotificationWaiter> waiter(
+      new AccessibilityNotificationWaiter(shell(), AccessibilityModeComplete,
+                                          ui::AX_EVENT_CHILDREN_CHANGED));
   ExecuteScript(L"document.body.children[0].style.visibility='visible'");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   AccessibleChecker static_text_checker(L"text", ROLE_SYSTEM_STATICTEXT,
                                         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());
 }
 
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestNotificationFocusChanged) {
   // The role attribute causes the node to be in the accessibility tree.
   LoadInitialAccessibilityTreeFromHtml("<div role=group tabindex='-1'></div>");
 
   // Check the browser's copy of the renderer accessibility tree.
   SCOPED_TRACE("Check initial tree");
   AccessibleChecker group_checker(std::wstring(), ROLE_SYSTEM_GROUPING,
                                   std::wstring());
   group_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   AccessibleChecker document_checker(std::wstring(), ROLE_SYSTEM_DOCUMENT,
                                      std::wstring());
   document_checker.AppendExpectedChild(&group_checker);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Focus the div in the document
-  scoped_ptr<AccessibilityNotificationWaiter> waiter(
-      new AccessibilityNotificationWaiter(
-          shell(), AccessibilityModeComplete,
-          ui::AX_EVENT_FOCUS));
+  std::unique_ptr<AccessibilityNotificationWaiter> waiter(
+      new AccessibilityNotificationWaiter(shell(), AccessibilityModeComplete,
+                                          ui::AX_EVENT_FOCUS));
   ExecuteScript(L"document.body.children[0].focus()");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   SCOPED_TRACE("Check updated tree after focusing div");
   group_checker.SetExpectedState(
       STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_FOCUSED);
   document_checker.CheckAccessible(GetRendererAccessible());
 
   // Focus the document accessible. This will un-focus the current node.
@@ skipping 26 matching lines @@
   text_field_checker.SetExpectedState(STATE_SYSTEM_FOCUSABLE);
   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());
 
   // Set the value of the text control
-  scoped_ptr<AccessibilityNotificationWaiter> waiter(
-      new AccessibilityNotificationWaiter(
-          shell(), AccessibilityModeComplete,
-          ui::AX_EVENT_VALUE_CHANGED));
+  std::unique_ptr<AccessibilityNotificationWaiter> waiter(
+      new AccessibilityNotificationWaiter(shell(), AccessibilityModeComplete,
+                                          ui::AX_EVENT_VALUE_CHANGED));
   ExecuteScript(L"document.body.children[0].value='new value'");
   waiter->WaitForNotification();
 
   // Check that the accessibility tree of the browser has been updated.
   text_field_checker.SetExpectedValue(L"new value");
   document_checker.CheckAccessible(GetRendererAccessible());
 }
 
 // This test verifies that the web content's accessibility tree is a
 // descendant of the main browser window's accessibility tree, so that
@@ skipping 757 matching lines @@
 IN_PROC_BROWSER_TEST_F(AccessibilityWinBrowserTest,
                        TestMultiLineTextAtOffsetWithBoundaryAll) {
   base::win::ScopedComPtr<IAccessibleText> textarea_text;
   SetUpTextareaField(&textarea_text);
 
   CheckTextAtOffset(textarea_text, CONTENTS_LENGTH - 1, IA2_TEXT_BOUNDARY_ALL,
       0, CONTENTS_LENGTH, base::SysUTF8ToWide(TEXTAREA_CONTENTS));
 }
 
 }  // namespace content