Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

base/win/scoped_comptr.h

 // 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.
 
 #ifndef BASE_WIN_SCOPED_COMPTR_H_
 #define BASE_WIN_SCOPED_COMPTR_H_
 
 #include <objbase.h>
 #include <unknwn.h>
 
@@ skipping 75 matching lines @@
 
   // Accepts an interface pointer that has already been addref-ed.
   void Attach(Interface* p) {
     DCHECK(!ptr_);
     ptr_ = p;
   }
 
   // Retrieves the pointer address.
   // Used to receive object pointers as out arguments (and take ownership).
   // The function DCHECKs on the current value being NULL.
-  // Usage: Foo(p.Receive());
-  Interface** Receive() {
+  // Usage: Foo(p.GetAddressOf());
+  Interface** GetAddressOf() {
     DCHECK(!ptr_) << "Object leak. Pointer must be NULL";
     return &ptr_;
   }
 
   template <class Query>
   HRESULT CopyTo(Query** p) {
     DCHECK(p);
     DCHECK(ptr_);
     // IUnknown already has a template version of QueryInterface
     // so the iid parameter is implicit here. The only thing this
     // function adds are the DCHECKs.
     return ptr_->QueryInterface(IID_PPV_ARGS(p));
   }
 
   // QI for times when the IID is not associated with the type.
   HRESULT CopyTo(const IID& iid, void** obj) {
     DCHECK(obj);
     DCHECK(ptr_);
     return ptr_->QueryInterface(iid, obj);
   }
 
   // Queries |other| for the interface this object wraps and returns the
   // error code from the other->QueryInterface operation.
   HRESULT QueryFrom(IUnknown* object) {
     DCHECK(object);
-    return object->QueryInterface(IID_PPV_ARGS(Receive()));
+    return object->QueryInterface(IID_PPV_ARGS(GetAddressOf()));
   }
 
   // Convenience wrapper around CoCreateInstance
   HRESULT CreateInstance(const CLSID& clsid,
                          IUnknown* outer = nullptr,
                          DWORD context = CLSCTX_ALL) {
     DCHECK(!ptr_);
     HRESULT hr = ::CoCreateInstance(clsid, outer, context, *interface_id,
                                     reinterpret_cast<void**>(&ptr_));
     return hr;
@@ skipping 83 matching lines @@
 // ComPtrRef equivalent transitional reference type to handle ComPtr equivalent
 // void** implicit casting. T should be a ScopedComPtr.
 template <typename T>
 class ScopedComPtrRef {
  public:
   explicit ScopedComPtrRef(T* scoped_com_ptr)
       : scoped_com_ptr_(scoped_com_ptr) {}
 
   // ComPtr equivalent conversion operators.
   operator void**() const {
-    return reinterpret_cast<void**>(scoped_com_ptr_->Receive());
+    return reinterpret_cast<void**>(scoped_com_ptr_->GetAddressOf());
   }
 
   // Allows ScopedComPtr to be passed to functions as a pointer.
   operator T*() { return scoped_com_ptr_; }
 
   // Allows IID_PPV_ARGS to perform __uuidof(**(ppType)).
   typename T::InterfaceType* operator*() { return scoped_com_ptr_->Get(); }
 
  private:
   T* const scoped_com_ptr_;
@@ skipping 39 matching lines @@
 // Helper to make IID_PPV_ARGS work with ScopedComPtr.
 template <typename T>
 void** IID_PPV_ARGS_Helper(base::win::details::ScopedComPtrRef<T> pp) throw() {
   return pp;
 }
 
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_WIN_SCOPED_COMPTR_H_