Add IID_PPV_ARGS_Helper for ScopedComPtr

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 {
 
 // DEPRECATED: Use Microsoft::WRL::ComPtr instead.
 // A fairly minimalistic smart class for COM interface pointers.
 template <class Interface, const IID* interface_id = &__uuidof(Interface)>
@@ skipping 74 matching lines @@
     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(p);
+    return ptr_->QueryInterface(IID_PPV_ARGS(p));
   }
 
   // QI for times when the IID is not associated with the type.
   HRESULT QueryInterface(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(Receive());
+    return object->QueryInterface(IID_PPV_ARGS(Receive()));
   }
 
   // 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;
   }
 
   // Checks if the identity of |other| and this object is the same.
   bool IsSameObject(IUnknown* other) {
     if (!other && !ptr_)
       return true;
 
     if (!other || !ptr_)
       return false;
 
     ScopedComPtr<IUnknown> my_identity;
-    QueryInterface(my_identity.Receive());
+    QueryInterface(IID_PPV_ARGS(my_identity.Receive()));
 
     ScopedComPtr<IUnknown> other_identity;
-    other->QueryInterface(other_identity.Receive());
+    other->QueryInterface(IID_PPV_ARGS(other_identity.Receive()));
 
     return my_identity == other_identity;
   }
 
   // Provides direct access to the interface.
   // Here we use a well known trick to make sure we block access to
   // IUnknown methods so that something bad like this doesn't happen:
   //    ScopedComPtr<IUnknown> p(Foo());
   //    p->Release();
   //    ... later the destructor runs, which will Release() again.
@@ skipping 98 matching lines @@
 template <typename T>
 bool operator!=(std::nullptr_t null, const ScopedComPtr<T>& rhs) {
   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();
+}
+
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_WIN_SCOPED_COMPTR_H_