Remove Interface ID Template Parameter from 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 <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)>
+template <class 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() {
   }
 
   explicit ScopedComPtr(Interface* p) : ptr_(p) {
     if (ptr_)
       ptr_->AddRef();
   }
 
-  ScopedComPtr(const ScopedComPtr<Interface, interface_id>& p) : ptr_(p.Get()) {
+  ScopedComPtr(const ScopedComPtr<Interface>& p) : ptr_(p.Get()) {
     if (ptr_)
       ptr_->AddRef();
   }
 
   ~ScopedComPtr() {
     // We don't want the smart pointer class to be bigger than the pointer
     // it wraps.
-    static_assert(
-        sizeof(ScopedComPtr<Interface, interface_id>) == sizeof(Interface*),
-        "ScopedComPtrSize");
+    static_assert(sizeof(ScopedComPtr<Interface>) == sizeof(Interface*),
+                  "ScopedComPtrSize");
     Reset();
   }
 
   Interface* Get() const { return ptr_; }
 
   explicit operator bool() const { return ptr_ != nullptr; }
 
   // Explicit Release() of the held object.  Useful for reuse of the
   // ScopedComPtr instance.
   // Note that this function equates to IUnknown::Release and should not
@@ skipping 56 matching lines @@
   //    ... later the destructor runs, which will Release() again.
   // and to get the benefit of the DCHECKs we add to QueryInterface.
   // There's still a way to call these methods if you absolutely must
   // by statically casting the ScopedComPtr instance to the wrapped interface
   // and then making the call... but generally that shouldn't be necessary.
   BlockIUnknownMethods* operator->() const {
     DCHECK(ptr_);
     return reinterpret_cast<BlockIUnknownMethods*>(ptr_);
   }
 
-  ScopedComPtr<Interface, interface_id>& operator=(Interface* rhs) {
+  ScopedComPtr<Interface>& operator=(Interface* rhs) {
     // AddRef first so that self assignment should work
     if (rhs)
       rhs->AddRef();
     Interface* old_ptr = ptr_;
     ptr_ = rhs;
     if (old_ptr)
       old_ptr->Release();
     return *this;
   }
 
-  ScopedComPtr<Interface, interface_id>& operator=(
-      const ScopedComPtr<Interface, interface_id>& rhs) {
+  ScopedComPtr<Interface>& operator=(const ScopedComPtr<Interface>& rhs) {
     return *this = rhs.ptr_;
   }
 
   Interface& operator*() const {
     DCHECK(ptr_);
     return *ptr_;
   }
 
-  bool operator==(const ScopedComPtr<Interface, interface_id>& rhs) const {
+  bool operator==(const ScopedComPtr<Interface>& rhs) const {
     return ptr_ == rhs.Get();
   }
 
   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;
   }
 
-  bool operator!=(const ScopedComPtr<Interface, interface_id>& rhs) const {
+  bool operator!=(const ScopedComPtr<Interface>& rhs) const {
     return ptr_ != rhs.Get();
   }
 
   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);
+  details::ScopedComPtrRef<ScopedComPtr<Interface>> operator&() {
+    return details::ScopedComPtrRef<ScopedComPtr<Interface>>(this);
   }
 
-  void swap(ScopedComPtr<Interface, interface_id>& r) {
+  void swap(ScopedComPtr<Interface>& r) {
     Interface* tmp = ptr_;
     ptr_ = r.ptr_;
     r.ptr_ = tmp;
   }
 
  private:
   Interface* ptr_ = nullptr;
 };
 
 namespace details {
@@ skipping 61 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_