mirror of
https://github.com/atom/atom.git
synced 2026-01-25 06:48:28 -05:00
f22fedebcf
This prevents concurrent access to the same state from different worker threads. We needed to treat windowState specially because we explicitly want it to last beyond the life-span of a single context. So we store it as a static variable in `native.mm` and synchronize access with a static `NSLock`. Good enough for now.
530 lines
19 KiB
Plaintext
530 lines
19 KiB
Plaintext
#import <Cocoa/Cocoa.h>
|
|
#import <dispatch/dispatch.h>
|
|
#import <CommonCrypto/CommonDigest.h>
|
|
|
|
#import "atom_application.h"
|
|
#import "native.h"
|
|
#import "include/cef_base.h"
|
|
#import "path_watcher.h"
|
|
|
|
#import <iostream>
|
|
#include <fts.h>
|
|
|
|
static std::string windowState = "{}";
|
|
static NSLock *windowStateLock = [[NSLock alloc] init];
|
|
|
|
namespace v8_extensions {
|
|
using namespace std;
|
|
|
|
NSString *stringFromCefV8Value(const CefRefPtr<CefV8Value>& value);
|
|
void throwException(const CefRefPtr<CefV8Value>& global, CefRefPtr<CefV8Exception> exception, NSString *message);
|
|
|
|
Native::Native() : CefV8Handler() {
|
|
}
|
|
|
|
void Native::CreateContextBinding(CefRefPtr<CefV8Context> context) {
|
|
const char* methodNames[] = {
|
|
"exists", "read", "write", "absolute", "getAllFilePathsAsync", "traverseTree", "isDirectory",
|
|
"isFile", "remove", "writeToPasteboard", "readFromPasteboard", "quit", "watchPath", "unwatchPath",
|
|
"getWatchedPaths", "unwatchAllPaths", "makeDirectory", "move", "moveToTrash", "reload", "lastModified",
|
|
"md5ForPath", "exec", "getPlatform", "setWindowState", "getWindowState"
|
|
};
|
|
|
|
CefRefPtr<CefV8Value> nativeObject = CefV8Value::CreateObject(NULL);
|
|
int arrayLength = sizeof(methodNames) / sizeof(const char *);
|
|
for (int i = 0; i < arrayLength; i++) {
|
|
const char *functionName = methodNames[i];
|
|
CefRefPtr<CefV8Value> function = CefV8Value::CreateFunction(functionName, this);
|
|
nativeObject->SetValue(functionName, function, V8_PROPERTY_ATTRIBUTE_NONE);
|
|
}
|
|
|
|
CefRefPtr<CefV8Value> global = context->GetGlobal();
|
|
global->SetValue("$native", nativeObject, V8_PROPERTY_ATTRIBUTE_NONE);
|
|
}
|
|
|
|
bool Native::Execute(const CefString& name,
|
|
CefRefPtr<CefV8Value> object,
|
|
const CefV8ValueList& arguments,
|
|
CefRefPtr<CefV8Value>& retval,
|
|
CefString& exception) {
|
|
if (name == "exists") {
|
|
std::string cc_value = arguments[0]->GetStringValue().ToString();
|
|
const char *path = cc_value.c_str();
|
|
retval = CefV8Value::CreateBool(access(path, F_OK) == 0);
|
|
|
|
return true;
|
|
}
|
|
else if (name == "read") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
|
|
NSError *error = nil;
|
|
NSStringEncoding *encoding = nil;
|
|
NSString *contents = [NSString stringWithContentsOfFile:path usedEncoding:encoding error:&error];
|
|
|
|
NSError *binaryFileError = nil;
|
|
if (error) {
|
|
contents = [NSString stringWithContentsOfFile:path encoding:NSASCIIStringEncoding error:&binaryFileError];
|
|
}
|
|
|
|
if (binaryFileError) {
|
|
exception = [[binaryFileError localizedDescription] UTF8String];
|
|
}
|
|
else {
|
|
retval = CefV8Value::CreateString([contents UTF8String]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "write") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
NSString *content = stringFromCefV8Value(arguments[1]);
|
|
|
|
NSFileManager *fm = [NSFileManager defaultManager];
|
|
|
|
// Create parent directories if they don't exist
|
|
BOOL exists = [fm fileExistsAtPath:[path stringByDeletingLastPathComponent] isDirectory:nil];
|
|
if (!exists) {
|
|
[fm createDirectoryAtPath:[path stringByDeletingLastPathComponent] withIntermediateDirectories:YES attributes:nil error:nil];
|
|
}
|
|
|
|
NSError *error = nil;
|
|
BOOL success = [content writeToFile:path atomically:YES encoding:NSUTF8StringEncoding error:&error];
|
|
|
|
if (error) {
|
|
exception = [[error localizedDescription] UTF8String];
|
|
}
|
|
else if (!success) {
|
|
std::string exception = "Cannot write to '";
|
|
exception += [path UTF8String];
|
|
exception += "'";
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "absolute") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
|
|
path = [path stringByStandardizingPath];
|
|
if ([path characterAtIndex:0] == '/') {
|
|
retval = CefV8Value::CreateString([path UTF8String]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "getAllFilePathsAsync") {
|
|
std::string argument = arguments[0]->GetStringValue().ToString();
|
|
CefRefPtr<CefV8Value> callback = arguments[1];
|
|
CefRefPtr<CefV8Context> context = CefV8Context::GetCurrentContext();
|
|
|
|
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
|
|
dispatch_async(queue, ^{
|
|
int rootPathLength = argument.size() + 1;
|
|
char rootPath[rootPathLength];
|
|
strcpy(rootPath, argument.c_str());
|
|
char * const treePaths[] = {rootPath, NULL};
|
|
|
|
FTS *tree = fts_open(treePaths, FTS_COMFOLLOW | FTS_PHYSICAL| FTS_NOCHDIR | FTS_NOSTAT, NULL);
|
|
std::vector<std::string> paths;
|
|
|
|
if (tree != NULL) {
|
|
FTSENT *entry;
|
|
int arrayIndex = 0;
|
|
while ((entry = fts_read(tree)) != NULL) {
|
|
if (entry->fts_level == 0) {
|
|
continue;
|
|
}
|
|
|
|
bool isFile = entry->fts_info == FTS_NSOK;
|
|
if (!isFile) {
|
|
continue;
|
|
}
|
|
|
|
int pathLength = entry->fts_pathlen - rootPathLength;
|
|
char relative[pathLength + 1];
|
|
relative[pathLength] = '\0';
|
|
strncpy(relative, entry->fts_path + rootPathLength, pathLength);
|
|
paths.push_back(relative);
|
|
}
|
|
}
|
|
|
|
dispatch_queue_t mainQueue = dispatch_get_main_queue();
|
|
dispatch_async(mainQueue, ^{
|
|
context->Enter();
|
|
CefRefPtr<CefV8Value> v8Paths = CefV8Value::CreateArray(paths.size());
|
|
for (int i = 0; i < paths.size(); i++) {
|
|
v8Paths->SetValue(i, CefV8Value::CreateString(paths[i]));
|
|
}
|
|
CefV8ValueList callbackArgs;
|
|
callbackArgs.push_back(v8Paths);
|
|
callback->ExecuteFunction(callback, callbackArgs);
|
|
context->Exit();
|
|
});
|
|
});
|
|
return true;
|
|
}
|
|
else if (name == "traverseTree") {
|
|
std::string argument = arguments[0]->GetStringValue().ToString();
|
|
int rootPathLength = argument.size() + 1;
|
|
char rootPath[rootPathLength];
|
|
strcpy(rootPath, argument.c_str());
|
|
char * const paths[] = {rootPath, NULL};
|
|
|
|
FTS *tree = fts_open(paths, FTS_COMFOLLOW | FTS_PHYSICAL| FTS_NOCHDIR | FTS_NOSTAT, NULL);
|
|
if (tree == NULL) {
|
|
return true;
|
|
}
|
|
|
|
CefRefPtr<CefV8Value> onFile = arguments[1];
|
|
CefRefPtr<CefV8Value> onDir = arguments[2];
|
|
CefV8ValueList args;
|
|
FTSENT *entry;
|
|
while ((entry = fts_read(tree)) != NULL) {
|
|
if (entry->fts_level == 0) {
|
|
continue;
|
|
}
|
|
|
|
bool isFile = entry->fts_info == FTS_NSOK;
|
|
bool isDir = entry->fts_info == FTS_D;
|
|
if (!isFile && !isDir) {
|
|
continue;
|
|
}
|
|
|
|
int pathLength = entry->fts_pathlen - rootPathLength;
|
|
char relative[pathLength + 1];
|
|
relative[pathLength] = '\0';
|
|
strncpy(relative, entry->fts_path + rootPathLength, pathLength);
|
|
args.clear();
|
|
args.push_back(CefV8Value::CreateString(relative));
|
|
if (isFile) {
|
|
onFile->ExecuteFunction(onFile, args);
|
|
}
|
|
else {
|
|
CefRefPtr<CefV8Value> enterDir = onDir->ExecuteFunction(onDir, args);
|
|
if(enterDir != NULL && !enterDir->GetBoolValue()) {
|
|
fts_set(tree, entry, FTS_SKIP);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "isDirectory") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
|
|
BOOL isDir = false;
|
|
BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:&isDir];
|
|
retval = CefV8Value::CreateBool(exists && isDir);
|
|
|
|
return true;
|
|
}
|
|
else if (name == "isFile") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
|
|
BOOL isDir = false;
|
|
BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:&isDir];
|
|
retval = CefV8Value::CreateBool(exists && !isDir);
|
|
|
|
return true;
|
|
}
|
|
else if (name == "remove") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
|
|
NSError *error = nil;
|
|
[[NSFileManager defaultManager] removeItemAtPath:path error:&error];
|
|
|
|
if (error) {
|
|
exception = [[error localizedDescription] UTF8String];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "writeToPasteboard") {
|
|
NSString *text = stringFromCefV8Value(arguments[0]);
|
|
|
|
NSPasteboard *pb = [NSPasteboard generalPasteboard];
|
|
[pb declareTypes:[NSArray arrayWithObjects:NSStringPboardType, nil] owner:nil];
|
|
[pb setString:text forType:NSStringPboardType];
|
|
|
|
return true;
|
|
}
|
|
else if (name == "readFromPasteboard") {
|
|
NSPasteboard *pb = [NSPasteboard generalPasteboard];
|
|
NSArray *results = [pb readObjectsForClasses:[NSArray arrayWithObjects:[NSString class], nil] options:nil];
|
|
if (results) {
|
|
retval = CefV8Value::CreateString([[results objectAtIndex:0] UTF8String]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "quit") {
|
|
[NSApp terminate:nil];
|
|
return true;
|
|
}
|
|
else if (name == "watchPath") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
CefRefPtr<CefV8Value> function = arguments[1];
|
|
|
|
CefRefPtr<CefV8Context> context = CefV8Context::GetCurrentContext();
|
|
|
|
WatchCallback callback = ^(NSString *eventType, NSString *path) {
|
|
context->Enter();
|
|
|
|
CefV8ValueList args;
|
|
|
|
args.push_back(CefV8Value::CreateString(std::string([eventType UTF8String], [eventType lengthOfBytesUsingEncoding:NSUTF8StringEncoding])));
|
|
args.push_back(CefV8Value::CreateString(std::string([path UTF8String], [path lengthOfBytesUsingEncoding:NSUTF8StringEncoding])));
|
|
function->ExecuteFunction(function, args);
|
|
|
|
context->Exit();
|
|
};
|
|
|
|
PathWatcher *pathWatcher = [PathWatcher pathWatcherForContext:CefV8Context::GetCurrentContext()];
|
|
NSString *watchId = [pathWatcher watchPath:path callback:[[callback copy] autorelease]];
|
|
if (watchId) {
|
|
retval = CefV8Value::CreateString([watchId UTF8String]);
|
|
}
|
|
else {
|
|
exception = std::string("Failed to watch path '") + std::string([path UTF8String]) + std::string("' (it may not exist)");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "unwatchPath") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
NSString *callbackId = stringFromCefV8Value(arguments[1]);
|
|
NSError *error = nil;
|
|
PathWatcher *pathWatcher = [PathWatcher pathWatcherForContext:CefV8Context::GetCurrentContext()];
|
|
[pathWatcher unwatchPath:path callbackId:callbackId error:&error];
|
|
|
|
if (error) {
|
|
exception = [[error localizedDescription] UTF8String];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "getWatchedPaths") {
|
|
PathWatcher *pathWatcher = [PathWatcher pathWatcherForContext:CefV8Context::GetCurrentContext()];
|
|
NSArray *paths = [pathWatcher watchedPaths];
|
|
|
|
CefRefPtr<CefV8Value> pathsArray = CefV8Value::CreateArray([paths count]);
|
|
|
|
for (int i = 0; i < [paths count]; i++) {
|
|
CefRefPtr<CefV8Value> path = CefV8Value::CreateString([[paths objectAtIndex:i] UTF8String]);
|
|
pathsArray->SetValue(i, path);
|
|
}
|
|
retval = pathsArray;
|
|
|
|
return true;
|
|
}
|
|
else if (name == "unwatchAllPaths") {
|
|
PathWatcher *pathWatcher = [PathWatcher pathWatcherForContext:CefV8Context::GetCurrentContext()];
|
|
[pathWatcher unwatchAllPaths];
|
|
return true;
|
|
}
|
|
else if (name == "makeDirectory") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
NSFileManager *fm = [NSFileManager defaultManager];
|
|
NSError *error = nil;
|
|
[fm createDirectoryAtPath:path withIntermediateDirectories:NO attributes:nil error:&error];
|
|
|
|
if (error) {
|
|
exception = [[error localizedDescription] UTF8String];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "move") {
|
|
NSString *sourcePath = stringFromCefV8Value(arguments[0]);
|
|
NSString *targetPath = stringFromCefV8Value(arguments[1]);
|
|
NSFileManager *fm = [NSFileManager defaultManager];
|
|
|
|
NSError *error = nil;
|
|
[fm moveItemAtPath:sourcePath toPath:targetPath error:&error];
|
|
|
|
if (error) {
|
|
exception = [[error localizedDescription] UTF8String];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "moveToTrash") {
|
|
NSString *sourcePath = stringFromCefV8Value(arguments[0]);
|
|
bool success = [[NSWorkspace sharedWorkspace] performFileOperation:NSWorkspaceRecycleOperation
|
|
source:[sourcePath stringByDeletingLastPathComponent]
|
|
destination:@""
|
|
files:[NSArray arrayWithObject:[sourcePath lastPathComponent]]
|
|
tag:nil];
|
|
|
|
if (!success) {
|
|
std::string exception = "Can not move ";
|
|
exception += [sourcePath UTF8String];
|
|
exception += " to trash.";
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else if (name == "reload") {
|
|
CefV8Context::GetCurrentContext()->GetBrowser()->ReloadIgnoreCache();
|
|
}
|
|
else if (name == "lastModified") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
NSFileManager *fm = [NSFileManager defaultManager];
|
|
|
|
NSError *error = nil;
|
|
NSDictionary *attributes = [fm attributesOfItemAtPath:path error:&error];
|
|
|
|
if (error) {
|
|
exception = [[error localizedDescription] UTF8String];
|
|
}
|
|
|
|
NSDate *lastModified = [attributes objectForKey:NSFileModificationDate];
|
|
retval = CefV8Value::CreateDate(CefTime([lastModified timeIntervalSince1970]));
|
|
return true;
|
|
}
|
|
else if (name == "md5ForPath") {
|
|
NSString *path = stringFromCefV8Value(arguments[0]);
|
|
unsigned char outputData[CC_MD5_DIGEST_LENGTH];
|
|
|
|
NSData *inputData = [[NSData alloc] initWithContentsOfFile:path];
|
|
CC_MD5([inputData bytes], [inputData length], outputData);
|
|
[inputData release];
|
|
|
|
NSMutableString *hash = [[NSMutableString alloc] init];
|
|
|
|
for (NSUInteger i = 0; i < CC_MD5_DIGEST_LENGTH; i++) {
|
|
[hash appendFormat:@"%02x", outputData[i]];
|
|
}
|
|
|
|
retval = CefV8Value::CreateString([hash UTF8String]);
|
|
return true;
|
|
}
|
|
else if (name == "exec") {
|
|
NSString *command = stringFromCefV8Value(arguments[0]);
|
|
CefRefPtr<CefV8Value> options = arguments[1];
|
|
CefRefPtr<CefV8Value> callback = arguments[2];
|
|
|
|
NSTask *task = [[NSTask alloc] init];
|
|
[task setLaunchPath:@"/bin/sh"];
|
|
[task setStandardInput:[NSFileHandle fileHandleWithNullDevice]];
|
|
[task setArguments:[NSArray arrayWithObjects:@"-l", @"-c", command, nil]];
|
|
|
|
NSPipe *stdout = [NSPipe pipe];
|
|
NSPipe *stderr = [NSPipe pipe];
|
|
[task setStandardOutput:stdout];
|
|
[task setStandardError:stderr];
|
|
|
|
CefRefPtr<CefV8Context> context = CefV8Context::GetCurrentContext();
|
|
void (^outputHandle)(NSString *contents, CefRefPtr<CefV8Value> function) = nil;
|
|
void (^taskTerminatedHandle)(NSString *output, NSString *errorOutput) = nil;
|
|
|
|
outputHandle = ^(NSString *contents, CefRefPtr<CefV8Value> function) {
|
|
context->Enter();
|
|
|
|
CefV8ValueList args;
|
|
args.push_back(CefV8Value::CreateString(std::string([contents UTF8String], [contents lengthOfBytesUsingEncoding:NSUTF8StringEncoding])));
|
|
CefRefPtr<CefV8Value> retval = function->ExecuteFunction(function, args);
|
|
|
|
if (function->HasException()) {
|
|
throwException(context->GetGlobal(), function->GetException(), @"Error thrown in OutputHandle");
|
|
}
|
|
|
|
context->Exit();
|
|
};
|
|
|
|
taskTerminatedHandle = ^(NSString *output, NSString *errorOutput) {
|
|
context->Enter();
|
|
|
|
CefV8ValueList args;
|
|
args.push_back(CefV8Value::CreateInt([task terminationStatus]));
|
|
args.push_back(CefV8Value::CreateString([output UTF8String]));
|
|
args.push_back(CefV8Value::CreateString([errorOutput UTF8String]));
|
|
|
|
callback->ExecuteFunction(callback, args);
|
|
|
|
if (callback->HasException()) {
|
|
throwException(context->GetGlobal(), callback->GetException(), @"Error thrown in TaskTerminatedHandle");
|
|
}
|
|
|
|
context->Exit();
|
|
|
|
stdout.fileHandleForReading.writeabilityHandler = nil;
|
|
stderr.fileHandleForReading.writeabilityHandler = nil;
|
|
};
|
|
|
|
task.terminationHandler = ^(NSTask *) {
|
|
NSString *output = [[NSString alloc] initWithData:[[stdout fileHandleForReading] readDataToEndOfFile] encoding:NSUTF8StringEncoding];
|
|
NSString *errorOutput = [[NSString alloc] initWithData:[[stderr fileHandleForReading] readDataToEndOfFile] encoding:NSUTF8StringEncoding];
|
|
dispatch_sync(dispatch_get_main_queue(), ^() {
|
|
taskTerminatedHandle(output, errorOutput);
|
|
});
|
|
[output release];
|
|
[errorOutput release];
|
|
};
|
|
|
|
CefRefPtr<CefV8Value> stdoutFunction = options->GetValue("stdout");
|
|
if (stdoutFunction->IsFunction()) {
|
|
stdout.fileHandleForReading.writeabilityHandler = ^(NSFileHandle *fileHandle) {
|
|
NSData *data = [fileHandle availableData];
|
|
NSString *contents = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
|
|
dispatch_sync(dispatch_get_main_queue(), ^() {
|
|
outputHandle(contents, stdoutFunction);
|
|
});
|
|
[contents release];
|
|
};
|
|
}
|
|
|
|
CefRefPtr<CefV8Value> stderrFunction = options->GetValue("stderr");
|
|
if (stderrFunction->IsFunction()) {
|
|
stderr.fileHandleForReading.writeabilityHandler = ^(NSFileHandle *fileHandle) {
|
|
NSData *data = [fileHandle availableData];
|
|
NSString *contents = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
|
|
dispatch_sync(dispatch_get_main_queue(), ^() {
|
|
outputHandle(contents, stderrFunction);
|
|
});
|
|
[contents release];
|
|
};
|
|
}
|
|
|
|
[task launch];
|
|
|
|
return true;
|
|
}
|
|
else if (name == "getPlatform") {
|
|
retval = CefV8Value::CreateString("mac");
|
|
return true;
|
|
}
|
|
|
|
else if (name == "setWindowState") {
|
|
[windowStateLock lock];
|
|
windowState = arguments[0]->GetStringValue().ToString();
|
|
[windowStateLock unlock];
|
|
return true;
|
|
}
|
|
|
|
else if (name == "getWindowState") {
|
|
[windowStateLock lock];
|
|
retval = CefV8Value::CreateString(windowState);
|
|
[windowStateLock unlock];
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
NSString *stringFromCefV8Value(const CefRefPtr<CefV8Value>& value) {
|
|
std::string cc_value = value->GetStringValue().ToString();
|
|
return [NSString stringWithUTF8String:cc_value.c_str()];
|
|
}
|
|
|
|
void throwException(const CefRefPtr<CefV8Value>& global, CefRefPtr<CefV8Exception> exception, NSString *message) {
|
|
CefV8ValueList arguments;
|
|
|
|
message = [message stringByAppendingFormat:@"\n%s", exception->GetMessage().ToString().c_str()];
|
|
arguments.push_back(CefV8Value::CreateString(std::string([message UTF8String], [message lengthOfBytesUsingEncoding:NSUTF8StringEncoding])));
|
|
|
|
CefRefPtr<CefV8Value> console = global->GetValue("console");
|
|
console->GetValue("error")->ExecuteFunction(console, arguments);
|
|
}
|
|
|
|
} // namespace v8_extensions
|