Rewrite most of the scopers in //base/mac to use ScopedTypeRef or ScopedGeneric.

base/mac/scoped_typeref.h

 // Copyright 2014 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_MAC_SCOPED_TYPEREF_H_
 #define BASE_MAC_SCOPED_TYPEREF_H_
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_policy.h"
 
 namespace base {
 
 // ScopedTypeRef<> is patterned after scoped_ptr<>, but maintains a ownership
 // of a reference to any type that is maintained by Retain and Release methods.
 //
 // The Traits structure must provide the Retain and Release methods for type T.
 // A default ScopedTypeRefTraits is used but not defined, and should be defined
 // for each type to use this interface. For example, an appropriate definition
 // of ScopedTypeRefTraits for CGLContextObj would be:
 //
 //   template<>
 //   struct ScopedTypeRefTraits<CGLContextObj> {
 //     static CGLContextObj InvalidValue() { return nullptr; }
-//     static void Retain(CGLContextObj object) { CGLContextRetain(object); }
+//     static CGLContextObj Retain(CGLContextObj object) {

[Mark Mentovai, 2016/01/04 16:09:23]

I think it’s easier to have these return void and consolidate the object_ =
object setting all in this one file, rather than making all of the traits have
to use an extra line. In practice, the extra line in the traits turns into three
extra lines as it did in this example.

Simpler traits are better than more-elegant internals, and I don’t think
you have any traits where the retain function returns something other than its
parameter anyway.

[Robert Sesek, 2016/01/04 16:11:52]

I had to make this change for ScopedBlock, since there's only Block_copy (which
creates a new heap block, potentially from a stack block) not a Block_retain.

+//       CGLContextRetain(object);
+//       return object;
+//     }
 //     static void Release(CGLContextObj object) { CGLContextRelease(object); }
 //   };
 //
 // For the many types that have pass-by-pointer create functions, the function
 // InitializeInto() is provided to allow direct initialization and assumption
 // of ownership of the object. For example, continuing to use the above
 // CGLContextObj specialization:
 //
 //   base::ScopedTypeRef<CGLContextObj> context;
 //   CGLCreateContext(pixel_format, share_group, context.InitializeInto());
@@ skipping 12 matching lines @@
 template<typename T, typename Traits = ScopedTypeRefTraits<T>>
 class ScopedTypeRef {
  public:
   typedef T element_type;
 
   ScopedTypeRef(
       T object = Traits::InvalidValue(),
       base::scoped_policy::OwnershipPolicy policy = base::scoped_policy::ASSUME)
       : object_(object) {
     if (object_ && policy == base::scoped_policy::RETAIN)
-      Traits::Retain(object_);
+      object_ = Traits::Retain(object_);
   }
 
   ScopedTypeRef(const ScopedTypeRef<T, Traits>& that)
       : object_(that.object_) {
     if (object_)
-      Traits::Retain(object_);
+      object_ = Traits::Retain(object_);
   }
 
   ~ScopedTypeRef() {
     if (object_)
       Traits::Release(object_);
   }
 
   ScopedTypeRef& operator=(const ScopedTypeRef<T, Traits>& that) {
     reset(that.get(), base::scoped_policy::RETAIN);
     return *this;
   }
 
   // This is to be used only to take ownership of objects that are created
   // by pass-by-pointer create functions. To enforce this, require that the
   // object be reset to NULL before this may be used.
   T* InitializeInto() WARN_UNUSED_RESULT {
     DCHECK(!object_);
     return &object_;
   }
 
   void reset(T object = Traits::InvalidValue(),
              base::scoped_policy::OwnershipPolicy policy =
                 base::scoped_policy::ASSUME) {
     if (object && policy == base::scoped_policy::RETAIN)
-      Traits::Retain(object);
+      object = Traits::Retain(object);
     if (object_)
       Traits::Release(object_);
     object_ = object;
   }
 
   bool operator==(T that) const {
     return object_ == that;
   }
 
   bool operator!=(T that) const {
@@ skipping 23 matching lines @@
     return temp;
   }
 
  private:
   T object_;
 };
 
 }  // namespace base
 
 #endif  // BASE_MAC_SCOPED_TYPEREF_H_