pristineio
diff --git a/‎webrtc/BUILD.gn
Lines changed: 0 additions & 7 deletions b/‎webrtc/BUILD.gn
Lines changed: 0 additions & 7 deletions
diff --git a/‎webrtc/base/BUILD.gn
Lines changed: 1 addition & 8 deletions b/‎webrtc/base/BUILD.gn
Lines changed: 1 addition & 8 deletions
diff --git a/‎webrtc/base/iosfilesystem.mm renamed to ‎webrtc/base/applefilesystem.mm
Lines changed: 6 additions & 6 deletions b/‎webrtc/base/iosfilesystem.mm renamed to ‎webrtc/base/applefilesystem.mm
Lines changed: 6 additions & 6 deletions
diff --git a/‎webrtc/base/base.gyp
Lines changed: 1 addition & 19 deletions b/‎webrtc/base/base.gyp
Lines changed: 1 addition & 19 deletions
diff --git a/‎webrtc/base/macsocketserver.cc
Lines changed: 0 additions & 171 deletions b/‎webrtc/base/macsocketserver.cc
Lines changed: 0 additions & 171 deletions
diff --git a/‎webrtc/base/macsocketserver.h
Lines changed: 1 addition & 58 deletions b/‎webrtc/base/macsocketserver.h
Lines changed: 1 addition & 58 deletions
@@ -559,10 +559,6 @@ if (rtc_include_tests) {
         "base/sslstreamadapter_unittest.cc",
       ]
     }
-    if (is_ios || (is_mac && target_cpu != "x86")) {
-      defines = [ "CARBON_DEPRECATED=YES" ]
-    }
-
     if (rtc_use_quic) {
       sources += [
         "p2p/quic/quicconnectionhelper_unittest.cc",
@@ -825,9 +821,6 @@ if (rtc_include_tests) {
     if (is_mac) {
       sources += [ "base/macsocketserver_unittest.cc" ]
     }
-    if (is_ios || (is_mac && target_cpu != "x86")) {
-      defines = [ "CARBON_DEPRECATED=YES" ]
-    }
     if (is_clang) {
       # Suppress warnings from the Chromium Clang plugin.
       # See http://code.google.com/p/webrtc/issues/detail?id=163 for details.
 
@@ -63,9 +63,6 @@ config("rtc_base_all_dependent_config") {
       "Security.framework",
       "SystemConfiguration.framework",
     ]
-    if (current_cpu == "x86") {
-      libs += [ "Carbon.framework" ]
-    }
   }
 }
 
@@ -289,6 +286,7 @@ rtc_static_library("rtc_base") {
   defines = [ "LOGGING=1" ]
 
   sources = [
+    "applefilesystem.mm",
     "arraysize.h",
     "asyncfile.cc",
     "asyncfile.h",
@@ -337,7 +335,6 @@ rtc_static_library("rtc_base") {
     "httpcommon.h",
     "httprequest.cc",
     "httprequest.h",
-    "iosfilesystem.mm",
     "ipaddress.cc",
     "ipaddress.h",
     "linked_ptr.h",
@@ -667,10 +664,6 @@ rtc_static_library("rtc_base") {
     }
   }
 
-  if (is_ios || (is_mac && current_cpu != "x86")) {
-    defines += [ "CARBON_DEPRECATED=YES" ]
-  }
-
   if (is_linux || is_android) {
     sources += [
       "linux.cc",
 
@@ -8,8 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-// This file only exists because various iOS system APIs are only
-// available from Objective-C.  See unixfilesystem.cc for the only use
+// This file only exists because various iOS and macOS system APIs are only
+// available from Objective-C. See unixfilesystem.cc for the only use
 // (enforced by a lack of a header file).
 
 #import <Foundation/NSPathUtilities.h>
@@ -33,21 +33,21 @@
 }
 
 // Return a (leaked) copy of a directory name suitable for application data.
-char* IOSDataDirectory() {
+char* AppleDataDirectory() {
   NSArray* paths = NSSearchPathForDirectoriesInDomains(
       NSApplicationSupportDirectory, NSUserDomainMask, YES);
   ASSERT([paths count] == 1);
   return copyString([paths objectAtIndex:0]);
 }
 
 // Return a (leaked) copy of a directory name suitable for use as a $TEMP.
-char* IOSTempDirectory() {
+char* AppleTempDirectory() {
   return copyString(NSTemporaryDirectory());
 }
 
 // Return the binary's path.
-void IOSAppName(rtc::Pathname* path) {
-  NSProcessInfo *pInfo = [NSProcessInfo processInfo];
+void AppleAppName(rtc::Pathname* path) {
+  NSProcessInfo* pInfo = [NSProcessInfo processInfo];
   NSString* argv0 = [[pInfo arguments] objectAtIndex:0];
   path->SetPathname([argv0 UTF8String]);
 }
@@ -229,6 +229,7 @@
         'LOGGING=1',
       ],
       'sources': [
+        'applefilesystem.mm',
         'arraysize.h',
         'asyncfile.cc',
         'asyncfile.h',
@@ -277,7 +278,6 @@
         'httpcommon.h',
         'httprequest.cc',
         'httprequest.h',
-        'iosfilesystem.mm',
         'ipaddress.cc',
         'ipaddress.h',
         'linked_ptr.h',
@@ -603,19 +603,6 @@
               },
             },
           },
-          'conditions': [
-            ['target_arch=="ia32"', {
-              'all_dependent_settings': {
-                'link_settings': {
-                  'xcode_settings': {
-                    'OTHER_LDFLAGS': [
-                      '-framework Carbon',
-                    ],
-                  },
-                },
-              },
-            }],
-          ],
         }],
         ['OS=="win" and nacl_untrusted_build==0', {
           'sources': [
@@ -664,11 +651,6 @@
             },
           }
         }],
-        ['OS=="ios" or (OS=="mac" and target_arch!="ia32")', {
-          'defines': [
-            'CARBON_DEPRECATED=YES',
-          ],
-        }],
         ['OS=="linux" or OS=="android"', {
           'sources': [
             'linux.cc',
 
@@ -212,175 +212,4 @@ void MacCFSocketServer::OnWakeUpCallback() {
   ASSERT(run_loop_ == CFRunLoopGetCurrent());
   CFRunLoopStop(run_loop_);
 }
-
-///////////////////////////////////////////////////////////////////////////////
-// MacCarbonSocketServer
-///////////////////////////////////////////////////////////////////////////////
-#ifndef CARBON_DEPRECATED
-
-const UInt32 kEventClassSocketServer = 'MCSS';
-const UInt32 kEventWakeUp = 'WAKE';
-const EventTypeSpec kEventWakeUpSpec[] = {
-  { kEventClassSocketServer, kEventWakeUp }
-};
-
-std::string DecodeEvent(EventRef event) {
-  std::string str;
-  DecodeFourChar(::GetEventClass(event), &str);
-  str.push_back(':');
-  DecodeFourChar(::GetEventKind(event), &str);
-  return str;
-}
-
-MacCarbonSocketServer::MacCarbonSocketServer()
-    : event_queue_(GetCurrentEventQueue()), wake_up_(NULL) {
-  VERIFY(noErr == CreateEvent(NULL, kEventClassSocketServer, kEventWakeUp, 0,
-                              kEventAttributeUserEvent, &wake_up_));
-}
-
-MacCarbonSocketServer::~MacCarbonSocketServer() {
-  if (wake_up_) {
-    ReleaseEvent(wake_up_);
-  }
-}
-
-bool MacCarbonSocketServer::Wait(int cms, bool process_io) {
-  ASSERT(GetCurrentEventQueue() == event_queue_);
-
-  // Listen to all events if we're processing I/O.
-  // Only listen for our wakeup event if we're not.
-  UInt32 num_types = 0;
-  const EventTypeSpec* events = NULL;
-  if (!process_io) {
-    num_types = GetEventTypeCount(kEventWakeUpSpec);
-    events = kEventWakeUpSpec;
-  }
-
-  EventTargetRef target = GetEventDispatcherTarget();
-  EventTimeout timeout =
-      (kForever == cms) ? kEventDurationForever : cms / 1000.0;
-  EventTimeout end_time = GetCurrentEventTime() + timeout;
-
-  bool done = false;
-  while (!done) {
-    EventRef event;
-    OSStatus result = ReceiveNextEvent(num_types, events, timeout, true,
-                                       &event);
-    if (noErr == result) {
-      if (wake_up_ != event) {
-        LOG_F(LS_VERBOSE) << "Dispatching event: " << DecodeEvent(event);
-        result = SendEventToEventTarget(event, target);
-        if ((noErr != result) && (eventNotHandledErr != result)) {
-          LOG_E(LS_ERROR, OS, result) << "SendEventToEventTarget";
-        }
-      } else {
-        done = true;
-      }
-      ReleaseEvent(event);
-    } else if (eventLoopTimedOutErr == result) {
-      ASSERT(cms != kForever);
-      done = true;
-    } else if (eventLoopQuitErr == result) {
-      // Ignore this... we get spurious quits for a variety of reasons.
-      LOG_E(LS_VERBOSE, OS, result) << "ReceiveNextEvent";
-    } else {
-      // Some strange error occurred. Log it.
-      LOG_E(LS_WARNING, OS, result) << "ReceiveNextEvent";
-      return false;
-    }
-    if (kForever != cms) {
-      timeout = end_time - GetCurrentEventTime();
-    }
-  }
-  return true;
-}
-
-void MacCarbonSocketServer::WakeUp() {
-  if (!IsEventInQueue(event_queue_, wake_up_)) {
-    RetainEvent(wake_up_);
-    OSStatus result = PostEventToQueue(event_queue_, wake_up_,
-                                       kEventPriorityStandard);
-    if (noErr != result) {
-      LOG_E(LS_ERROR, OS, result) << "PostEventToQueue";
-    }
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// MacCarbonAppSocketServer
-///////////////////////////////////////////////////////////////////////////////
-
-MacCarbonAppSocketServer::MacCarbonAppSocketServer()
-    : event_queue_(GetCurrentEventQueue()) {
-  // Install event handler
-  VERIFY(noErr == InstallApplicationEventHandler(
-      NewEventHandlerUPP(WakeUpEventHandler), 1, kEventWakeUpSpec, this,
-      &event_handler_));
-
-  // Install a timer and set it idle to begin with.
-  VERIFY(noErr == InstallEventLoopTimer(GetMainEventLoop(),
-                                        kEventDurationForever,
-                                        kEventDurationForever,
-                                        NewEventLoopTimerUPP(TimerHandler),
-                                        this,
-                                        &timer_));
-}
-
-MacCarbonAppSocketServer::~MacCarbonAppSocketServer() {
-  RemoveEventLoopTimer(timer_);
-  RemoveEventHandler(event_handler_);
-}
-
-OSStatus MacCarbonAppSocketServer::WakeUpEventHandler(
-    EventHandlerCallRef next, EventRef event, void *data) {
-  QuitApplicationEventLoop();
-  return noErr;
-}
-
-void MacCarbonAppSocketServer::TimerHandler(
-    EventLoopTimerRef timer, void *data) {
-  QuitApplicationEventLoop();
-}
-
-bool MacCarbonAppSocketServer::Wait(int cms, bool process_io) {
-  if (!process_io && cms == 0) {
-    // No op.
-    return true;
-  }
-  if (kForever != cms) {
-    // Start a timer.
-    OSStatus error =
-        SetEventLoopTimerNextFireTime(timer_, cms / 1000.0);
-    if (error != noErr) {
-      LOG(LS_ERROR) << "Failed setting next fire time.";
-    }
-  }
-  if (!process_io) {
-    // No way to listen to common modes and not get socket events, unless
-    // we disable each one's callbacks.
-    EnableSocketCallbacks(false);
-  }
-  RunApplicationEventLoop();
-  if (!process_io) {
-    // Reenable them.  Hopefully this won't cause spurious callbacks or
-    // missing ones while they were disabled.
-    EnableSocketCallbacks(true);
-  }
-  return true;
-}
-
-void MacCarbonAppSocketServer::WakeUp() {
-  // TODO: No-op if there's already a WakeUp in flight.
-  EventRef wake_up;
-  VERIFY(noErr == CreateEvent(NULL, kEventClassSocketServer, kEventWakeUp, 0,
-                              kEventAttributeUserEvent, &wake_up));
-  OSStatus result = PostEventToQueue(event_queue_, wake_up,
-                                       kEventPriorityStandard);
-  if (noErr != result) {
-    LOG_E(LS_ERROR, OS, result) << "PostEventToQueue";
-  }
-  ReleaseEvent(wake_up);
-}
-
-#endif
 } // namespace rtc
@@ -11,9 +11,7 @@
 #define WEBRTC_BASE_MACSOCKETSERVER_H__
 
 #include <set>
-#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) // Invalid on IOS
-#include <Carbon/Carbon.h>
-#endif
+#include <CoreFoundation/CoreFoundation.h>
 #include "webrtc/base/physicalsocketserver.h"
 
 namespace rtc {
@@ -76,61 +74,6 @@ class MacCFSocketServer : public MacBaseSocketServer {
   CFRunLoopRef run_loop_;
   CFRunLoopSourceRef wake_up_;
 };
-
-#ifndef CARBON_DEPRECATED
-
-///////////////////////////////////////////////////////////////////////////////
-// MacCarbonSocketServer
-///////////////////////////////////////////////////////////////////////////////
-
-// Interacts with the Carbon event queue. While idle it will block,
-// waiting for events. When the socket server has work to do, it will
-// post a 'wake up' event to the queue, causing the thread to exit the
-// event loop until the next call to Wait. Other events are dispatched
-// to their target. Supports Carbon and Cocoa UI interaction.
-class MacCarbonSocketServer : public MacBaseSocketServer {
- public:
-  MacCarbonSocketServer();
-  virtual ~MacCarbonSocketServer();
-
-  // SocketServer Interface
-  virtual bool Wait(int cms, bool process_io);
-  virtual void WakeUp();
-
- private:
-  EventQueueRef event_queue_;
-  EventRef wake_up_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// MacCarbonAppSocketServer
-///////////////////////////////////////////////////////////////////////////////
-
-// Runs the Carbon application event loop on the current thread while
-// idle. When the socket server has work to do, it will post an event
-// to the queue, causing the thread to exit the event loop until the
-// next call to Wait. Other events are automatically dispatched to
-// their target.
-class MacCarbonAppSocketServer : public MacBaseSocketServer {
- public:
-  MacCarbonAppSocketServer();
-  virtual ~MacCarbonAppSocketServer();
-
-  // SocketServer Interface
-  virtual bool Wait(int cms, bool process_io);
-  virtual void WakeUp();
-
- private:
-  static OSStatus WakeUpEventHandler(EventHandlerCallRef next, EventRef event,
-                                     void *data);
-  static void TimerHandler(EventLoopTimerRef timer, void *data);
-
-  EventQueueRef event_queue_;
-  EventHandlerRef event_handler_;
-  EventLoopTimerRef timer_;
-};
-
-#endif
 } // namespace rtc
 
 #endif  // WEBRTC_BASE_MACSOCKETSERVER_H__