Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

content/browser/accessibility/accessibility_event_recorder_win.cc

 // Copyright 2014 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/accessibility_event_recorder.h"
 
 #include <oleacc.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 21 matching lines @@
     return base::UTF16ToUTF8(IAccessibleRoleToString(V_I4(role.ptr())));
   } else if (role.type() == VT_BSTR) {
     return base::UTF16ToUTF8(
         base::string16(V_BSTR(role.ptr()), SysStringLen(V_BSTR(role.ptr()))));
   }
   return std::string();
 }
 
 HRESULT QueryIAccessible2(IAccessible* accessible, IAccessible2** accessible2) {
   base::win::ScopedComPtr<IServiceProvider> service_provider;
-  HRESULT hr = accessible->QueryInterface(service_provider.Receive());
+  HRESULT hr = accessible->QueryInterface(service_provider.GetAddressOf());
   return SUCCEEDED(hr) ?
       service_provider->QueryService(IID_IAccessible2, accessible2) : hr;
 }
 
 HRESULT QueryIAccessibleText(IAccessible* accessible,
                              IAccessibleText** accessible_text) {
   base::win::ScopedComPtr<IServiceProvider> service_provider;
-  HRESULT hr = accessible->QueryInterface(service_provider.Receive());
+  HRESULT hr = accessible->QueryInterface(service_provider.GetAddressOf());
   return SUCCEEDED(hr) ?
       service_provider->QueryService(IID_IAccessibleText, accessible_text) : hr;
 }
 
 std::string BstrToUTF8(BSTR bstr) {
   base::string16 str16(bstr, SysStringLen(bstr));
 
   // IAccessibleText returns the text you get by appending all static text
   // children, with an "embedded object character" for each non-text child.
   // Pretty-print the embedded object character as <obj> so that test output
@@ skipping 97 matching lines @@
 void AccessibilityEventRecorderWin::OnWinEventHook(
     HWINEVENTHOOK handle,
     DWORD event,
     HWND hwnd,
     LONG obj_id,
     LONG child_id,
     DWORD event_thread,
     DWORD event_time) {
   base::win::ScopedComPtr<IAccessible> browser_accessible;
   HRESULT hr = AccessibleObjectFromWindowWrapper(
-      hwnd,
-      obj_id,
-      IID_IAccessible,
-      reinterpret_cast<void**>(browser_accessible.Receive()));
+      hwnd, obj_id, IID_IAccessible,
+      reinterpret_cast<void**>(browser_accessible.GetAddressOf()));
   if (!SUCCEEDED(hr)) {
     // Note: our event hook will pick up some superfluous events we
     // don't care about, so it's safe to just ignore these failures.
     // Same below for other HRESULT checks.
     VLOG(1) << "Ignoring result " << hr << " from AccessibleObjectFromWindow";
     return;
   }
 
   base::win::ScopedVariant childid_variant(child_id);
   base::win::ScopedComPtr<IDispatch> dispatch;
-  hr = browser_accessible->get_accChild(childid_variant, dispatch.Receive());
+  hr = browser_accessible->get_accChild(childid_variant,
+                                        dispatch.GetAddressOf());
   if (!SUCCEEDED(hr) || !dispatch) {
     VLOG(1) << "Ignoring result " << hr << " and result " << dispatch
             << " from get_accChild";
     return;
   }
 
   base::win::ScopedComPtr<IAccessible> iaccessible;
-  hr = dispatch.CopyTo(iaccessible.Receive());
+  hr = dispatch.CopyTo(iaccessible.GetAddressOf());
   if (!SUCCEEDED(hr)) {
     VLOG(1) << "Ignoring result " << hr << " from QueryInterface";
     return;
   }
 
   std::string event_str = AccessibilityEventToStringUTF8(event);
   if (event_str.empty()) {
     VLOG(1) << "Ignoring event " << event;
     return;
   }
@@ skipping 20 matching lines @@
   // window is frontmost or not, and "hottracked" depends on whether the
   // mouse cursor happens to be over the element.
   ia_state &= (~STATE_SYSTEM_OFFSCREEN & ~STATE_SYSTEM_HOTTRACKED);
 
   // The "readonly" state is set on almost every node and doesn't typically
   // change, so filter it out to keep the output less verbose.
   ia_state &= ~STATE_SYSTEM_READONLY;
 
   AccessibleStates ia2_state = 0;
   base::win::ScopedComPtr<IAccessible2> iaccessible2;
-  hr = QueryIAccessible2(iaccessible.Get(), iaccessible2.Receive());
+  hr = QueryIAccessible2(iaccessible.Get(), iaccessible2.GetAddressOf());
   if (SUCCEEDED(hr))
     iaccessible2->get_states(&ia2_state);
 
   std::string log = base::StringPrintf(
       "%s on role=%s", event_str.c_str(), RoleVariantToString(role).c_str());
   if (name_bstr.Length() > 0)
     log += base::StringPrintf(" name=\"%s\"", BstrToUTF8(name_bstr).c_str());
   if (value_bstr.Length() > 0)
     log += base::StringPrintf(" value=\"%s\"", BstrToUTF8(value_bstr).c_str());
   log += " ";
   log += base::UTF16ToUTF8(IAccessibleStateToString(ia_state));
   log += " ";
   log += base::UTF16ToUTF8(IAccessible2StateToString(ia2_state));
 
   // For TEXT_REMOVED and TEXT_INSERTED events, query the text that was
   // inserted or removed and include that in the log.
   base::win::ScopedComPtr<IAccessibleText> accessible_text;
-  hr = QueryIAccessibleText(iaccessible.Get(), accessible_text.Receive());
+  hr = QueryIAccessibleText(iaccessible.Get(), accessible_text.GetAddressOf());
   if (SUCCEEDED(hr)) {
     if (event == IA2_EVENT_TEXT_REMOVED) {
       IA2TextSegment old_text;
       if (SUCCEEDED(accessible_text->get_oldText(&old_text))) {
         log += base::StringPrintf(" old_text={'%s' start=%d end=%d}",
                                   BstrToUTF8(old_text.text).c_str(),
                                   old_text.start,
                                   old_text.end);
       }
     }
@@ skipping 27 matching lines @@
   if (accessibility_hwnd != hwnd)
     return E_FAIL;
 
   IAccessible* obj = ToBrowserAccessibilityComWin(manager_->GetRoot());
   obj->AddRef();
   *ppv_object = obj;
   return S_OK;
 }
 
 }  // namespace content