Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

ui/accessibility/platform/ax_platform_node_win_unittest.cc

 // Copyright 2015 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 "ui/accessibility/platform/ax_platform_node.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <oleacc.h>
 
@@ skipping 81 matching lines @@
   ScopedComPtr<IAccessible> GetRootIAccessible() {
     return IAccessibleFromNode(GetRootNode());
   }
 
   ScopedComPtr<IAccessible2> ToIAccessible2(
       ScopedComPtr<IAccessible> accessible) {
     CHECK(accessible.Get());
     ScopedComPtr<IServiceProvider> service_provider;
     service_provider.QueryFrom(accessible.Get());
     ScopedComPtr<IAccessible2> result;
-    CHECK(SUCCEEDED(
-        service_provider->QueryService(IID_IAccessible2, result.Receive())));
+    CHECK(SUCCEEDED(service_provider->QueryService(IID_IAccessible2,
+                                                   result.GetAddressOf())));
     return result;
   }
 
   std::unique_ptr<AXTree> tree_;
 };
 
 TEST_F(AXPlatformNodeWinTest, TestIAccessibleDetachedObject) {
   AXNodeData root;
   root.id = 1;
   root.AddStringAttribute(AX_ATTR_NAME, "Name");
@@ skipping 169 matching lines @@
   LONG child_count;
   EXPECT_EQ(S_OK, root_iaccessible->get_accChildCount(&child_count));
   EXPECT_EQ(2L, child_count);
   EXPECT_EQ(S_OK, button_iaccessible->get_accChildCount(&child_count));
   EXPECT_EQ(0L, child_count);
   EXPECT_EQ(S_OK, checkbox_iaccessible->get_accChildCount(&child_count));
   EXPECT_EQ(0L, child_count);
 
   {
     ScopedComPtr<IDispatch> result;
-    EXPECT_EQ(S_OK, root_iaccessible->get_accChild(SELF, result.Receive()));
+    EXPECT_EQ(S_OK,
+              root_iaccessible->get_accChild(SELF, result.GetAddressOf()));
     EXPECT_EQ(result.Get(), root_iaccessible);
   }
 
   {
     ScopedComPtr<IDispatch> result;
     ScopedVariant child1(1);
-    EXPECT_EQ(S_OK, root_iaccessible->get_accChild(child1, result.Receive()));
+    EXPECT_EQ(S_OK,
+              root_iaccessible->get_accChild(child1, result.GetAddressOf()));
     EXPECT_EQ(result.Get(), button_iaccessible);
   }
 
   {
     ScopedComPtr<IDispatch> result;
     ScopedVariant child2(2);
-    EXPECT_EQ(S_OK, root_iaccessible->get_accChild(child2, result.Receive()));
+    EXPECT_EQ(S_OK,
+              root_iaccessible->get_accChild(child2, result.GetAddressOf()));
     EXPECT_EQ(result.Get(), checkbox_iaccessible);
   }
 
   {
     // Asking for child id 3 should fail.
     ScopedComPtr<IDispatch> result;
     ScopedVariant child3(3);
     EXPECT_EQ(E_INVALIDARG,
-              root_iaccessible->get_accChild(child3, result.Receive()));
+              root_iaccessible->get_accChild(child3, result.GetAddressOf()));
   }
 
   // We should be able to ask for the button by its unique id too.
   LONG button_unique_id;
   ScopedComPtr<IAccessible2> button_iaccessible2 =
       ToIAccessible2(button_iaccessible);
   button_iaccessible2->get_uniqueID(&button_unique_id);
   ASSERT_LT(button_unique_id, 0);
   {
     ScopedComPtr<IDispatch> result;
     ScopedVariant button_id_variant(button_unique_id);
     EXPECT_EQ(S_OK, root_iaccessible->get_accChild(button_id_variant,
-                                                   result.Receive()));
+                                                   result.GetAddressOf()));
     EXPECT_EQ(result.Get(), button_iaccessible);
   }
 
   // We shouldn't be able to ask for the root node by its unique ID
   // from one of its children, though.
   LONG root_unique_id;
   ScopedComPtr<IAccessible2> root_iaccessible2 =
       ToIAccessible2(root_iaccessible);
   root_iaccessible2->get_uniqueID(&root_unique_id);
   ASSERT_LT(root_unique_id, 0);
   {
     ScopedComPtr<IDispatch> result;
     ScopedVariant root_id_variant(root_unique_id);
-    EXPECT_EQ(E_INVALIDARG, button_iaccessible->get_accChild(root_id_variant,
-                                                             result.Receive()));
+    EXPECT_EQ(E_INVALIDARG, button_iaccessible->get_accChild(
+                                root_id_variant, result.GetAddressOf()));
   }
 
   // Now check parents.
   {
     ScopedComPtr<IDispatch> result;
-    EXPECT_EQ(S_OK, button_iaccessible->get_accParent(result.Receive()));
+    EXPECT_EQ(S_OK, button_iaccessible->get_accParent(result.GetAddressOf()));
     EXPECT_EQ(result.Get(), root_iaccessible);
   }
 
   {
     ScopedComPtr<IDispatch> result;
-    EXPECT_EQ(S_OK, checkbox_iaccessible->get_accParent(result.Receive()));
+    EXPECT_EQ(S_OK, checkbox_iaccessible->get_accParent(result.GetAddressOf()));
     EXPECT_EQ(result.Get(), root_iaccessible);
   }
 
   {
     ScopedComPtr<IDispatch> result;
-    EXPECT_EQ(S_FALSE, root_iaccessible->get_accParent(result.Receive()));
+    EXPECT_EQ(S_FALSE, root_iaccessible->get_accParent(result.GetAddressOf()));
   }
 }
 
 TEST_F(AXPlatformNodeWinTest, TestIAccessible2IndexInParent) {
   AXNodeData root;
   root.id = 1;
   root.child_ids.push_back(2);
   root.child_ids.push_back(3);
 
   AXNodeData left;
@@ skipping 43 matching lines @@
   EXPECT_HRESULT_SUCCEEDED(text_field->setSelection(0, 1, 0));
   EXPECT_HRESULT_SUCCEEDED(text_field->setSelection(0, 2, 2));
   EXPECT_HRESULT_SUCCEEDED(text_field->setSelection(0, IA2_TEXT_OFFSET_CARET,
                                                     IA2_TEXT_OFFSET_LENGTH));
 
   EXPECT_HRESULT_FAILED(text_field->setSelection(1, 0, 0));
   EXPECT_HRESULT_FAILED(text_field->setSelection(0, 0, 5));
 }
 
 }  // namespace ui