Rename ScopedComPtr::get() to ScopedComPtr::Get()

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 17 matching lines @@
   };
 
   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, interface_id>& 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");
     Reset();
   }
 
-  Interface* get() const { return ptr_; }
+  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
   // be confused with e.g. unique_ptr::release().
   unsigned long Reset() {
     unsigned long ref = 0;
     Interface* temp = ptr_;
@@ skipping 113 matching lines @@
       const ScopedComPtr<Interface, interface_id>& rhs) {
     return *this = rhs.ptr_;
   }
 
   Interface& operator*() const {
     DCHECK(ptr_);
     return *ptr_;
   }
 
   bool operator==(const ScopedComPtr<Interface, interface_id>& rhs) const {
-    return ptr_ == rhs.get();
+    return ptr_ == rhs.Get();
   }
 
   template <typename U>
   bool operator==(const ScopedComPtr<U>& rhs) const {
-    return ptr_ == rhs.get();
+    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 {
-    return ptr_ != rhs.get();
+    return ptr_ != rhs.Get();
   }
 
   template <typename U>
   bool operator!=(const ScopedComPtr<U>& rhs) const {
-    return ptr_ != rhs.get();
+    return ptr_ != rhs.Get();
   }
 
   template <typename U>
   bool operator!=(const U* rhs) const {
     return ptr_ != rhs;
   }
 
   void swap(ScopedComPtr<Interface, interface_id>& r) {
     Interface* tmp = ptr_;
     ptr_ = r.ptr_;
     r.ptr_ = tmp;
   }
 
  private:
   Interface* ptr_ = nullptr;
 };
 
 template <typename T, typename U>
 bool operator==(const T* lhs, const ScopedComPtr<U>& rhs) {
-  return lhs == rhs.get();
+  return lhs == rhs.Get();
 }
 
 template <typename T>
 bool operator==(const ScopedComPtr<T>& lhs, std::nullptr_t null) {
   return !static_cast<bool>(lhs);
 }
 
 template <typename T>
 bool operator==(std::nullptr_t null, const ScopedComPtr<T>& rhs) {
   return !static_cast<bool>(rhs);
 }
 
 template <typename T, typename U>
 bool operator!=(const T* lhs, const ScopedComPtr<U>& rhs) {
   return !operator==(lhs, rhs);
 }
 
 template <typename T>
 bool operator!=(const ScopedComPtr<T>& lhs, std::nullptr_t null) {
   return !operator==(lhs, null);
 }
 
 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();
+  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_