base/mac/objc_property_releaser.mm

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #import "base/mac/objc_property_releaser.h"
   6
   7 #import <objc/runtime.h>
   8 #include <stdlib.h>
   9
  10 #include <string>
  11
  12 #include "base/logging.h"
  13
  14 namespace base {
  15 namespace mac {
  16
  17 namespace {
  18
  19 // Returns the name of the instance variable backing the property, if known,
  20 // if the property is marked "retain" or "copy". If the instance variable name
  21 // is not known (perhaps because it was not automatically associated with the
  22 // property by @synthesize) or if the property is not "retain" or "copy",
  23 // returns an empty string.
  24 std::string ReleasableInstanceName(objc_property_t property) {
  25   // TODO(mark): Starting in newer system releases, the Objective-C runtime
  26   // provides a function to break the property attribute string into
  27   // individual attributes (property_copyAttributeList), as well as a function
  28   // to look up the value of a specific attribute
  29   // (property_copyAttributeValue). When the SDK defining that interface is
  30   // final, this function should be adapted to walk the attribute list as
  31   // returned by property_copyAttributeList when that function is available in
  32   // preference to scanning through the attribute list manually.
  33
  34   // The format of the string returned by property_getAttributes is documented
  35   // at
  36   // http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtPropertyIntrospection.html#//apple_ref/doc/uid/TP40008048-CH101-SW6
  37   const char* property_attributes = property_getAttributes(property);
  38
  39   std::string instance_name;
  40   bool releasable = false;
  41   while (*property_attributes) {
  42     char name = *property_attributes;
  43
  44     const char* value = ++property_attributes;
  45     while (*property_attributes && *property_attributes != ',') {
  46       ++property_attributes;
  47     }
  48
  49     switch (name) {
  50       // It might seem intelligent to check the type ('T') attribute to verify
  51       // that it identifies an NSObject-derived type (the attribute value
  52       // begins with '@'.) This is a bad idea beacuse it fails to identify
  53       // CFTypeRef-based properties declared as __attribute__((NSObject)),
  54       // which just show up as pointers to their underlying CFType structs.
  55       //
  56       // Quoting
  57       // http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjectiveC/Chapters/ocProperties.html#//apple_ref/doc/uid/TP30001163-CH17-SW27
  58       //
  59       // > In Mac OS X v10.6 and later, you can use the __attribute__ keyword
  60       // > to specify that a Core Foundation property should be treated like
  61       // > an Objective-C object for memory management:
  62       // >   @property(retain) __attribute__((NSObject)) CFDictionaryRef
  63       // >       myDictionary;
  64       case 'C':  // copy
  65       case '&':  // retain
  66         releasable = true;
  67         break;
  68       case 'V':  // instance variable name
  69         // 'V' is specified as the last attribute to occur in the
  70         // documentation, but empirically, it's not always the last. In
  71         // GC-supported or GC-required code, the 'P' (GC-eligible) attribute
  72         // occurs after 'V'.
  73         instance_name.assign(value, property_attributes - value);
  74         break;
  75     }
  76
  77     if (*property_attributes) {
  78       ++property_attributes;
  79     }
  80   }
  81
  82   if (releasable) {
  83     return instance_name;
  84   }
  85
  86   return std::string();
  87 }
  88
  89 }  // namespace
  90
  91 void ObjCPropertyReleaser::Init(id object, Class classy) {
  92   DCHECK(!object_);
  93   DCHECK(!class_);
  94   CHECK([object isKindOfClass:classy]);
  95
  96   object_ = object;
  97   class_ = classy;
  98 }
  99
 100 void ObjCPropertyReleaser::ReleaseProperties() {
 101   DCHECK(object_);
 102   DCHECK(class_);
 103
 104   unsigned int property_count = 0;
 105   objc_property_t* properties = class_copyPropertyList(class_, &property_count);
 106
 107   for (unsigned int property_index = 0;
 108        property_index < property_count;
 109        ++property_index) {
 110     objc_property_t property = properties[property_index];
 111     std::string instance_name = ReleasableInstanceName(property);
 112     if (!instance_name.empty()) {
 113       id instance_value = nil;
 114       Ivar instance_variable =
 115           object_getInstanceVariable(object_, instance_name.c_str(),
 116                                      (void**)&instance_value);
 117       DCHECK(instance_variable);
 118       [instance_value release];
 119     }
 120   }
 121
 122   free(properties);
 123
 124   // Clear object_ and class_ in case this ObjCPropertyReleaser will live on.
 125   // It's only expected to release the properties it supervises once per Init.
 126   object_ = nil;
 127   class_ = nil;
 128 }
 129
 130 }  // namespace mac
 131 }  // namespace base