zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reland of move all reference to carbon api (patchset #1 id:1 of https://codereview.webrtc.org/2316563002/ )

Browse Source 
Reason for revert:
Chromium build issues have been resolved.

Original issue's description:
> Revert of Remove all reference to carbon api (patchset #2 id:20001 of https://codereview.webrtc.org/2299633002/ )
>
> Reason for revert:
> Breaks chromium build
>
> Original issue's description:
> > Remove all reference to carbon api
> >
> > BUG=webrtc:6282
> >
> > Committed: https://crrev.com/dbd8b6bec4143c940b2f2ca8cd85c25d17327964
> > Cr-Commit-Position: refs/heads/master@{#14080}
>
> TBR=magjed@webrtc.org,mflodman@webrtc.org
> # Skipping CQ checks because original CL landed less than 1 days ago.
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
> BUG=webrtc:6282
>
> Committed: https://crrev.com/b096aa7fd375a980daab3a986596548ca5de2a1c
> Cr-Commit-Position: refs/heads/master@{#14081}

TBR=magjed@webrtc.org,mflodman@webrtc.org
# Not skipping CQ checks because original CL landed more than 1 days ago.
BUG=webrtc:6282

Review-Url: https://codereview.webrtc.org/2321493002
Cr-Commit-Position: refs/heads/master@{#14125}
This commit is contained in:
kthelgason
2016-09-08 03:34:40 -07:00
committed by Commit bot
parent 71eb61cf37
commit a90879b64f
21 changed files with 27 additions and 842 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
webrtc/base/BUILD.gn
View File

@ -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",

12
webrtc/base/iosfilesystem.mm → webrtc/base/applefilesystem.mm
View File

@ -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,7 +33,7 @@ static char* copyString(NSString* s) {
}
// 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);
@ -41,13 +41,13 @@ char* IOSDataDirectory() {
}
// 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]);
}

20
webrtc/base/base.gyp
View File

@ -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',

171
webrtc/base/macsocketserver.cc
View File

@ -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

59
webrtc/base/macsocketserver.h
View File

@ -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__

74
webrtc/base/macsocketserver_unittest.cc
View File

@ -31,64 +31,6 @@ class WakeThread : public Thread {
SocketServer* ss_;
};
#ifndef CARBON_DEPRECATED
// Test that MacCFSocketServer::Wait works as expected.
TEST(MacCFSocketServerTest, TestWait) {
MacCFSocketServer server;
uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
}
// Test that MacCFSocketServer::Wakeup works as expected.
TEST(MacCFSocketServerTest, TestWakeup) {
MacCFSocketServer server;
WakeThread thread(&server);
uint32_t start = Time();
thread.Start();
server.Wait(10000, true);
EXPECT_LT(TimeSince(start), 10000);
}
// Test that MacCarbonSocketServer::Wait works as expected.
TEST(MacCarbonSocketServerTest, TestWait) {
MacCarbonSocketServer server;
uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
}
// Test that MacCarbonSocketServer::Wakeup works as expected.
TEST(MacCarbonSocketServerTest, TestWakeup) {
MacCarbonSocketServer server;
WakeThread thread(&server);
uint32_t start = Time();
thread.Start();
server.Wait(10000, true);
EXPECT_LT(TimeSince(start), 10000);
}
// Test that MacCarbonAppSocketServer::Wait works as expected.
TEST(MacCarbonAppSocketServerTest, TestWait) {
MacCarbonAppSocketServer server;
uint32_t start = Time();
server.Wait(1000, true);
EXPECT_GE(TimeSince(start), 1000);
}
// Test that MacCarbonAppSocketServer::Wakeup works as expected.
TEST(MacCarbonAppSocketServerTest, TestWakeup) {
MacCarbonAppSocketServer server;
WakeThread thread(&server);
uint32_t start = Time();
thread.Start();
server.Wait(10000, true);
EXPECT_LT(TimeSince(start), 10000);
}
#endif
// Test that MacAsyncSocket passes all the generic Socket tests.
class MacAsyncSocketTest : public SocketTest {
protected:
@ -220,20 +162,4 @@ TEST_F(MacAsyncSocketTest, DISABLED_TestGetSetOptionsIPv4) {
TEST_F(MacAsyncSocketTest, DISABLED_TestGetSetOptionsIPv6) {
SocketTest::TestGetSetOptionsIPv6();
}
#ifndef CARBON_DEPRECATED
class MacCarbonAppAsyncSocketTest : public MacAsyncSocketTest {
virtual MacBaseSocketServer* CreateSocketServer() {
return new MacCarbonAppSocketServer();
};
};
TEST_F(MacCarbonAppAsyncSocketTest, TestSocketServerWaitIPv4) {
SocketTest::TestSocketServerWaitIPv4();
}
TEST_F(MacCarbonAppAsyncSocketTest, TestSocketServerWaitIPv6) {
SocketTest::TestSocketServerWaitIPv6();
}
#endif
} // namespace rtc

81
webrtc/base/macutils.cc
View File

@ -11,6 +11,8 @@
#include <memory>
#include <sstream>
#include <CoreServices/CoreServices.h>
#include "webrtc/base/common.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/macutils.h"
@ -46,7 +48,6 @@ bool ToUtf16(const std::string& str8, CFStringRef* str16) {
return NULL != *str16;
}
#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
void DecodeFourChar(UInt32 fc, std::string* out) {
std::stringstream ss;
ss << '\'';
@ -128,82 +129,4 @@ MacOSVersionName GetOSVersionName() {
}
return kMacOSNewer;
}
bool RunAppleScript(const std::string& script) {
// TODO(thaloun): Add a .mm file that contains something like this:
// NSString source from script
// NSAppleScript* appleScript = [[NSAppleScript alloc] initWithSource:&source]
// if (appleScript != nil) {
// [appleScript executeAndReturnError:nil]
// [appleScript release]
#ifndef CARBON_DEPRECATED
ComponentInstance component = NULL;
AEDesc script_desc;
AEDesc result_data;
OSStatus err;
OSAID script_id, result_id;
AECreateDesc(typeNull, NULL, 0, &script_desc);
AECreateDesc(typeNull, NULL, 0, &result_data);
script_id = kOSANullScript;
result_id = kOSANullScript;
component = OpenDefaultComponent(kOSAComponentType, typeAppleScript);
if (component == NULL) {
LOG(LS_ERROR) << "Failed opening Apple Script component";
return false;
}
err = AECreateDesc(typeUTF8Text, script.data(), script.size(), &script_desc);
if (err != noErr) {
CloseComponent(component);
LOG(LS_ERROR) << "Failed creating Apple Script description";
return false;
}
err = OSACompile(component, &script_desc, kOSAModeCanInteract, &script_id);
if (err != noErr) {
AEDisposeDesc(&script_desc);
if (script_id != kOSANullScript) {
OSADispose(component, script_id);
}
CloseComponent(component);
LOG(LS_ERROR) << "Error compiling Apple Script";
return false;
}
err = OSAExecute(component, script_id, kOSANullScript, kOSAModeCanInteract,
&result_id);
if (err == errOSAScriptError) {
LOG(LS_ERROR) << "Error when executing Apple Script: " << script;
AECreateDesc(typeNull, NULL, 0, &result_data);
OSAScriptError(component, kOSAErrorMessage, typeChar, &result_data);
int len = AEGetDescDataSize(&result_data);
char* data = (char*)malloc(len);
if (data != NULL) {
err = AEGetDescData(&result_data, data, len);
LOG(LS_ERROR) << "Script error: " << std::string(data, len);
}
AEDisposeDesc(&script_desc);
AEDisposeDesc(&result_data);
return false;
}
AEDisposeDesc(&script_desc);
if (script_id != kOSANullScript) {
OSADispose(component, script_id);
}
if (result_id != kOSANullScript) {
OSADispose(component, result_id);
}
CloseComponent(component);
return true;
#else
// TODO(thaloun): Support applescripts with the NSAppleScript API.
return false;
#endif // CARBON_DEPRECATED
}
#endif // WEBRTC_MAC && !defined(WEBRTC_IOS)
///////////////////////////////////////////////////////////////////////////////
} // namespace rtc

7
webrtc/base/macutils.h
View File

@ -12,9 +12,6 @@
#define WEBRTC_BASE_MACUTILS_H__
#include <CoreFoundation/CoreFoundation.h>
#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
#include <Carbon/Carbon.h>
#endif
#include <string>
namespace rtc {
@ -44,10 +41,6 @@ enum MacOSVersionName {
};
MacOSVersionName GetOSVersionName();
// Runs the given apple script. Only supports scripts that does not
// require user interaction.
bool RunAppleScript(const std::string& script);
#endif
///////////////////////////////////////////////////////////////////////////////

19
webrtc/base/macutils_unittest.cc
View File

@ -16,22 +16,3 @@ TEST(MacUtilsTest, GetOsVersionName) {
LOG(LS_INFO) << "GetOsVersionName " << ver;
EXPECT_NE(rtc::kMacOSUnknown, ver);
}
TEST(MacUtilsTest, RunAppleScriptCompileError) {
std::string script("set value to to 5");
EXPECT_FALSE(rtc::RunAppleScript(script));
}
TEST(MacUtilsTest, RunAppleScriptRuntimeError) {
std::string script("set value to 5 / 0");
EXPECT_FALSE(rtc::RunAppleScript(script));
}
#ifdef CARBON_DEPRECATED
TEST(MacUtilsTest, DISABLED_RunAppleScriptSuccess) {
#else
TEST(MacUtilsTest, RunAppleScriptSuccess) {
#endif
std::string script("set value to 5");
EXPECT_TRUE(rtc::RunAppleScript(script));
}

69
webrtc/base/macwindowpicker.cc
View File

@ -106,74 +106,7 @@ bool MacWindowPicker::IsVisible(const WindowId& id) {
}
bool MacWindowPicker::MoveToFront(const WindowId& id) {
// Init if we're not already initialized.
if (get_window_list_desc_ == NULL && !Init()) {
return false;
}
CGWindowID ids[1];
ids[0] = id.id();
CFArrayRef window_id_array =
CFArrayCreate(NULL, reinterpret_cast<const void **>(&ids), 1, NULL);
CFArrayRef window_array =
reinterpret_cast<CGWindowListCreateDescriptionFromArrayProc>(
get_window_list_desc_)(window_id_array);
if (window_array == NULL || 0 == CFArrayGetCount(window_array)) {
// Could not find the window. It might have been closed.
LOG(LS_INFO) << "Window not found";
CFRelease(window_id_array);
return false;
}
CFDictionaryRef window = reinterpret_cast<CFDictionaryRef>(
CFArrayGetValueAtIndex(window_array, 0));
CFStringRef window_name_ref = reinterpret_cast<CFStringRef>(
CFDictionaryGetValue(window, kCGWindowName));
CFNumberRef application_pid = reinterpret_cast<CFNumberRef>(
CFDictionaryGetValue(window, kCGWindowOwnerPID));
int pid_val;
CFNumberGetValue(application_pid, kCFNumberIntType, &pid_val);
std::string window_name;
ToUtf8(window_name_ref, &window_name);
// Build an applescript that sets the selected window to front
// within the application. Then set the application to front.
bool result = true;
std::stringstream ss;
ss << "tell application \"System Events\"\n"
<< "set proc to the first item of (every process whose unix id is "
<< pid_val
<< ")\n"
<< "tell proc to perform action \"AXRaise\" of window \""
<< window_name
<< "\"\n"
<< "set the frontmost of proc to true\n"
<< "end tell";
if (!RunAppleScript(ss.str())) {
// This might happen to for example X applications where the X
// server spawns of processes with their own PID but the X server
// is still registered as owner to the application windows. As a
// workaround, we put the X server process to front, meaning that
// all X applications will show up. The drawback with this
// workaround is that the application that we really wanted to set
// to front might be behind another X application.
ProcessSerialNumber psn;
pid_t pid = pid_val;
int res = GetProcessForPID(pid, &psn);
if (res != 0) {
LOG(LS_ERROR) << "Failed getting process for pid";
result = false;
}
res = SetFrontProcess(&psn);
if (res != 0) {
LOG(LS_ERROR) << "Failed setting process to front";
result = false;
}
}
CFRelease(window_id_array);
CFRelease(window_array);
return result;
return false;
}
bool MacWindowPicker::GetDesktopList(DesktopDescriptionList* descriptions) {

6
webrtc/base/proxydetect.cc
View File

@ -1170,9 +1170,6 @@ bool GetMacProxySettings(ProxyInfo* proxy) {
result = p_putPasswordInProxyInfo(proxy);
}
// We created the dictionary with something that had the
// word 'copy' in it, so we have to release it, according
// to the Carbon memory management standards.
CFRelease(proxyDict);
} else {
LOG(LS_ERROR) << "SCDynamicStoreCopyProxies failed";
@ -1223,9 +1220,6 @@ bool GetiOSProxySettings(ProxyInfo* proxy) {
result = true;
}
// We created the dictionary with something that had the
// word 'copy' in it, so we have to release it, according
// to the Carbon memory management standards.
CFRelease(proxy_dict);
return result;

51
webrtc/base/unixfilesystem.cc
View File

@ -17,7 +17,7 @@
#include <unistd.h>
#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
#include <Carbon/Carbon.h>
#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOCFBundle.h>
#include <sys/statvfs.h>
#include "webrtc/base/macutils.h"
@ -50,13 +50,13 @@
#include "webrtc/base/stream.h"
#include "webrtc/base/stringutils.h"
#if defined(WEBRTC_IOS)
// Defined in iosfilesystem.mm. No header file to discourage use
#if defined(WEBRTC_MAC)
// Defined in applefilesystem.mm. No header file to discourage use
// elsewhere; other places should use GetApp{Data,Temp}Folder() in
// this file. Don't copy/paste. I mean it.
char* IOSDataDirectory();
char* IOSTempDirectory();
void IOSAppName(rtc::Pathname* path);
char* AppleDataDirectory();
char* AppleTempDirectory();
void AppleAppName(rtc::Pathname* path);
#endif
namespace rtc {
@ -81,9 +81,9 @@ void UnixFilesystem::SetAppTempFolder(const std::string& folder) {
UnixFilesystem::UnixFilesystem() {
#if defined(WEBRTC_IOS)
if (!provided_app_data_folder_)
provided_app_data_folder_ = IOSDataDirectory();
provided_app_data_folder_ = AppleDataDirectory();
if (!provided_app_temp_folder_)
provided_app_temp_folder_ = IOSTempDirectory();
provided_app_temp_folder_ = AppleTempDirectory();
#endif
}
@ -171,19 +171,10 @@ bool UnixFilesystem::DeleteEmptyFolder(const Pathname &folder) {
bool UnixFilesystem::GetTemporaryFolder(Pathname &pathname, bool create,
const std::string *append) {
#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
FSRef fr;
if (0 != FSFindFolder(kOnAppropriateDisk, kTemporaryFolderType,
kCreateFolder, &fr))
return false;
unsigned char buffer[NAME_MAX+1];
if (0 != FSRefMakePath(&fr, buffer, arraysize(buffer)))
return false;
pathname.SetPathname(reinterpret_cast<char*>(buffer), "");
#elif defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
#if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
ASSERT(provided_app_temp_folder_ != NULL);
pathname.SetPathname(provided_app_temp_folder_, "");
#else // !WEBRTC_MAC || WEBRTC_IOS && !WEBRTC_ANDROID
#else
if (const char* tmpdir = getenv("TMPDIR")) {
pathname.SetPathname(tmpdir, "");
} else if (const char* tmp = getenv("TMP")) {
@ -195,7 +186,7 @@ bool UnixFilesystem::GetTemporaryFolder(Pathname &pathname, bool create,
pathname.SetPathname("/tmp/", "");
#endif // !P_tmpdir
}
#endif // !WEBRTC_MAC || WEBRTC_IOS && !WEBRTC_ANDROID
#endif // defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
if (append) {
ASSERT(!append->empty());
pathname.AppendFolder(*append);
@ -357,24 +348,10 @@ bool UnixFilesystem::GetFileTime(const Pathname& path, FileTimeType which,
}
bool UnixFilesystem::GetAppPathname(Pathname* path) {
#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
ProcessSerialNumber psn = { 0, kCurrentProcess };
CFDictionaryRef procinfo = ProcessInformationCopyDictionary(&psn,
kProcessDictionaryIncludeAllInformationMask);
if (NULL == procinfo)
return false;
CFStringRef cfpath = (CFStringRef) CFDictionaryGetValue(procinfo,
kIOBundleExecutableKey);
std::string path8;
bool success = ToUtf8(cfpath, &path8);
CFRelease(procinfo);
if (success)
path->SetPathname(path8);
return success;
#elif defined(__native_client__)
#if defined(__native_client__)
return false;
#elif WEBRTC_IOS
IOSAppName(path);
#elif defined(WEBRTC_MAC)
AppleAppName(path);
return true;
#else // WEBRTC_MAC && !defined(WEBRTC_IOS)
char buffer[PATH_MAX + 2];