[iOS/OS X] Allow base::scoped_nsobject<> to be used when ARC is enabled.

base/mac/scoped_nsobject.h

 // Copyright (c) 2012 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_NSOBJECT_H_
 #define BASE_MAC_SCOPED_NSOBJECT_H_
 
 #include <type_traits>
 
 // Include NSObject.h directly because Foundation.h pulls in many dependencies.
 // (Approx 100k lines of code versus 1.5k for NSObject.h). scoped_nsobject gets
 // singled out because it is most typically included from other header files.
 #import <Foundation/NSObject.h>
 
 #include "base/compiler_specific.h"
 #include "base/mac/scoped_typeref.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
 @class NSAutoreleasePool;
+#endif
 
 namespace base {
 
 // scoped_nsobject<> is patterned after scoped_ptr<>, but maintains ownership
 // of an NSObject subclass object.  Style deviations here are solely for
 // compatibility with scoped_ptr<>'s interface, with which everyone is already
 // familiar.
 //
 // scoped_nsobject<> 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 scoped_nsobject<>, and relinquishes an
 // ownership claim to that object.  scoped_nsobject<> does not call -retain,
 // callers have to call this manually if appropriate.
 //
 // scoped_nsprotocol<> has the same behavior as scoped_nsobject, but can be used
 // with protocols.
 //
 // scoped_nsobject<> is not to be used for NSAutoreleasePools. For
 // NSAutoreleasePools use ScopedNSAutoreleasePool from
 // scoped_nsautorelease_pool.h instead.
 // We check for bad uses of scoped_nsobject and NSAutoreleasePool at compile
 // time with a template specialization (see below).
 
 namespace internal {
 
+id ScopedNSProtocolTraitsRetain(__unsafe_unretained id obj)
+    __attribute((ns_returns_not_retained));
+id ScopedNSProtocolTraitsAutoRelease(__unsafe_unretained id obj)
+    __attribute((ns_returns_not_retained));
+void ScopedNSProtocolTraitsRelease(__unsafe_unretained id obj);
+
 template <typename NST>
 struct ScopedNSProtocolTraits {
-  static NST InvalidValue() { return nil; }
-  static NST Retain(NST nst) { return [nst retain]; }
-  static void Release(NST nst) { [nst release]; }
+  static NST InvalidValue() __attribute((ns_returns_not_retained)) {

[Nico, 2016/04/04 17:53:45]

is this one needed? [nil retain] is a noop, right?

+    return nil;
+  }
+  static NST Retain(__unsafe_unretained NST nst)

[Nico, 2016/04/04 17:53:45]

`Retain() returns_not_retained` needs a comment on why returns_not_retained is
correct on a method called Retain :-)

+      __attribute((ns_returns_not_retained)) {
+    return ScopedNSProtocolTraitsRetain(nst);
+  }
+  static void Release(__unsafe_unretained NST nst) {
+    ScopedNSProtocolTraitsRelease(nst);
+  }
 };
 
 }  // namespace internal
 
 template <typename NST>
 class scoped_nsprotocol
     : public ScopedTypeRef<NST, internal::ScopedNSProtocolTraits<NST>> {
  public:
   using ScopedTypeRef<NST,
                       internal::ScopedNSProtocolTraits<NST>>::ScopedTypeRef;
 
   // Shift reference to the autorelease pool to be released later.
-  NST autorelease() { return [this->release() autorelease]; }
+  NST autorelease() __attribute((ns_returns_not_retained)) {
+    return internal::ScopedNSProtocolTraitsAutoRelease(this->release());
+  }
 };
 
 // Free functions
 template <class C>
 void swap(scoped_nsprotocol<C>& p1, scoped_nsprotocol<C>& p2) {
   p1.swap(p2);
 }
 
 template <class C>
 bool operator==(C p1, const scoped_nsprotocol<C>& p2) {
   return p1 == p2.get();
 }
 
 template <class C>
 bool operator!=(C p1, const scoped_nsprotocol<C>& p2) {
   return p1 != p2.get();
 }
 
 template <typename NST>
 class scoped_nsobject : public scoped_nsprotocol<NST*> {

[Nico, 2016/04/04 17:53:45]

in arc mode, you probably want to add a static_assert(policy == RETAIN)
somewhere, if that's a requirement.

It seems like a somewhat unfortunate requirement.

  public:
   using scoped_nsprotocol<NST*>::scoped_nsprotocol;
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
   static_assert(std::is_same<NST, NSAutoreleasePool>::value == false,
                 "Use ScopedNSAutoreleasePool instead");
+#endif
 };
 
 // Specialization to make scoped_nsobject<id> work.
 template<>
 class scoped_nsobject<id> : public scoped_nsprotocol<id> {
  public:
   using scoped_nsprotocol<id>::scoped_nsprotocol;
 };
 
 }  // namespace base
 
 #endif  // BASE_MAC_SCOPED_NSOBJECT_H_