Remove ScopedComPtr::ReceiveVoid and Add ScopedComPtrRef

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>
 
 #include "base/logging.h"
 
 namespace base {
 namespace win {
 
+namespace details {
+
+template <typename T>
+class ScopedComPtrRef;
+
+}  // details
+
 // DEPRECATED: Use Microsoft::WRL::ComPtr instead.
 // A fairly minimalistic smart class for COM interface pointers.
 template <class Interface, const IID* interface_id = &__uuidof(Interface)>
 class ScopedComPtr {
  public:
+  using InterfaceType = Interface;
+
   // Utility template to prevent users of ScopedComPtr from calling AddRef
   // and/or Release() without going through the ScopedComPtr class.
   class BlockIUnknownMethods : public Interface {
    private:
     STDMETHOD(QueryInterface)(REFIID iid, void** object) = 0;
     STDMETHOD_(ULONG, AddRef)() = 0;
     STDMETHOD_(ULONG, Release)() = 0;
   };
 
   ScopedComPtr() {
@@ skipping 52 matching lines @@
 
   // 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() {
     DCHECK(!ptr_) << "Object leak. Pointer must be NULL";
     return &ptr_;
   }
 
-  // A convenience for whenever a void pointer is needed as an out argument.
-  void** ReceiveVoid() {
-    return reinterpret_cast<void**>(Receive());
-  }
-
   template <class Query>
   HRESULT QueryInterface(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));
   }
 
@@ skipping 95 matching lines @@
   template <typename U>
   bool operator!=(const ScopedComPtr<U>& rhs) const {
     return ptr_ != rhs.Get();
   }
 
   template <typename U>
   bool operator!=(const U* rhs) const {
     return ptr_ != rhs;
   }
 
+  details::ScopedComPtrRef<ScopedComPtr<Interface, interface_id>> operator&() {
+    return details::ScopedComPtrRef<ScopedComPtr<Interface, interface_id>>(
+        this);
+  }
+
   void swap(ScopedComPtr<Interface, interface_id>& r) {
     Interface* tmp = ptr_;
     ptr_ = r.ptr_;
     r.ptr_ = tmp;
   }
 
  private:
   Interface* ptr_ = nullptr;
 };
 
+namespace details {
+
+// ComPtrRef equivalent transitional reference type to handle ComPtr equivalent
+// void** implicit casting. T should be a ScopedComPtr.
+template <typename T>
+class ScopedComPtrRef {
+ public:
+  ScopedComPtrRef(T* scoped_com_ptr) : scoped_com_ptr_(scoped_com_ptr) {}

[scottmg, 2017/04/27 23:16:07]

explicit

+
+  // ComPtr equivalent conversion operators.
+  operator void**() const {
+    return reinterpret_cast<void**>(scoped_com_ptr_->Receive());
+  }
+
+  // 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_;
+};
+
+}  // details
+
 template <typename T, typename U>
 bool operator==(const T* lhs, const ScopedComPtr<U>& rhs) {
   return lhs == rhs.Get();
 }
 
 template <typename T>
 bool operator==(const ScopedComPtr<T>& lhs, std::nullptr_t null) {
   return !static_cast<bool>(lhs);
 }
 
@@ skipping 17 matching lines @@
   return !operator==(null, rhs);
 }
 
 template <typename T>
 std::ostream& operator<<(std::ostream& out, const ScopedComPtr<T>& p) {
   return out << p.Get();
 }
 
 // Helper to make IID_PPV_ARGS work with ScopedComPtr.
 template <typename T>
-void** IID_PPV_ARGS_Helper(base::win::ScopedComPtr<T>* pp) throw() {
-  return pp->ReceiveVoid();
+void** IID_PPV_ARGS_Helper(base::win::details::ScopedComPtrRef<T> pp) throw() {
+  return pp;
 }
 
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_WIN_SCOPED_COMPTR_H_