Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

content/browser/accessibility/browser_accessibility_win_unittest.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/browser_accessibility_win.h"
 
+#include <objbase.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_variant.h"
@@ skipping 118 matching lines @@
   std::unique_ptr<BrowserAccessibilityManager> manager(
       BrowserAccessibilityManager::Create(MakeAXTreeUpdate(root, text), nullptr,
                                           new BrowserAccessibilityFactory()));
 
   // Query for the text IAccessible and verify that it returns "old text" as its
   // value.
   base::win::ScopedVariant one(1);
   base::win::ScopedComPtr<IDispatch> text_dispatch;
   HRESULT hr = ToBrowserAccessibilityWin(manager->GetRoot())
                    ->GetCOM()
-                   ->get_accChild(one, text_dispatch.Receive());
+                   ->get_accChild(one, text_dispatch.GetAddressOf());
   ASSERT_EQ(S_OK, hr);
 
   base::win::ScopedComPtr<IAccessible> text_accessible;
-  hr = text_dispatch.CopyTo(text_accessible.Receive());
+  hr = text_dispatch.CopyTo(text_accessible.GetAddressOf());
   ASSERT_EQ(S_OK, hr);
 
   base::win::ScopedVariant childid_self(CHILDID_SELF);
   base::win::ScopedBstr name;
   hr = text_accessible->get_accName(childid_self, name.Receive());
   ASSERT_EQ(S_OK, hr);
   EXPECT_EQ(L"old text", base::string16(name));
   name.Reset();
 
   text_dispatch.Reset();
   text_accessible.Reset();
 
   // Notify the BrowserAccessibilityManager that the text child has changed.
   AXContentNodeData text2;
   text2.id = 2;
   text2.role = ui::AX_ROLE_STATIC_TEXT;
   text2.SetName("new text");
   AXEventNotificationDetails param;
   param.event_type = ui::AX_EVENT_CHILDREN_CHANGED;
   param.update.nodes.push_back(text2);
   param.id = text2.id;
   std::vector<AXEventNotificationDetails> events;
   events.push_back(param);
   manager->OnAccessibilityEvents(events);
 
   // Query for the text IAccessible and verify that it now returns "new text"
   // as its value.
   hr = ToBrowserAccessibilityWin(manager->GetRoot())
            ->GetCOM()
-           ->get_accChild(one, text_dispatch.Receive());
+           ->get_accChild(one, text_dispatch.GetAddressOf());
   ASSERT_EQ(S_OK, hr);
 
-  hr = text_dispatch.CopyTo(text_accessible.Receive());
+  hr = text_dispatch.CopyTo(text_accessible.GetAddressOf());
   ASSERT_EQ(S_OK, hr);
 
   hr = text_accessible->get_accName(childid_self, name.Receive());
   ASSERT_EQ(S_OK, hr);
   EXPECT_EQ(L"new text", base::string16(name));
 
   text_dispatch.Reset();
   text_accessible.Reset();
 
   // Delete the manager and test that all BrowserAccessibility instances are
@@ skipping 249 matching lines @@
 
   base::win::ScopedBstr text;
   EXPECT_EQ(S_OK, root_obj->get_text(0, text_name_len, text.Receive()));
   EXPECT_EQ(text1_name + text2_name, base::UTF16ToUTF8(base::string16(text)));
 
   long hyperlink_count;
   EXPECT_EQ(S_OK, root_obj->get_nHyperlinks(&hyperlink_count));
   EXPECT_EQ(0, hyperlink_count);
 
   base::win::ScopedComPtr<IAccessibleHyperlink> hyperlink;
-  EXPECT_EQ(E_INVALIDARG, root_obj->get_hyperlink(-1, hyperlink.Receive()));
-  EXPECT_EQ(E_INVALIDARG, root_obj->get_hyperlink(0, hyperlink.Receive()));
   EXPECT_EQ(E_INVALIDARG,
-            root_obj->get_hyperlink(text_name_len, hyperlink.Receive()));
+            root_obj->get_hyperlink(-1, hyperlink.GetAddressOf()));
+  EXPECT_EQ(E_INVALIDARG, root_obj->get_hyperlink(0, hyperlink.GetAddressOf()));
   EXPECT_EQ(E_INVALIDARG,
-            root_obj->get_hyperlink(text_name_len + 1, hyperlink.Receive()));
+            root_obj->get_hyperlink(text_name_len, hyperlink.GetAddressOf()));
+  EXPECT_EQ(E_INVALIDARG, root_obj->get_hyperlink(text_name_len + 1,
+                                                  hyperlink.GetAddressOf()));
 
   long hyperlink_index;
   EXPECT_EQ(S_FALSE, root_obj->get_hyperlinkIndex(0, &hyperlink_index));
   EXPECT_EQ(-1, hyperlink_index);
   // Invalid arguments should not be modified.
   hyperlink_index = -2;
   EXPECT_EQ(E_INVALIDARG,
             root_obj->get_hyperlinkIndex(text_name_len, &hyperlink_index));
   EXPECT_EQ(-2, hyperlink_index);
   EXPECT_EQ(E_INVALIDARG, root_obj->get_hyperlinkIndex(-1, &hyperlink_index));
@@ skipping 95 matching lines @@
   EXPECT_EQ(S_OK, root_obj->get_text(0, root_hypertext_len, text.Receive()));
   EXPECT_STREQ(root_hypertext.c_str(), text);
   text.Reset();
 
   long hyperlink_count;
   EXPECT_EQ(S_OK, root_obj->get_nHyperlinks(&hyperlink_count));
   EXPECT_EQ(4, hyperlink_count);
 
   base::win::ScopedComPtr<IAccessibleHyperlink> hyperlink;
   base::win::ScopedComPtr<IAccessibleText> hypertext;
-  EXPECT_EQ(E_INVALIDARG, root_obj->get_hyperlink(-1, hyperlink.Receive()));
-  EXPECT_EQ(E_INVALIDARG, root_obj->get_hyperlink(4, hyperlink.Receive()));
+  EXPECT_EQ(E_INVALIDARG,
+            root_obj->get_hyperlink(-1, hyperlink.GetAddressOf()));
+  EXPECT_EQ(E_INVALIDARG, root_obj->get_hyperlink(4, hyperlink.GetAddressOf()));
 
   // Get the text of the combo box.
   // It should be its value.
-  EXPECT_EQ(S_OK, root_obj->get_hyperlink(0, hyperlink.Receive()));
-  EXPECT_EQ(S_OK, hyperlink.CopyTo(hypertext.Receive()));
+  EXPECT_EQ(S_OK, root_obj->get_hyperlink(0, hyperlink.GetAddressOf()));
+  EXPECT_EQ(S_OK, hyperlink.CopyTo(hypertext.GetAddressOf()));
   EXPECT_EQ(S_OK,
             hypertext->get_text(0, IA2_TEXT_OFFSET_LENGTH, text.Receive()));
   EXPECT_STREQ(combo_box_value.c_str(), text);
   text.Reset();
   hyperlink.Reset();
   hypertext.Reset();
 
   // Get the text of the check box.
   // It should be its name.
-  EXPECT_EQ(S_OK, root_obj->get_hyperlink(1, hyperlink.Receive()));
-  EXPECT_EQ(S_OK, hyperlink.CopyTo(hypertext.Receive()));
+  EXPECT_EQ(S_OK, root_obj->get_hyperlink(1, hyperlink.GetAddressOf()));
+  EXPECT_EQ(S_OK, hyperlink.CopyTo(hypertext.GetAddressOf()));
   EXPECT_EQ(S_OK,
             hypertext->get_text(0, IA2_TEXT_OFFSET_LENGTH, text.Receive()));
   EXPECT_STREQ(check_box_name.c_str(), text);
   text.Reset();
   hyperlink.Reset();
   hypertext.Reset();
 
   // Get the text of the button.
-  EXPECT_EQ(S_OK, root_obj->get_hyperlink(2, hyperlink.Receive()));
-  EXPECT_EQ(S_OK, hyperlink.CopyTo(hypertext.Receive()));
+  EXPECT_EQ(S_OK, root_obj->get_hyperlink(2, hyperlink.GetAddressOf()));
+  EXPECT_EQ(S_OK, hyperlink.CopyTo(hypertext.GetAddressOf()));
   EXPECT_EQ(S_OK,
             hypertext->get_text(0, IA2_TEXT_OFFSET_LENGTH, text.Receive()));
   EXPECT_STREQ(button_text_name.c_str(), text);
   text.Reset();
   hyperlink.Reset();
   hypertext.Reset();
 
   // Get the text of the link.
-  EXPECT_EQ(S_OK, root_obj->get_hyperlink(3, hyperlink.Receive()));
-  EXPECT_EQ(S_OK, hyperlink.CopyTo(hypertext.Receive()));
+  EXPECT_EQ(S_OK, root_obj->get_hyperlink(3, hyperlink.GetAddressOf()));
+  EXPECT_EQ(S_OK, hyperlink.CopyTo(hypertext.GetAddressOf()));
   EXPECT_EQ(S_OK, hypertext->get_text(0, 4, text.Receive()));
   EXPECT_STREQ(link_text_name.c_str(), text);
   text.Reset();
   hyperlink.Reset();
   hypertext.Reset();
 
   long hyperlink_index;
   EXPECT_EQ(S_FALSE, root_obj->get_hyperlinkIndex(0, &hyperlink_index));
   EXPECT_EQ(-1, hyperlink_index);
   // Invalid arguments should not be modified.
@@ skipping 424 matching lines @@
   BrowserAccessibilityWin* textarea_accessible =
       ToBrowserAccessibilityWin(root_accessible->PlatformGetChild(0));
   ASSERT_NE(nullptr, textarea_accessible);
   BrowserAccessibilityWin* text_field_accessible =
       ToBrowserAccessibilityWin(root_accessible->PlatformGetChild(1));
   ASSERT_NE(nullptr, text_field_accessible);
 
   base::win::ScopedComPtr<IAccessibleText> textarea_object;
   EXPECT_HRESULT_SUCCEEDED(textarea_accessible->GetCOM()->QueryInterface(
       IID_IAccessibleText,
-      reinterpret_cast<void**>(textarea_object.Receive())));
+      reinterpret_cast<void**>(textarea_object.GetAddressOf())));
   base::win::ScopedComPtr<IAccessibleText> text_field_object;
   EXPECT_HRESULT_SUCCEEDED(text_field_accessible->GetCOM()->QueryInterface(
       IID_IAccessibleText,
-      reinterpret_cast<void**>(text_field_object.Receive())));
+      reinterpret_cast<void**>(text_field_object.GetAddressOf())));
 
   LONG offset = 0;
   while (offset < static_cast<LONG>(text.length())) {
     LONG start, end;
     base::win::ScopedBstr word;
     EXPECT_EQ(S_OK,
               textarea_object->get_textAtOffset(offset, IA2_TEXT_BOUNDARY_WORD,
                                                 &start, &end, word.Receive()));
     EXPECT_EQ(offset, start);
     EXPECT_LT(offset, end);
@@ skipping 463 matching lines @@
 
   base::win::ScopedComPtr<IAccessibleHyperlink> hyperlink;
   base::win::ScopedVariant anchor;
   base::win::ScopedVariant anchor_target;
   base::win::ScopedBstr bstr;
 
   base::string16 div_hypertext(L"Click ");
   div_hypertext.push_back(BrowserAccessibilityComWin::kEmbeddedCharacter);
 
   // div_accessible and link_accessible are the only IA2 hyperlinks.
-  EXPECT_HRESULT_FAILED(root_accessible->GetCOM()->QueryInterface(
-      IID_IAccessibleHyperlink, reinterpret_cast<void**>(hyperlink.Receive())));
+  EXPECT_HRESULT_FAILED(
+      root_accessible->GetCOM()->QueryInterface(IID_PPV_ARGS(&hyperlink)));
   hyperlink.Reset();
-  EXPECT_HRESULT_SUCCEEDED(div_accessible->GetCOM()->QueryInterface(
-      IID_IAccessibleHyperlink, reinterpret_cast<void**>(hyperlink.Receive())));
+  EXPECT_HRESULT_SUCCEEDED(
+      div_accessible->GetCOM()->QueryInterface(IID_PPV_ARGS(&hyperlink)));
   hyperlink.Reset();
-  EXPECT_HRESULT_FAILED(text_accessible->GetCOM()->QueryInterface(
-      IID_IAccessibleHyperlink, reinterpret_cast<void**>(hyperlink.Receive())));
+  EXPECT_HRESULT_FAILED(
+      text_accessible->GetCOM()->QueryInterface(IID_PPV_ARGS(&hyperlink)));
   hyperlink.Reset();
-  EXPECT_HRESULT_SUCCEEDED(link_accessible->GetCOM()->QueryInterface(
-      IID_IAccessibleHyperlink, reinterpret_cast<void**>(hyperlink.Receive())));
+  EXPECT_HRESULT_SUCCEEDED(
+      link_accessible->GetCOM()->QueryInterface(IID_PPV_ARGS(&hyperlink)));
   hyperlink.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(root_accessible->GetCOM()->nActions(&n_actions));
   EXPECT_EQ(0, n_actions);
   EXPECT_HRESULT_SUCCEEDED(div_accessible->GetCOM()->nActions(&n_actions));
   EXPECT_EQ(1, n_actions);
   EXPECT_HRESULT_SUCCEEDED(text_accessible->GetCOM()->nActions(&n_actions));
   EXPECT_EQ(0, n_actions);
   EXPECT_HRESULT_SUCCEEDED(link_accessible->GetCOM()->nActions(&n_actions));
   EXPECT_EQ(1, n_actions);
@@ skipping 649 matching lines @@
   int32_t child_unique_id_2 = child->unique_id();
 
   // The nodes in the new tree should not have the same ids.
   EXPECT_NE(root_unique_id, root_unique_id_2);
   EXPECT_NE(child_unique_id, child_unique_id_2);
 
   // Trying to access the unique IDs of the old, deleted objects should fail.
   base::win::ScopedVariant old_root_variant(-root_unique_id);
   base::win::ScopedComPtr<IDispatch> old_root_dispatch;
   HRESULT hr = ToBrowserAccessibilityWin(root)->GetCOM()->get_accChild(
-      old_root_variant, old_root_dispatch.Receive());
+      old_root_variant, old_root_dispatch.GetAddressOf());
   EXPECT_EQ(E_INVALIDARG, hr);
 
   base::win::ScopedVariant old_child_variant(-child_unique_id);
   base::win::ScopedComPtr<IDispatch> old_child_dispatch;
   hr = ToBrowserAccessibilityWin(root)->GetCOM()->get_accChild(
-      old_child_variant, old_child_dispatch.Receive());
+      old_child_variant, old_child_dispatch.GetAddressOf());
   EXPECT_EQ(E_INVALIDARG, hr);
 
   // Trying to access the unique IDs of the new objects should succeed.
   base::win::ScopedVariant new_root_variant(-root_unique_id_2);
   base::win::ScopedComPtr<IDispatch> new_root_dispatch;
   hr = ToBrowserAccessibilityWin(root)->GetCOM()->get_accChild(
-      new_root_variant, new_root_dispatch.Receive());
+      new_root_variant, new_root_dispatch.GetAddressOf());
   EXPECT_EQ(S_OK, hr);
 
   base::win::ScopedVariant new_child_variant(-child_unique_id_2);
   base::win::ScopedComPtr<IDispatch> new_child_dispatch;
   hr = ToBrowserAccessibilityWin(root)->GetCOM()->get_accChild(
-      new_child_variant, new_child_dispatch.Receive());
+      new_child_variant, new_child_dispatch.GetAddressOf());
   EXPECT_EQ(S_OK, hr);
 }
 
 TEST_F(BrowserAccessibilityTest, AccChildOnlyReturnsDescendants) {
   ui::AXNodeData root_node;
   root_node.id = 1;
   root_node.role = ui::AX_ROLE_ROOT_WEB_AREA;
 
   ui::AXNodeData child_node;
   child_node.id = 2;
   root_node.child_ids.push_back(2);
 
   std::unique_ptr<BrowserAccessibilityManagerWin> manager(
       new BrowserAccessibilityManagerWin(
           MakeAXTreeUpdate(root_node, child_node), nullptr,
           new BrowserAccessibilityFactory()));
 
   BrowserAccessibility* root = manager->GetRoot();
   BrowserAccessibility* child = root->PlatformGetChild(0);
 
   base::win::ScopedVariant root_unique_id_variant(-root->unique_id());
   base::win::ScopedComPtr<IDispatch> result;
   EXPECT_EQ(E_INVALIDARG,
             ToBrowserAccessibilityWin(child)->GetCOM()->get_accChild(
-                root_unique_id_variant, result.Receive()));
+                root_unique_id_variant, result.GetAddressOf()));
 
   base::win::ScopedVariant child_unique_id_variant(-child->unique_id());
   EXPECT_EQ(S_OK, ToBrowserAccessibilityWin(root)->GetCOM()->get_accChild(
-                      child_unique_id_variant, result.Receive()));
+                      child_unique_id_variant, result.GetAddressOf()));
 }
 
 TEST_F(BrowserAccessibilityTest, TestIAccessible2Relations) {
   ui::AXNodeData root;
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
   // Reflexive relations should be ignored.
   std::vector<int32_t> describedby_ids = {1, 2, 3};
   root.AddIntListAttribute(ui::AX_ATTR_DESCRIBEDBY_IDS, describedby_ids);
 
@@ skipping 28 matching lines @@
   base::win::ScopedBstr relation_type;
   base::win::ScopedComPtr<IAccessibleRelation> describedby_relation;
   base::win::ScopedComPtr<IAccessibleRelation> description_for_relation;
   base::win::ScopedComPtr<IUnknown> target;
   base::win::ScopedComPtr<IAccessible2> ax_target;
 
   EXPECT_HRESULT_SUCCEEDED(ax_root->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(1, n_relations);
 
   EXPECT_HRESULT_SUCCEEDED(
-      ax_root->GetCOM()->get_relation(0, describedby_relation.Receive()));
+      ax_root->GetCOM()->get_relation(0, describedby_relation.GetAddressOf()));
   EXPECT_HRESULT_SUCCEEDED(
       describedby_relation->get_relationType(relation_type.Receive()));
   EXPECT_EQ(L"describedBy", base::string16(relation_type));
   relation_type.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(describedby_relation->get_nTargets(&n_targets));
   EXPECT_EQ(2, n_targets);
 
   EXPECT_HRESULT_SUCCEEDED(
-      describedby_relation->get_target(0, target.Receive()));
-  target.CopyTo(ax_target.Receive());
+      describedby_relation->get_target(0, target.GetAddressOf()));
+  target.CopyTo(ax_target.GetAddressOf());
   EXPECT_HRESULT_SUCCEEDED(ax_target->get_uniqueID(&unique_id));
   EXPECT_EQ(-ax_child1->unique_id(), unique_id);
   ax_target.Reset();
   target.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(
-      describedby_relation->get_target(1, target.Receive()));
-  target.CopyTo(ax_target.Receive());
+      describedby_relation->get_target(1, target.GetAddressOf()));
+  target.CopyTo(ax_target.GetAddressOf());
   EXPECT_HRESULT_SUCCEEDED(ax_target->get_uniqueID(&unique_id));
   EXPECT_EQ(-ax_child2->unique_id(), unique_id);
   ax_target.Reset();
   target.Reset();
   describedby_relation.Reset();
 
   // Test the reverse relations.
   EXPECT_HRESULT_SUCCEEDED(ax_child1->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(1, n_relations);
 
-  EXPECT_HRESULT_SUCCEEDED(
-      ax_child1->GetCOM()->get_relation(0, description_for_relation.Receive()));
+  EXPECT_HRESULT_SUCCEEDED(ax_child1->GetCOM()->get_relation(
+      0, description_for_relation.GetAddressOf()));
   EXPECT_HRESULT_SUCCEEDED(
       description_for_relation->get_relationType(relation_type.Receive()));
   EXPECT_EQ(L"descriptionFor", base::string16(relation_type));
   relation_type.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(description_for_relation->get_nTargets(&n_targets));
   EXPECT_EQ(1, n_targets);
 
   EXPECT_HRESULT_SUCCEEDED(
-      description_for_relation->get_target(0, target.Receive()));
-  target.CopyTo(ax_target.Receive());
+      description_for_relation->get_target(0, target.GetAddressOf()));
+  target.CopyTo(ax_target.GetAddressOf());
   EXPECT_HRESULT_SUCCEEDED(ax_target->get_uniqueID(&unique_id));
   EXPECT_EQ(-ax_root->unique_id(), unique_id);
   ax_target.Reset();
   target.Reset();
   description_for_relation.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(ax_child2->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(1, n_relations);
 
-  EXPECT_HRESULT_SUCCEEDED(
-      ax_child2->GetCOM()->get_relation(0, description_for_relation.Receive()));
+  EXPECT_HRESULT_SUCCEEDED(ax_child2->GetCOM()->get_relation(
+      0, description_for_relation.GetAddressOf()));
   EXPECT_HRESULT_SUCCEEDED(
       description_for_relation->get_relationType(relation_type.Receive()));
   EXPECT_EQ(L"descriptionFor", base::string16(relation_type));
   relation_type.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(description_for_relation->get_nTargets(&n_targets));
   EXPECT_EQ(1, n_targets);
 
   EXPECT_HRESULT_SUCCEEDED(
-      description_for_relation->get_target(0, target.Receive()));
-  target.CopyTo(ax_target.Receive());
+      description_for_relation->get_target(0, target.GetAddressOf()));
+  target.CopyTo(ax_target.GetAddressOf());
   EXPECT_HRESULT_SUCCEEDED(ax_target->get_uniqueID(&unique_id));
   EXPECT_EQ(-ax_root->unique_id(), unique_id);
   ax_target.Reset();
   target.Reset();
 
   // Try adding one more relation.
   std::vector<int32_t> labelledby_ids = {3};
   child1.AddIntListAttribute(ui::AX_ATTR_LABELLEDBY_IDS, labelledby_ids);
   AXEventNotificationDetails event;
   event.event_type = ui::AX_EVENT_ARIA_ATTRIBUTE_CHANGED;
   event.update.nodes.push_back(child1);
   event.id = child1.id;
   std::vector<AXEventNotificationDetails> events = {event};
   manager->OnAccessibilityEvents(events);
 
   EXPECT_HRESULT_SUCCEEDED(ax_child1->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(2, n_relations);
   EXPECT_HRESULT_SUCCEEDED(ax_child2->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(2, n_relations);
 }
 
 }  // namespace content