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

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"
@@ skipping 36 matching lines @@
 
 template<typename T>
 struct ScopedTypeRefTraits;
 
 template<typename T, typename Traits = ScopedTypeRefTraits<T>>
 class ScopedTypeRef {
  public:
   typedef T element_type;
 
   ScopedTypeRef(
-      T object = Traits::InvalidValue(),
+      __unsafe_unretained T object = Traits::InvalidValue(),
       base::scoped_policy::OwnershipPolicy policy = base::scoped_policy::ASSUME)
       : object_(object) {
     if (object_ && policy == base::scoped_policy::RETAIN)
       object_ = Traits::Retain(object_);
   }
 
   ScopedTypeRef(const ScopedTypeRef<T, Traits>& that)
       : object_(that.object_) {
     if (object_)
       object_ = Traits::Retain(object_);
@@ skipping 24 matching lines @@
   }
 
   // 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(),
+  void reset(__unsafe_unretained T object = Traits::InvalidValue(),
              base::scoped_policy::OwnershipPolicy policy =
-                base::scoped_policy::ASSUME) {
+                 base::scoped_policy::ASSUME) {
     if (object && policy == base::scoped_policy::RETAIN)
       object = Traits::Retain(object);
     if (object_)
       Traits::Release(object_);
     object_ = object;
   }
 
-  bool operator==(T that) const {
-    return object_ == that;
-  }
+  bool operator==(__unsafe_unretained T that) const { return object_ == that; }
 
-  bool operator!=(T that) const {
-    return object_ != that;
-  }
+  bool operator!=(__unsafe_unretained T that) const { return object_ != that; }
 
-  operator T() const {
-    return object_;
-  }
+  operator T() const __attribute((ns_returns_not_retained)) { return object_; }
 
-  T get() const {
-    return object_;
-  }
+  T get() const __attribute((ns_returns_not_retained)) { return object_; }
 
   void swap(ScopedTypeRef& that) {
-    T temp = that.object_;
+    __unsafe_unretained T temp = that.object_;
     that.object_ = object_;
     object_ = temp;
   }
 
   // ScopedTypeRef<>::release() is like scoped_ptr<>::release.  It is NOT
   // a wrapper for Release().  To force a ScopedTypeRef<> object to call
   // Release(), use ScopedTypeRef<>::reset().
-  T release() WARN_UNUSED_RESULT {
-    T temp = object_;
+  T release() __attribute((ns_returns_not_retained)) WARN_UNUSED_RESULT {
+    __unsafe_unretained T temp = object_;
     object_ = Traits::InvalidValue();
     return temp;
   }
 
  private:
-  T object_;
+  __unsafe_unretained T object_;
 };
 
 }  // namespace base
 
 #endif  // BASE_MAC_SCOPED_TYPEREF_H_