Hide NSAutoreleasePool from ARC translation units.

base/message_loop/message_pump_mac.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.
 
 // The basis for all native run loops on the Mac is the CFRunLoop.  It can be
 // used directly, it can be used as the driving force behind the similar
 // Foundation NSRunLoop, and it can be used to implement higher-level event
 // loops such as the NSApplication event loop.
 //
 // This file introduces a basic CFRunLoop-based implementation of the
@@ skipping 20 matching lines @@
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_MAC_H_
 
 #include "base/message_loop/message_pump.h"
 
 #include "base/basictypes.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 
 #include "base/memory/weak_ptr.h"
 
-#if !defined(__OBJC__)
-class NSAutoreleasePool;
-#else  // !defined(__OBJC__)
+#if defined(__OBJC__)
 #if defined(OS_IOS)
 #import <Foundation/Foundation.h>
 #else
 #import <AppKit/AppKit.h>
 
 // Clients must subclass NSApplication and implement this protocol if they use
 // MessagePumpMac.
 @protocol CrAppProtocol
 // Must return true if -[NSApplication sendEvent:] is currently on the stack.
 // See the comment for |CreateAutoreleasePool()| in the cc file for why this is
 // necessary.
 - (BOOL)isHandlingSendEvent;
 @end
 #endif  // !defined(OS_IOS)
-#endif  // !defined(__OBJC__)
+#endif  // defined(__OBJC__)
 
 namespace base {
 
 class MessagePumpInstrumentation;
 class RunLoop;
 class TimeTicks;
 
+// AutoreleasePoolType is a proxy type for autorelease pools. Its definition
+// depends on the TU in which this header appears. In pure C++ TUs, it is

[Mark Mentovai, 2014/04/29 02:07:03]

TU is not a commonly-understood abbreviation. Say “translation unit” the first
time, and you can leave the rest as TU.

+// defined as a forward C++ class declaration (that is never defined), because
+// autorelease pools are an Objective-C concept. In Automatic Reference Counting
+// (ARC) Objective-C TUs, it is similarly defined as a forward C++ class
+// declaration, because clang will not allow the type "NSAutoreleasePool" in
+// such TUs. Finally, in Manual Retain Release (MRR) Objective-C TUs, it is a
+// type alias for NSAutoreleasePool. In all cases, a method that takes or
+// returns an NSAutoreleasePool* can use AutoreleasePoolType* instead.
+#if !defined(__OBJC__) || __has_feature(objc_arc)
+class AutoreleasePoolType;
+#else   // !defined(__OBJC__) || __has_feature(objc_arc)
+typedef NSAutoreleasePool AutoreleasePoolType;
+#endif  // !defined(__OBJC__) || __has_feature(objc_arc)
+
 class MessagePumpCFRunLoopBase : public MessagePump {
   // Needs access to CreateAutoreleasePool.
   friend class MessagePumpScopedAutoreleasePool;
  public:
   MessagePumpCFRunLoopBase();
   virtual ~MessagePumpCFRunLoopBase();
 
   // Subclasses should implement the work they need to do in MessagePump::Run
   // in the DoRun method.  MessagePumpCFRunLoopBase::Run calls DoRun directly.
   // This arrangement is used because MessagePumpCFRunLoopBase needs to set
@@ skipping 11 matching lines @@
   int run_nesting_level() const { return run_nesting_level_; }
 
   // Sets this pump's delegate.  Signals the appropriate sources if
   // |delegateless_work_| is true.  |delegate| can be NULL.
   void SetDelegate(Delegate* delegate);
 
   // Return an autorelease pool to wrap around any work being performed.
   // In some cases, CreateAutoreleasePool may return nil intentionally to
   // preventing an autorelease pool from being created, allowing any
   // objects autoreleased by work to fall into the current autorelease pool.
-  virtual NSAutoreleasePool* CreateAutoreleasePool();
+  virtual AutoreleasePoolType* CreateAutoreleasePool();
 
   // Enables instrumentation of the MessagePump. See MessagePumpInstrumentation
   // in the implementation for details.
   void EnableInstrumentation();
   WeakPtr<MessagePumpInstrumentation> instrumentation_;
 
  private:
   // Timer callback scheduled by ScheduleDelayedWork.  This does not do any
   // work, but it signals work_source_ so that delayed work can be performed
   // within the appropriate priority constraints.
@@ skipping 181 matching lines @@
 };
 
 class MessagePumpCrApplication : public MessagePumpNSApplication {
  public:
   MessagePumpCrApplication();
   virtual ~MessagePumpCrApplication();
 
  protected:
   // Returns nil if NSApp is currently in the middle of calling
   // -sendEvent.  Requires NSApp implementing CrAppProtocol.
-  virtual NSAutoreleasePool* CreateAutoreleasePool() OVERRIDE;
+  virtual AutoreleasePoolType* CreateAutoreleasePool() OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MessagePumpCrApplication);
 };
 #endif  // !defined(OS_IOS)
 
 class MessagePumpMac {
  public:
   // If not on the main thread, returns a new instance of
   // MessagePumpNSRunLoop.
@@ skipping 18 matching lines @@
   BASE_EXPORT static bool IsHandlingSendEvent();
 #endif  // !defined(OS_IOS)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(MessagePumpMac);
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_MAC_H_