Sync Mac scopers with upstream Chromium

base/mac/scoped_cftyperef.h

Index: base/mac/scoped_cftyperef.h
diff --git a/base/mac/scoped_cftyperef.h b/base/mac/scoped_cftyperef.h
index 32000f8ee676a54012f29d70ae03b83be1827d35..7ea09219ff23395fe2e0988eeadfb382319324a7 100644
--- a/base/mac/scoped_cftyperef.h
+++ b/base/mac/scoped_cftyperef.h
@@ -7,99 +7,27 @@
 
 #include <CoreFoundation/CoreFoundation.h>
 
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/memory/scoped_policy.h"
+#include "base/mac/scoped_typeref.h"
 
 namespace base {
 
-// ScopedCFTypeRef<> is patterned after scoped_ptr<>, but maintains ownership
-// of a CoreFoundation object: any object that can be represented as a
-// CFTypeRef.  Style deviations here are solely for compatibility with
-// scoped_ptr<>'s interface, with which everyone is already familiar.
-//
-// By default, ScopedCFTypeRef<> takes ownership of an object (in the
-// constructor or in reset()) by taking over the caller's existing ownership
-// claim.  The caller must own the object it gives to ScopedCFTypeRef<>, and
-// relinquishes an ownership claim to that object.  ScopedCFTypeRef<> does not
-// call CFRetain(). This behavior is parameterized by the |OwnershipPolicy|
-// enum. If the value |RETAIN| is passed (in the constructor or in reset()),
-// then ScopedCFTypeRef<> will call CFRetain() on the object, and the initial
-// ownership is not changed.
+namespace internal {
 
-template<typename CFT>
-class ScopedCFTypeRef {
- public:
-  typedef CFT element_type;
-
-  explicit ScopedCFTypeRef(
-      CFT object = NULL,
-      base::scoped_policy::OwnershipPolicy policy = base::scoped_policy::ASSUME)
-      : object_(object) {
-    if (object_ && policy == base::scoped_policy::RETAIN)
-      CFRetain(object_);
-  }
-
-  ScopedCFTypeRef(const ScopedCFTypeRef<CFT>& that)
-      : object_(that.object_) {
-    if (object_)
-      CFRetain(object_);
-  }
-
-  ~ScopedCFTypeRef() {
-    if (object_)
-      CFRelease(object_);
-  }
-
-  ScopedCFTypeRef& operator=(const ScopedCFTypeRef<CFT>& that) {
-    reset(that.get(), base::scoped_policy::RETAIN);
-    return *this;
-  }
-
-  void reset(CFT object = NULL,
-             base::scoped_policy::OwnershipPolicy policy =
-                base::scoped_policy::ASSUME) {
-    if (object && policy == base::scoped_policy::RETAIN)
-      CFRetain(object);
-    if (object_)
-      CFRelease(object_);
-    object_ = object;
-  }
-
-  bool operator==(CFT that) const {
-    return object_ == that;
-  }
-
-  bool operator!=(CFT that) const {
-    return object_ != that;
-  }
-
-  operator CFT() const {
-    return object_;
-  }
-
-  CFT get() const {
-    return object_;
+template <typename CFT>
+struct ScopedCFTypeRefTraits {
+  static CFT InvalidValue() { return nullptr; }
+  static CFT Retain(CFT object) {
+    CFRetain(object);
+    return object;
   }
+  static void Release(CFT object) { CFRelease(object); }
+};
 
-  void swap(ScopedCFTypeRef& that) {
-    CFT temp = that.object_;
-    that.object_ = object_;
-    object_ = temp;
-  }
+}  // namespace internal
 
-  // ScopedCFTypeRef<>::release() is like scoped_ptr<>::release.  It is NOT
-  // a wrapper for CFRelease().  To force a ScopedCFTypeRef<> object to call
-  // CFRelease(), use ScopedCFTypeRef<>::reset().
-  CFT release() WARN_UNUSED_RESULT {
-    CFT temp = object_;
-    object_ = NULL;
-    return temp;
-  }
-
- private:
-  CFT object_;
-};
+template <typename CFT>
+using ScopedCFTypeRef =
+    ScopedTypeRef<CFT, internal::ScopedCFTypeRefTraits<CFT>>;
 
 }  // namespace base