'atom/common/api/atom_api_v8_util.cc',
'atom/common/api/atom_bindings.cc',
'atom/common/api/atom_bindings.h',
- 'atom/common/api/atom_extensions.cc',
- 'atom/common/api/atom_extensions.h',
'atom/common/api/object_life_monitor.cc',
'atom/common/api/object_life_monitor.h',
'atom/common/browser_v8_locker.cc',
'<(libchromiumcontent_library_dir)/icudt.dll',
'<(libchromiumcontent_library_dir)/libEGL.dll',
'<(libchromiumcontent_library_dir)/libGLESv2.dll',
+ '<(libchromiumcontent_resources_dir)/icudtl.dat',
'<(libchromiumcontent_resources_dir)/content_shell.pak',
'external_binaries/d3dcompiler_43.dll',
'external_binaries/xinput1_3.dll',
'files': [
'<(libchromiumcontent_library_dir)/libchromiumcontent.so',
'<(libchromiumcontent_library_dir)/libffmpegsumo.so',
+ '<(libchromiumcontent_resources_dir)/icudtl.dat',
'<(libchromiumcontent_resources_dir)/content_shell.pak',
],
},
'mac_bundle_resources': [
'atom/common/resources/mac/MainMenu.xib',
'<(libchromiumcontent_resources_dir)/content_shell.pak',
+ '<(libchromiumcontent_resources_dir)/icudtl.dat',
],
'xcode_settings': {
'INFOPLIST_FILE': 'atom/common/resources/mac/Info.plist',
#if defined(OS_MACOSX)
int AtomMain(int argc, const char* argv[]) {
atom::AtomMainDelegate delegate;
- return content::ContentMain(argc, argv, &delegate);
+ return content::ContentMain(content::ContentMainParams(&delegate));
}
#endif // OS_MACOSX
} // namespace
-NODE_MODULE(atom_browser_app, Initialize)
+NODE_MODULE_X(atom_browser_app, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_browser_auto_updater, Initialize)
+NODE_MODULE_X(atom_browser_auto_updater, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_browser_dialog, Initialize)
+NODE_MODULE_X(atom_browser_dialog, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_browser_menu, Initialize)
+NODE_MODULE_X(atom_browser_menu, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_browser_power_monitor, Initialize)
+NODE_MODULE_X(atom_browser_power_monitor, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_browser_protocol, Initialize)
+NODE_MODULE_X(atom_browser_protocol, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_browser_tray, Initialize)
+NODE_MODULE_X(atom_browser_tray, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_browser_window, Initialize)
+NODE_MODULE_X(atom_browser_window, Initialize, NULL, NM_F_BUILTIN)
net::URLRequestContextGetter* AtomBrowserClient::CreateRequestContext(
content::BrowserContext* browser_context,
- content::ProtocolHandlerMap* protocol_handlers) {
+ content::ProtocolHandlerMap* protocol_handlers,
+ content::ProtocolHandlerScopedVector protocol_interceptors) {
return static_cast<AtomBrowserContext*>(browser_context)->
CreateRequestContext(protocol_handlers);
}
window->OverrideWebkitPrefs(url, prefs);
}
-bool AtomBrowserClient::ShouldSwapProcessesForNavigation(
+bool AtomBrowserClient::ShouldSwapBrowsingInstancesForNavigation(
content::SiteInstance* site_instance,
const GURL& current_url,
const GURL& new_url) {
}
void AtomBrowserClient::AppendExtraCommandLineSwitches(
- CommandLine* command_line,
+ base::CommandLine* command_line,
int child_process_id) {
WindowList* list = WindowList::GetInstance();
NativeWindow* window = NULL;
protected:
net::URLRequestContextGetter* CreateRequestContext(
content::BrowserContext* browser_context,
- content::ProtocolHandlerMap* protocol_handlers) OVERRIDE;
+ content::ProtocolHandlerMap* protocol_handlers,
+ content::ProtocolHandlerScopedVector protocol_interceptors) OVERRIDE;
virtual void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
const GURL& url,
WebPreferences* prefs) OVERRIDE;
- virtual bool ShouldSwapProcessesForNavigation(
+ virtual bool ShouldSwapBrowsingInstancesForNavigation(
content::SiteInstance* site_instance,
const GURL& current_url,
const GURL& new_url) OVERRIDE;
virtual std::string GetApplicationLocale() OVERRIDE;
- virtual void AppendExtraCommandLineSwitches(CommandLine* command_line,
+ virtual void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
int child_process_id) OVERRIDE;
private:
context->Enter();
// Add atom-shell extended APIs.
- atom_bindings_->BindTo(global_env->process_object());
+ atom_bindings_->BindTo(isolate, global_env->process_object());
}
void AtomBrowserMainParts::PreMainMessageLoopRun() {
#include "content/public/browser/notification_source.h"
#include "content/public/browser/notification_types.h"
#include "content/public/browser/plugin_service.h"
+#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/render_widget_host_view.h"
#include "content/public/browser/web_contents_view.h"
#include "content/public/common/renderer_preferences.h"
+#include "content/public/common/user_agent.h"
#include "ipc/ipc_message_macros.h"
#include "native_mate/dictionary.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/size.h"
#include "vendor/brightray/browser/inspectable_web_contents.h"
#include "vendor/brightray/browser/inspectable_web_contents_view.h"
-#include "webkit/common/user_agent/user_agent_util.h"
#include "webkit/common/webpreferences.h"
using content::NavigationEntry;
browser->GetVersion().c_str(),
CHROME_VERSION_STRING);
web_contents->GetMutableRendererPrefs()->user_agent_override =
- webkit_glue::BuildUserAgentFromProduct(product_name);
+ content::BuildUserAgentFromProduct(product_name);
// Get notified of title updated message.
registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED,
size,
base::Bind(&NativeWindow::OnCapturePageDone,
weak_factory_.GetWeakPtr(),
- callback));
+ callback),
+ SkBitmap::kARGB_8888_Config);
}
void NativeWindow::DestroyWebContents() {
ScheduleUnresponsiveEvent(5000);
if (web_contents->NeedToFireBeforeUnload())
- web_contents->GetRenderViewHost()->FirePageBeforeUnload(false);
+ web_contents->GetMainFrame()->DispatchBeforeUnload(false);
else
web_contents->Close();
}
return inspectable_web_contents()->devtools_web_contents();
}
-void NativeWindow::AppendExtraCommandLineSwitches(CommandLine* command_line,
- int child_process_id) {
+void NativeWindow::AppendExtraCommandLineSwitches(
+ base::CommandLine* command_line, int child_process_id) {
// Append --node-integration to renderer process.
command_line->AppendSwitchASCII(switches::kNodeIntegration,
node_integration_);
}
saved_files_[url] = path;
- file_util::WriteFile(path, content.data(), content.size());
+ base::WriteFile(path, content.data(), content.size());
// Notify devtools.
base::StringValue url_value(url);
PathsMap::iterator it = saved_files_.find(url);
if (it == saved_files_.end())
return;
- file_util::AppendToFile(it->second, content.data(), content.size());
+ base::AppendToFile(it->second, content.data(), content.size());
// Notify devtools.
base::StringValue url_value(url);
}
}
GetDevToolsWebContents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
- string16(), base::UTF8ToUTF16(function_name + "(" + params + ");"));
+ base::string16(), base::UTF8ToUTF16(function_name + "(" + params + ");"));
}
} // namespace atom
#include "vendor/brightray/browser/inspectable_web_contents_delegate.h"
#include "vendor/brightray/browser/inspectable_web_contents_impl.h"
-class CommandLine;
struct WebPreferences;
+namespace base {
+class CommandLine;
+}
+
namespace content {
class BrowserContext;
class WebContents;
content::WebContents* GetDevToolsWebContents() const;
// Called when renderer process is going to be started.
- void AppendExtraCommandLineSwitches(CommandLine* command_line,
+ void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
int child_process_id);
void OverrideWebkitPrefs(const GURL& url, WebPreferences* prefs);
void NativeWindowGtk::HandleKeyboardEvent(
content::WebContents*,
const content::NativeWebKeyboardEvent& event) {
- if (event.type == WebKit::WebInputEvent::RawKeyDown) {
+ if (event.type == blink::WebInputEvent::RawKeyDown) {
GdkEventKey* os_event = reinterpret_cast<GdkEventKey*>(event.os_event);
ui::Accelerator accelerator = ui::AcceleratorForGdkKeyCodeAndModifier(
os_event->keyval, static_cast<GdkModifierType>(os_event->state));
void NativeWindowWin::HandleKeyboardEvent(
content::WebContents*,
const content::NativeWebKeyboardEvent& event) {
- if (event.type == WebKit::WebInputEvent::RawKeyDown) {
+ if (event.type == blink::WebInputEvent::RawKeyDown) {
ui::Accelerator accelerator(
static_cast<ui::KeyboardCode>(event.windowsKeyCode),
content::GetModifiersFromNativeWebKeyboardEvent(event));
virtual views::View* GetInitiallyFocusedView() OVERRIDE;
virtual bool CanResize() const OVERRIDE;
virtual bool CanMaximize() const OVERRIDE;
- virtual string16 GetWindowTitle() const OVERRIDE;
+ virtual base::string16 GetWindowTitle() const OVERRIDE;
virtual bool ShouldHandleSystemCommands() const OVERRIDE;
virtual gfx::ImageSkia GetWindowAppIcon() OVERRIDE;
virtual gfx::ImageSkia GetWindowIcon() OVERRIDE;
bool use_content_size_;
bool resizable_;
- string16 title_;
+ base::string16 title_;
gfx::Size minimum_size_;
gfx::Size maximum_size_;
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_storage.h"
#include "vendor/brightray/browser/network_delegate.h"
+#include "webkit/browser/quota/special_storage_policy.h"
namespace atom {
url_request_context_->set_network_delegate(network_delegate_.get());
storage_.reset(
new net::URLRequestContextStorage(url_request_context_.get()));
- storage_->set_cookie_store(content::CreatePersistentCookieStore(
+ auto cookie_config = content::CookieStoreConfig(
base_path_.Append(FILE_PATH_LITERAL("Cookies")),
- false,
+ content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES,
nullptr,
- nullptr,
- nullptr));
+ nullptr);
+ storage_->set_cookie_store(content::CreateCookieStore(cookie_config));
storage_->set_server_bound_cert_service(new net::ServerBoundCertService(
new net::DefaultServerBoundCertStore(NULL),
base::WorkerPool::GetTaskRunner(true)));
storage_->set_http_user_agent_settings(
new net::StaticHttpUserAgentSettings(
- "en-us,en", EmptyString()));
+ "en-us,en", base::EmptyString()));
scoped_ptr<net::HostResolver> host_resolver(
net::HostResolver::CreateDefaultResolver(NULL));
content::BrowserThread::GetBlockingPool()->
GetTaskRunnerWithShutdownBehavior(
base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
- job_factory_->SetProtocolHandler(chrome::kDataScheme,
+ job_factory_->SetProtocolHandler(content::kDataScheme,
new net::DataProtocolHandler);
- job_factory_->SetProtocolHandler(chrome::kFileScheme,
+ job_factory_->SetProtocolHandler(content::kFileScheme,
file_protocol_handler.release());
storage_->set_job_factory(job_factory_);
}
- (void)addItemToMenu:(NSMenu*)menu
atIndex:(NSInteger)index
fromModel:(ui::MenuModel*)model {
- string16 label16 = model->GetLabelAt(index);
+ base::string16 label16 = model->GetLabelAt(index);
NSString* label = l10n_util::FixUpWindowsStyleLabel(label16);
base::scoped_nsobject<NSMenuItem> item(
[[NSMenuItem alloc] initWithTitle:label
virtual bool Dispatch(const base::NativeEvent& event) OVERRIDE;
// Overridden from views::WidgetDelegate:
- virtual string16 GetWindowTitle() const;
+ virtual base::string16 GetWindowTitle() const;
virtual void WindowClosing() OVERRIDE;
virtual views::Widget* GetWidget() OVERRIDE;
virtual const views::Widget* GetWidget() const OVERRIDE;
bool should_close_;
bool delete_on_close_;
int result_;
- string16 title_;
+ base::string16 title_;
views::Widget* widget_;
views::MessageBoxView* message_box_view_;
scoped_ptr<NativeWindow::DialogScope> dialog_scope_;
// The Windows API requires that whoever creates the menus must own the
// strings used for labels, and keep them around for the lifetime of the
// created menu. So be it.
- string16 label;
+ base::string16 label;
// Someone needs to own submenus, it may as well be us.
scoped_ptr<Menu2> submenu;
if (data->submenu.get())
measure_item_struct->itemWidth += kArrowWidth;
// If the label contains an accelerator, make room for tab.
- if (data->label.find(L'\t') != string16::npos)
+ if (data->label.find(L'\t') != base::string16::npos)
measure_item_struct->itemWidth += font.GetStringWidth(L" ");
measure_item_struct->itemHeight =
font.GetHeight() + kItemBottomMargin + kItemTopMargin;
// left and the accelerator on the right.
// TODO(jungshik): This will break in RTL UI. Currently, he/ar use the
// window system UI font and will not hit here.
- string16 label = data->label;
- string16 accel;
- string16::size_type tab_pos = label.find(L'\t');
- if (tab_pos != string16::npos) {
+ base::string16 label = data->label;
+ base::string16 accel;
+ base::string16::size_type tab_pos = label.find(L'\t');
+ if (tab_pos != base::string16::npos) {
accel = label.substr(tab_pos);
label = label.substr(0, tab_pos);
}
mii.fType = MFT_OWNERDRAW;
ItemData* item_data = new ItemData;
- item_data->label = string16();
+ item_data->label = base::string16();
ui::MenuModel::ItemType type = model_->GetTypeAt(model_index);
if (type == ui::MenuModel::TYPE_SUBMENU) {
item_data->submenu.reset(new Menu2(model_->GetSubmenuModelAt(model_index)));
void NativeMenuWin::SetMenuItemLabel(int menu_index,
int model_index,
- const string16& label) {
+ const base::string16& label) {
if (IsSeparatorItemAt(menu_index))
return;
void NativeMenuWin::UpdateMenuItemInfoForString(MENUITEMINFO* mii,
int model_index,
- const string16& label) {
- string16 formatted = label;
+ const base::string16& label) {
+ base::string16 formatted = label;
ui::MenuModel::ItemType type = model_->GetTypeAt(model_index);
// Strip out any tabs, otherwise they get interpreted as accelerators and can
// lead to weird behavior.
// Sets the label of the item at the specified index.
void SetMenuItemLabel(int menu_index,
int model_index,
- const string16& label);
+ const base::string16& label);
// Updates the local data structure with the correctly formatted version of
// |label| at the specified model_index, and adds string data to |mii| if
// of the peculiarities of the Windows menu API.
void UpdateMenuItemInfoForString(MENUITEMINFO* mii,
int model_index,
- const string16& label);
+ const base::string16& label);
// Returns the alignment flags to be passed to TrackPopupMenuEx, based on the
// supplied alignment and the UI text direction.
#include "atom/common/native_mate_converters/string16_converter.h"
#include "native_mate/dictionary.h"
#include "ui/base/clipboard/clipboard.h"
+#include "ui/base/clipboard/scoped_clipboard_writer.h"
#include "atom/common/node_includes.h"
namespace mate {
template<>
-struct Converter<ui::Clipboard::Buffer> {
+struct Converter<ui::ClipboardType> {
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
- ui::Clipboard::Buffer* out) {
+ ui::ClipboardType* out) {
std::string type;
if (!Converter<std::string>::FromV8(isolate, val, &type))
return false;
if (type == "selection")
- *out = ui::Clipboard::BUFFER_SELECTION;
+ *out = ui::CLIPBOARD_TYPE_SELECTION;
else
- *out = ui::Clipboard::BUFFER_STANDARD;
+ *out = ui::CLIPBOARD_TYPE_COPY_PASTE;
return true;
}
};
namespace {
-bool Has(const std::string& format_string, ui::Clipboard::Buffer buffer) {
+bool Has(const std::string& format_string, ui::ClipboardType type) {
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
ui::Clipboard::FormatType format(ui::Clipboard::GetFormatType(format_string));
- return clipboard->IsFormatAvailable(format, buffer);
+ return clipboard->IsFormatAvailable(format, type);
}
std::string Read(const std::string& format_string,
- ui::Clipboard::Buffer buffer) {
+ ui::ClipboardType type) {
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
ui::Clipboard::FormatType format(ui::Clipboard::GetFormatType(format_string));
return data;
}
-string16 ReadText(ui::Clipboard::Buffer buffer) {
- string16 data;
- ui::Clipboard::GetForCurrentThread()->ReadText(buffer, &data);
+base::string16 ReadText(ui::ClipboardType type) {
+ base::string16 data;
+ ui::Clipboard::GetForCurrentThread()->ReadText(type, &data);
return data;
}
-void WriteText(const std::string text, ui::Clipboard::Buffer buffer) {
- ui::Clipboard::ObjectMap object_map;
- object_map[ui::Clipboard::CBF_TEXT].push_back(
- std::vector<char>(text.begin(), text.end()));
-
+void WriteText(const base::string16& text, ui::ClipboardType type) {
ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
- clipboard->WriteObjects(buffer, object_map);
+ ui::ScopedClipboardWriter writer(clipboard, type);
+ writer.WriteText(text);
}
-void Clear(ui::Clipboard::Buffer buffer) {
- ui::Clipboard::GetForCurrentThread()->Clear(buffer);
+void Clear(ui::ClipboardType type) {
+ ui::Clipboard::GetForCurrentThread()->Clear(type);
}
void Initialize(v8::Handle<v8::Object> exports) {
} // namespace
-NODE_MODULE(atom_common_clipboard, Initialize)
+NODE_MODULE_X(atom_common_clipboard, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_common_crash_reporter, Initialize)
+NODE_MODULE_X(atom_common_crash_reporter, Initialize, NULL, NM_F_BUILTIN)
mate::Converter<int32_t>::ToV8(isolate, key));
map_[key] = new mate::RefCountedPersistent<v8::Object>(object);
- map_[key]->MakeWeak(this, WeakCallback);
+ map_[key]->SetWeak(this, WeakCallback);
return key;
}
-v8::Handle<v8::Value> IDWeakMap::Get(int32_t key) {
+v8::Handle<v8::Value> IDWeakMap::Get(v8::Isolate* isolate, int32_t key) {
if (!Has(key)) {
node::ThrowError("Invalid key");
- return v8::Undefined();
+ return v8::Undefined(isolate);
}
return map_[key]->NewHandle();
}
// static
-void IDWeakMap::WeakCallback(v8::Isolate* isolate,
- v8::Persistent<v8::Object>* value,
- IDWeakMap* self) {
- v8::HandleScope handle_scope(isolate);
- v8::Local<v8::Object> object = v8::Local<v8::Object>::New(isolate, *value);
- int32_t key = object->GetHiddenValue(
- mate::StringToV8(isolate, "IDWeakMapKey"))->Int32Value();
- self->Remove(key);
+void IDWeakMap::WeakCallback(
+ const v8::WeakCallbackData<v8::Object, IDWeakMap>& data) {
+ int32_t key = data.GetValue()->GetHiddenValue(
+ mate::StringToV8(data.GetIsolate(), "IDWeakMapKey"))->Int32Value();
+ data.GetParameter()->Remove(key);
}
} // namespace api
} // namespace
-NODE_MODULE(atom_common_id_weak_map, Initialize)
+NODE_MODULE_X(atom_common_id_weak_map, Initialize, NULL, NM_F_BUILTIN)
virtual ~IDWeakMap();
int32_t Add(v8::Isolate* isolate, v8::Handle<v8::Object> object);
- v8::Handle<v8::Value> Get(int32_t key);
+ v8::Handle<v8::Value> Get(v8::Isolate* isolate, int32_t key);
bool Has(int32_t key) const;
std::vector<int32_t> Keys() const;
void Remove(int32_t key);
int GetNextID();
- static void WeakCallback(v8::Isolate* isolate,
- v8::Persistent<v8::Object>* value,
- IDWeakMap* self);
+ static void WeakCallback(
+ const v8::WeakCallbackData<v8::Object, IDWeakMap>& data);
int32_t next_id_;
} // namespace
-NODE_MODULE(atom_common_screen, Initialize)
+NODE_MODULE_X(atom_common_screen, Initialize, NULL, NM_F_BUILTIN)
} // namespace
-NODE_MODULE(atom_common_shell, Initialize)
+NODE_MODULE_X(atom_common_shell, Initialize, NULL, NM_F_BUILTIN)
namespace {
-v8::Handle<v8::Object> CreateObjectWithName(v8::Handle<v8::String> name) {
- v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New();
+v8::Handle<v8::Object> CreateObjectWithName(v8::Isolate* isolate,
+ v8::Handle<v8::String> name) {
+ v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
t->SetClassName(name);
return t->GetFunction()->NewInstance();
}
return object->GetIdentityHash();
}
-void SetDestructor(v8::Handle<v8::Object> object,
+void SetDestructor(v8::Isolate* isolate,
+ v8::Handle<v8::Object> object,
v8::Handle<v8::Function> callback) {
- atom::ObjectLifeMonitor::BindTo(object, callback);
+ atom::ObjectLifeMonitor::BindTo(isolate, object, callback);
}
-void TakeHeapSnapshot() {
- node::node_isolate->GetHeapProfiler()->TakeHeapSnapshot(
- v8::String::New("test"));
+void TakeHeapSnapshot(v8::Isolate* isolate) {
+ isolate->GetHeapProfiler()->TakeHeapSnapshot(
+ mate::StringToV8(isolate, "test"));
}
void Initialize(v8::Handle<v8::Object> exports) {
} // namespace
-NODE_MODULE(atom_common_v8_util, Initialize)
+NODE_MODULE_X(atom_common_v8_util, Initialize, NULL, NM_F_BUILTIN)
namespace atom {
-// Defined in atom_extensions.cc.
-node::node_module_struct* GetBuiltinModule(const char *name, bool is_browser);
-
namespace {
// Async handle to wake up uv loop.
struct DummyClass { bool crash; };
// Async handler to call next process.nextTick callbacks.
-void UvCallNextTick(uv_async_t* handle, int status) {
- node::Environment* env = node::Environment::GetCurrent(node_isolate);
+void UvCallNextTick(uv_async_t* handle) {
+ v8::Isolate* isolate = v8::Isolate::GetCurrent();
+ node::Environment* env = node::Environment::GetCurrent(isolate);
node::Environment::TickInfo* tick_info = env->tick_info();
if (tick_info->in_tick())
}
// Async handler to execute the stored v8 callback.
-void UvOnCallback(uv_async_t* handle, int status) {
+void UvOnCallback(uv_async_t* handle) {
g_v8_callback.Run();
}
return mate::ConvertToV8(isolate, frame_dict);;
}
-v8::Handle<v8::Value> Binding(v8::Handle<v8::String> module) {
- v8::String::Utf8Value module_v(module);
- node::node_module_struct* modp;
-
- v8::Local<v8::Object> process = v8::Context::GetCurrent()->Global()->
- Get(v8::String::New("process"))->ToObject();
- DCHECK(!process.IsEmpty());
-
- // is_browser = process.type == 'browser'.
- bool is_browser = std::string("browser") == *v8::String::Utf8Value(
- process->Get(v8::String::New("type")));
-
- // Cached in process.__atom_binding_cache.
- v8::Local<v8::Object> binding_cache;
- v8::Local<v8::String> bc_name = v8::String::New("__atomBindingCache");
- if (process->Has(bc_name)) {
- binding_cache = process->Get(bc_name)->ToObject();
- DCHECK(!binding_cache.IsEmpty());
- } else {
- binding_cache = v8::Object::New();
- process->Set(bc_name, binding_cache);
- }
-
- if (binding_cache->Has(module))
- return binding_cache->Get(module)->ToObject();
-
- if ((modp = GetBuiltinModule(*module_v, is_browser)) != NULL) {
- v8::Local<v8::Object> exports = v8::Object::New();
- // Internal bindings don't have a "module" object,
- // only exports.
- modp->register_func(exports, v8::Undefined());
- binding_cache->Set(module, exports);
- return exports;
- }
-
- node::ThrowError("No such module");
- return v8::Undefined();
-}
-
void Crash() {
static_cast<DummyClass*>(NULL)->crash = true;
}
uv_async_send(&g_next_tick_uv_handle);
}
-void Log(const string16& message) {
+void Log(const base::string16& message) {
logging::LogMessage("CONSOLE", 0, 0).stream() << message;
}
v8::Handle<v8::Value> GetCurrentStackTrace(v8::Isolate* isolate,
int stack_limit) {
v8::Local<v8::StackTrace> stack_trace = v8::StackTrace::CurrentStackTrace(
- stack_limit, v8::StackTrace::kDetailed);
+ isolate, stack_limit, v8::StackTrace::kDetailed);
int frame_count = stack_trace->GetFrameCount();
- v8::Local<v8::Array> result = v8::Array::New(frame_count);
+ v8::Local<v8::Array> result = v8::Array::New(isolate, frame_count);
for (int i = 0; i < frame_count; ++i)
result->Set(i, DumpStackFrame(isolate, stack_trace->GetFrame(i)));
AtomBindings::~AtomBindings() {
}
-void AtomBindings::BindTo(v8::Handle<v8::Object> process) {
- v8::Isolate* isolate = v8::Isolate::GetCurrent();
+void AtomBindings::BindTo(v8::Isolate* isolate,
+ v8::Handle<v8::Object> process) {
mate::Dictionary dict(isolate, process);
- dict.SetMethod("atomBinding", &Binding);
dict.SetMethod("crash", &Crash);
dict.SetMethod("activateUvLoop", &ActivateUVLoop);
dict.SetMethod("log", &Log);
AtomBindings();
virtual ~AtomBindings();
- // Add process.atom_binding function, which behaves like process.binding but
+ // Add process.atom_binding function, which behaves like process.atomBinding but
// load native code from atom-shell instead.
- virtual void BindTo(v8::Handle<v8::Object> process);
+ virtual void BindTo(v8::Isolate* isolate, v8::Handle<v8::Object> process);
private:
DISALLOW_COPY_AND_ASSIGN(AtomBindings);
+++ /dev/null
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include <string.h>
-#include <stdio.h>
-
-#include "base/strings/string_util.h"
-#include "vendor/node/src/node_version.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-#undef NODE_EXT_LIST_START
-#undef NODE_EXT_LIST_ITEM
-#undef NODE_EXT_LIST_END
-
-#define NODE_EXT_LIST_START
-#define NODE_EXT_LIST_ITEM NODE_MODULE_DECL
-#define NODE_EXT_LIST_END
-
-#include "atom/common/api/atom_extensions.h"
-
-#undef NODE_EXT_LIST_START
-#undef NODE_EXT_LIST_ITEM
-#undef NODE_EXT_LIST_END
-
-#define NODE_EXT_STRING(x) &x ## _module,
-#define NODE_EXT_LIST_START node::node_module_struct *node_module_list[] = {
-#define NODE_EXT_LIST_ITEM NODE_EXT_STRING
-#define NODE_EXT_LIST_END NULL};
-
-#include "atom/common/api/atom_extensions.h" // NOLINT
-
-node::node_module_struct* GetBuiltinModule(const char *name, bool is_browser) {
- char common[128];
- char spec[128];
- node::node_module_struct *cur = NULL;
- base::snprintf(common, sizeof(common), "atom_common_%s", name);
- base::snprintf(spec, sizeof(spec),
- (is_browser ? "atom_browser_%s": "atom_renderer_%s"),
- name);
- /* TODO: you could look these up in a hash, but there are only
- * a few, and once loaded they are cached. */
- for (int i = 0; node_module_list[i] != NULL; i++) {
- cur = node_module_list[i];
- if (strcmp(cur->modname, common) == 0 || strcmp(cur->modname, spec) == 0) {
- return cur;
- }
- }
-
- return NULL;
-}
-
-} // namespace atom
+++ /dev/null
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-// Multiply-included file, no traditional include guard.
-
-// Used by atom_extensions.cc to declare a list of built-in modules of Atom.
-
-NODE_EXT_LIST_START
-
-// Module names start with `atom_browser_` can only be used by browser process.
-NODE_EXT_LIST_ITEM(atom_browser_app)
-NODE_EXT_LIST_ITEM(atom_browser_auto_updater)
-NODE_EXT_LIST_ITEM(atom_browser_dialog)
-NODE_EXT_LIST_ITEM(atom_browser_menu)
-NODE_EXT_LIST_ITEM(atom_browser_power_monitor)
-NODE_EXT_LIST_ITEM(atom_browser_protocol)
-NODE_EXT_LIST_ITEM(atom_browser_tray)
-NODE_EXT_LIST_ITEM(atom_browser_window)
-
-// Module names start with `atom_renderer_` can only be used by renderer
-// process.
-NODE_EXT_LIST_ITEM(atom_renderer_ipc)
-NODE_EXT_LIST_ITEM(atom_renderer_web_view)
-
-// Module names start with `atom_common_` can be used by both browser and
-// renderer processes.
-NODE_EXT_LIST_ITEM(atom_common_clipboard)
-NODE_EXT_LIST_ITEM(atom_common_crash_reporter)
-NODE_EXT_LIST_ITEM(atom_common_id_weak_map)
-NODE_EXT_LIST_ITEM(atom_common_screen)
-NODE_EXT_LIST_ITEM(atom_common_shell)
-NODE_EXT_LIST_ITEM(atom_common_v8_util)
-
-NODE_EXT_LIST_END
#include "atom/common/api/object_life_monitor.h"
+#include "native_mate/compat.h"
+
namespace atom {
// static
-void ObjectLifeMonitor::BindTo(v8::Handle<v8::Object> target,
+void ObjectLifeMonitor::BindTo(v8::Isolate* isolate,
+ v8::Handle<v8::Object> target,
v8::Handle<v8::Value> destructor) {
- target->SetHiddenValue(v8::String::New("destructor"), destructor);
+ target->SetHiddenValue(MATE_STRING_NEW(isolate, "destructor"), destructor);
ObjectLifeMonitor* olm = new ObjectLifeMonitor();
olm->handle_.reset(target);
- olm->handle_.MakeWeak(olm, WeakCallback);
+ olm->handle_.SetWeak(olm, WeakCallback);
}
ObjectLifeMonitor::ObjectLifeMonitor() {
}
// static
-void ObjectLifeMonitor::WeakCallback(v8::Isolate* isolate,
- v8::Persistent<v8::Object>* value,
- ObjectLifeMonitor* self) {
+void ObjectLifeMonitor::WeakCallback(
+ const v8::WeakCallbackData<v8::Object, ObjectLifeMonitor>& data) {
// destructor.call(object, object);
- {
- v8::HandleScope handle_scope(isolate);
- v8::Local<v8::Object> obj = self->handle_.NewHandle();
- v8::Local<v8::Function>::Cast(obj->GetHiddenValue(
- v8::String::New("destructor")))->Call(obj, 0, NULL);
- }
-
- delete self;
+ v8::Local<v8::Object> obj = data.GetValue();
+ v8::Local<v8::Function>::Cast(obj->GetHiddenValue(
+ MATE_STRING_NEW(data.GetIsolate(), "destructor")))->Call(obj, 0, NULL);
+ delete data.GetParameter();
}
} // namespace atom
class ObjectLifeMonitor {
public:
- static void BindTo(v8::Handle<v8::Object> target,
+ static void BindTo(v8::Isolate* isolate,
+ v8::Handle<v8::Object> target,
v8::Handle<v8::Value> destructor);
private:
ObjectLifeMonitor();
- static void WeakCallback(v8::Isolate* isolate,
- v8::Persistent<v8::Object>* value,
- ObjectLifeMonitor* self);
+ static void WeakCallback(
+ const v8::WeakCallbackData<v8::Object, ObjectLifeMonitor>& data);
mate::ScopedPersistent<v8::Object> handle_;
return;
}
- string16 pipe_name = ReplaceStringPlaceholders(kPipeNameFormat,
+ base::string16 pipe_name = ReplaceStringPlaceholders(kPipeNameFormat,
UTF8ToUTF16(product_name),
NULL);
VLOG(1) << "Session start. cmdline is [" << cmd << "]";
// Setting the crash reporter.
- string16 pipe_name = ReplaceStringPlaceholders(kPipeNameFormat,
+ base::string16 pipe_name = ReplaceStringPlaceholders(kPipeNameFormat,
application_name,
NULL);
cmd_line.AppendSwitch("no-window");
timers = require 'timers'
Module = require 'module'
+process.atomBinding = (name) -> process.binding "atom_#{process.type}_#{name}"
+
# Add common/api/lib to module search paths.
globalPaths = Module.globalPaths
globalPaths.push path.join(process.resourcesPath, 'atom', 'common', 'api', 'lib')
#include "ui/gfx/codec/jpeg_codec.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/image/image_skia.h"
+#include "ui/base/layout.h"
namespace mate {
strip_null_from_objects_ = val;
}
-v8::Handle<v8::Value> V8ValueConverter::ToV8Value(
- const base::Value* value, v8::Handle<v8::Context> context) const {
+v8::Local<v8::Value> V8ValueConverter::ToV8Value(
+ const base::Value* value, v8::Local<v8::Context> context) const {
v8::Context::Scope context_scope(context);
- v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
- return handle_scope.Close(ToV8ValueImpl(value));
+ v8::EscapableHandleScope handle_scope(context->GetIsolate());
+ return handle_scope.Escape(ToV8ValueImpl(context->GetIsolate(), value));
}
-Value* V8ValueConverter::FromV8Value(
- v8::Handle<v8::Value> val,
- v8::Handle<v8::Context> context) const {
+base::Value* V8ValueConverter::FromV8Value(
+ v8::Local<v8::Value> val,
+ v8::Local<v8::Context> context) const {
v8::Context::Scope context_scope(context);
- v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
+ v8::HandleScope handle_scope(context->GetIsolate());
HashToHandleMap unique_map;
return FromV8ValueImpl(val, &unique_map);
}
-v8::Handle<v8::Value> V8ValueConverter::ToV8ValueImpl(
- const base::Value* value) const {
+v8::Local<v8::Value> V8ValueConverter::ToV8ValueImpl(
+ v8::Isolate* isolate, const base::Value* value) const {
CHECK(value);
switch (value->GetType()) {
case base::Value::TYPE_NULL:
- return v8::Null();
+ return v8::Null(isolate);
case base::Value::TYPE_BOOLEAN: {
bool val = false;
CHECK(value->GetAsBoolean(&val));
- return v8::Boolean::New(val);
+ return v8::Boolean::New(isolate, val);
}
case base::Value::TYPE_INTEGER: {
int val = 0;
CHECK(value->GetAsInteger(&val));
- return v8::Integer::New(val);
+ return v8::Integer::New(isolate, val);
}
case base::Value::TYPE_DOUBLE: {
double val = 0.0;
CHECK(value->GetAsDouble(&val));
- return v8::Number::New(val);
+ return v8::Number::New(isolate, val);
}
case base::Value::TYPE_STRING: {
std::string val;
CHECK(value->GetAsString(&val));
- return v8::String::New(val.c_str(), val.length());
+ return v8::String::NewFromUtf8(
+ isolate, val.c_str(), v8::String::kNormalString, val.length());
}
case base::Value::TYPE_LIST:
- return ToV8Array(static_cast<const base::ListValue*>(value));
+ return ToV8Array(isolate, static_cast<const base::ListValue*>(value));
case base::Value::TYPE_DICTIONARY:
- return ToV8Object(static_cast<const base::DictionaryValue*>(value));
+ return ToV8Object(isolate,
+ static_cast<const base::DictionaryValue*>(value));
default:
LOG(ERROR) << "Unexpected value type: " << value->GetType();
- return v8::Null();
+ return v8::Null(isolate);
}
}
-v8::Handle<v8::Value> V8ValueConverter::ToV8Array(
- const base::ListValue* val) const {
- v8::Handle<v8::Array> result(v8::Array::New(val->GetSize()));
+v8::Local<v8::Value> V8ValueConverter::ToV8Array(
+ v8::Isolate* isolate, const base::ListValue* val) const {
+ v8::Local<v8::Array> result(v8::Array::New(isolate, val->GetSize()));
for (size_t i = 0; i < val->GetSize(); ++i) {
const base::Value* child = NULL;
CHECK(val->Get(i, &child));
- v8::Handle<v8::Value> child_v8 = ToV8ValueImpl(child);
+ v8::Local<v8::Value> child_v8 = ToV8ValueImpl(isolate, child);
CHECK(!child_v8.IsEmpty());
v8::TryCatch try_catch;
return result;
}
-v8::Handle<v8::Value> V8ValueConverter::ToV8Object(
- const base::DictionaryValue* val) const {
- v8::Handle<v8::Object> result(v8::Object::New());
+v8::Local<v8::Value> V8ValueConverter::ToV8Object(
+ v8::Isolate* isolate, const base::DictionaryValue* val) const {
+ v8::Local<v8::Object> result(v8::Object::New(isolate));
for (base::DictionaryValue::Iterator iter(*val);
!iter.IsAtEnd(); iter.Advance()) {
const std::string& key = iter.key();
- v8::Handle<v8::Value> child_v8 = ToV8ValueImpl(&iter.value());
+ v8::Local<v8::Value> child_v8 = ToV8ValueImpl(isolate, &iter.value());
CHECK(!child_v8.IsEmpty());
v8::TryCatch try_catch;
- result->Set(v8::String::New(key.c_str(), key.length()), child_v8);
+ result->Set(
+ v8::String::NewFromUtf8(isolate, key.c_str(), v8::String::kNormalString,
+ key.length()),
+ child_v8);
if (try_catch.HasCaught()) {
LOG(ERROR) << "Setter for property " << key.c_str() << " threw an "
<< "exception.";
return result;
}
-Value* V8ValueConverter::FromV8ValueImpl(v8::Handle<v8::Value> val,
+base::Value* V8ValueConverter::FromV8ValueImpl(v8::Local<v8::Value> val,
HashToHandleMap* unique_map) const {
CHECK(!val.IsEmpty());
return NULL;
}
-Value* V8ValueConverter::FromV8Array(v8::Handle<v8::Array> val,
+base::Value* V8ValueConverter::FromV8Array(v8::Local<v8::Array> val,
HashToHandleMap* unique_map) const {
if (!UpdateAndCheckUniqueness(unique_map, val))
return base::Value::CreateNullValue();
+ v8::Isolate* isolate = v8::Isolate::GetCurrent();
scoped_ptr<v8::Context::Scope> scope;
// If val was created in a different context than our current one, change to
// that context, but change back after val is converted.
if (!val->CreationContext().IsEmpty() &&
- val->CreationContext() != v8::Context::GetCurrent())
+ val->CreationContext() != isolate->GetCurrentContext())
scope.reset(new v8::Context::Scope(val->CreationContext()));
base::ListValue* result = new base::ListValue();
// Only fields with integer keys are carried over to the ListValue.
for (uint32 i = 0; i < val->Length(); ++i) {
v8::TryCatch try_catch;
- v8::Handle<v8::Value> child_v8 = val->Get(i);
+ v8::Local<v8::Value> child_v8 = val->Get(i);
if (try_catch.HasCaught()) {
LOG(ERROR) << "Getter for index " << i << " threw an exception.";
- child_v8 = v8::Null();
+ child_v8 = v8::Null(isolate);
}
if (!val->HasRealIndexedProperty(i))
return result;
}
-Value* V8ValueConverter::FromV8Object(
- v8::Handle<v8::Object> val,
+base::Value* V8ValueConverter::FromV8Object(
+ v8::Local<v8::Object> val,
HashToHandleMap* unique_map) const {
if (!UpdateAndCheckUniqueness(unique_map, val))
return base::Value::CreateNullValue();
+ v8::Isolate* isolate = v8::Isolate::GetCurrent();
scoped_ptr<v8::Context::Scope> scope;
// If val was created in a different context than our current one, change to
// that context, but change back after val is converted.
if (!val->CreationContext().IsEmpty() &&
- val->CreationContext() != v8::Context::GetCurrent())
+ val->CreationContext() != isolate->GetCurrentContext())
scope.reset(new v8::Context::Scope(val->CreationContext()));
scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
- v8::Handle<v8::Array> property_names(val->GetOwnPropertyNames());
+ v8::Local<v8::Array> property_names(val->GetOwnPropertyNames());
for (uint32 i = 0; i < property_names->Length(); ++i) {
- v8::Handle<v8::Value> key(property_names->Get(i));
+ v8::Local<v8::Value> key(property_names->Get(i));
// Extend this test to cover more types as necessary and if sensible.
if (!key->IsString() &&
!key->IsNumber()) {
- NOTREACHED() << "Key \"" << *v8::String::AsciiValue(key) << "\" "
+ NOTREACHED() << "Key \"" << *v8::String::Utf8Value(key) << "\" "
"is neither a string nor a number";
continue;
}
v8::String::Utf8Value name_utf8(key->ToString());
v8::TryCatch try_catch;
- v8::Handle<v8::Value> child_v8 = val->Get(key);
+ v8::Local<v8::Value> child_v8 = val->Get(key);
if (try_catch.HasCaught()) {
LOG(ERROR) << "Getter for property " << *name_utf8
<< " threw an exception.";
- child_v8 = v8::Null();
+ child_v8 = v8::Null(isolate);
}
scoped_ptr<base::Value> child(FromV8ValueImpl(child_v8, unique_map));
// there *is* a "windowId" property, but since it should be an int, code
// on the browser which doesn't additionally check for null will fail.
// We can avoid all bugs related to this by stripping null.
- if (strip_null_from_objects_ && child->IsType(Value::TYPE_NULL))
+ if (strip_null_from_objects_ && child->IsType(base::Value::TYPE_NULL))
continue;
result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
bool V8ValueConverter::UpdateAndCheckUniqueness(
HashToHandleMap* map,
- v8::Handle<v8::Object> handle) const {
+ v8::Local<v8::Object> handle) const {
typedef HashToHandleMap::const_iterator Iterator;
int hash = avoid_identity_hash_for_testing_ ? 0 : handle->GetIdentityHash();
return false;
}
- map->insert(std::pair<int, v8::Handle<v8::Object> >(hash, handle));
+ map->insert(std::pair<int, v8::Local<v8::Object> >(hash, handle));
return true;
}
void SetRegExpAllowed(bool val);
void SetFunctionAllowed(bool val);
void SetStripNullFromObjects(bool val);
- v8::Handle<v8::Value> ToV8Value(const base::Value* value,
- v8::Handle<v8::Context> context) const;
- base::Value* FromV8Value(v8::Handle<v8::Value> value,
- v8::Handle<v8::Context> context) const;
+ v8::Local<v8::Value> ToV8Value(const base::Value* value,
+ v8::Local<v8::Context> context) const;
+ base::Value* FromV8Value(v8::Local<v8::Value> value,
+ v8::Local<v8::Context> context) const;
private:
- typedef std::multimap<int, v8::Handle<v8::Object> > HashToHandleMap;
-
- v8::Handle<v8::Value> ToV8ValueImpl(const base::Value* value) const;
- v8::Handle<v8::Value> ToV8Array(const base::ListValue* list) const;
- v8::Handle<v8::Value> ToV8Object(
+ typedef std::multimap<int, v8::Local<v8::Object> > HashToHandleMap;
+
+ v8::Local<v8::Value> ToV8ValueImpl(v8::Isolate* isolate,
+ const base::Value* value) const;
+ v8::Local<v8::Value> ToV8Array(v8::Isolate* isolate,
+ const base::ListValue* list) const;
+ v8::Local<v8::Value> ToV8Object(
+ v8::Isolate* isolate,
const base::DictionaryValue* dictionary) const;
- base::Value* FromV8ValueImpl(v8::Handle<v8::Value> value,
+ base::Value* FromV8ValueImpl(v8::Local<v8::Value> value,
HashToHandleMap* unique_map) const;
- base::Value* FromV8Array(v8::Handle<v8::Array> array,
+ base::Value* FromV8Array(v8::Local<v8::Array> array,
HashToHandleMap* unique_map) const;
- base::Value* FromV8Object(v8::Handle<v8::Object> object,
+ base::Value* FromV8Object(v8::Local<v8::Object> object,
HashToHandleMap* unique_map) const;
// If |handle| is not in |map|, then add it to |map| and return true.
// be unique even if there already is another handle with the same identity
// hash (key) in the map, because two objects can have the same hash.
bool UpdateAndCheckUniqueness(HashToHandleMap* map,
- v8::Handle<v8::Object> handle) const;
+ v8::Local<v8::Object> handle) const;
// If true, we will convert Date JavaScript objects to doubles.
bool date_allowed_;
base::DictionaryValue* out) {
scoped_ptr<atom::V8ValueConverter> converter(new atom::V8ValueConverter);
scoped_ptr<base::Value> value(converter->FromV8Value(
- val, v8::Context::GetCurrent()));
+ val, isolate->GetCurrentContext()));
if (value && value->IsType(base::Value::TYPE_DICTIONARY)) {
- out->Swap(static_cast<DictionaryValue*>(value.get()));
+ out->Swap(static_cast<base::DictionaryValue*>(value.get()));
return true;
} else {
return false;
base::ListValue* out) {
scoped_ptr<atom::V8ValueConverter> converter(new atom::V8ValueConverter);
scoped_ptr<base::Value> value(converter->FromV8Value(
- val, v8::Context::GetCurrent()));
+ val, isolate->GetCurrentContext()));
if (value->IsType(base::Value::TYPE_LIST)) {
- out->Swap(static_cast<ListValue*>(value.get()));
+ out->Swap(static_cast<base::ListValue*>(value.get()));
return true;
} else {
return false;
namespace {
// Empty callback for async handle.
-void UvNoOp(uv_async_t* handle, int status) {
+void UvNoOp(uv_async_t* handle) {
}
// Convert the given vector to an array of C-strings. The strings in the
// Clear uv.
uv_sem_destroy(&embed_sem_);
- uv_timer_stop(&idle_timer_);
}
void NodeBindings::Initialize() {
- // Init idle GC for browser.
- if (is_browser_) {
- uv_timer_init(uv_default_loop(), &idle_timer_);
- uv_timer_start(&idle_timer_, IdleCallback, 5000, 5000);
- }
-
// Open node's error reporting system for browser process.
node::g_standalone_mode = is_browser_;
node::g_upstream_node_mode = false;
uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_prepare_handle()));
uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_check_handle()));
- Local<FunctionTemplate> process_template = FunctionTemplate::New();
+ Local<FunctionTemplate> process_template = FunctionTemplate::New(isolate);
process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "process"));
Local<Object> process_object = process_template->GetFunction()->NewInstance();
void NodeBindings::UvRunOnce() {
DCHECK(!is_browser_ || BrowserThread::CurrentlyOn(BrowserThread::UI));
- // Use Locker in browser process.
- BrowserV8Locker locker(node_isolate);
+ // By default the global env would be used unless user specified another one
+ // (this happens for renderer process, which wraps the uv loop with web page
+ // context).
+ node::Environment* env = uv_env() ? uv_env() : global_env;
- v8::HandleScope handle_scope(node_isolate);
+ // Use Locker in browser process.
+ BrowserV8Locker locker(env->isolate());
+ v8::HandleScope handle_scope(env->isolate());
- // Enter node context while dealing with uv events, by default the global
- // env would be used unless user specified another one (this happens for
- // renderer process, which wraps the uv loop with web page context).
- node::Environment* env = uv_env() ? uv_env() : global_env;
+ // Enter node context while dealing with uv events.
v8::Context::Scope context_scope(env->context());
// Deal with uv events.
}
}
-// static
-void NodeBindings::IdleCallback(uv_timer_t*, int) {
- v8::V8::IdleNotification();
-}
-
} // namespace atom
// Thread to poll uv events.
static void EmbedThreadRunner(void *arg);
- // Do idle GC.
- static void IdleCallback(uv_timer_t*, int);
-
// Whether the libuv loop has ended.
bool embed_closed_;
// Dummy handle to make uv's loop not quit.
uv_async_t dummy_uv_handle_;
- // Timer to do idle GC.
- uv_timer_t idle_timer_;
-
// Thread for polling events.
uv_thread_t embed_thread_;
#include "atom/common/node_includes.h"
using content::RenderView;
-using WebKit::WebFrame;
-using WebKit::WebView;
+using blink::WebFrame;
+using blink::WebView;
namespace {
return RenderView::FromWebView(view);
}
-void Send(const string16& channel, const base::ListValue& arguments) {
+void Send(const base::string16& channel, const base::ListValue& arguments) {
RenderView* render_view = GetCurrentRenderView();
if (render_view == NULL)
return;
node::ThrowError("Unable to send AtomViewHostMsg_Message");
}
-string16 SendSync(const string16& channel, const base::ListValue& arguments) {
- string16 json;
+base::string16 SendSync(const base::string16& channel,
+ const base::ListValue& arguments) {
+ base::string16 json;
RenderView* render_view = GetCurrentRenderView();
if (render_view == NULL)
} // namespace
-NODE_MODULE(atom_renderer_ipc, Initialize)
+NODE_MODULE_X(atom_renderer_ipc, Initialize, NULL, NM_F_BUILTIN)
namespace {
-WebKit::WebView* GetCurrentWebView() {
- WebKit::WebFrame* frame = WebKit::WebFrame::frameForCurrentContext();
+blink::WebView* GetCurrentWebView() {
+ blink::WebFrame* frame = blink::WebFrame::frameForCurrentContext();
if (!frame)
return NULL;
return frame->view();
}
double WebView::SetZoomFactor(double factor) {
- return WebKit::WebView::zoomLevelToZoomFactor(SetZoomLevel(
- WebKit::WebView::zoomFactorToZoomLevel(factor)));
+ return blink::WebView::zoomLevelToZoomFactor(SetZoomLevel(
+ blink::WebView::zoomFactorToZoomLevel(factor)));
}
double WebView::GetZoomFactor() const {
- return WebKit::WebView::zoomLevelToZoomFactor(GetZoomLevel());
+ return blink::WebView::zoomLevelToZoomFactor(GetZoomLevel());
}
mate::ObjectTemplateBuilder WebView::GetObjectTemplateBuilder(
} // namespace
-NODE_MODULE(atom_renderer_web_view, Initialize)
+NODE_MODULE_X(atom_renderer_web_view, Initialize, NULL, NM_F_BUILTIN)
#include "native_mate/handle.h"
#include "native_mate/wrappable.h"
-namespace WebKit {
+namespace blink {
class WebView;
}
virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
v8::Isolate* isolate);
- WebKit::WebView* web_view_;
+ blink::WebView* web_view_;
DISALLOW_COPY_AND_ASSIGN(WebView);
};
#include "base/memory/scoped_ptr.h"
#include "base/values.h"
#include "content/public/renderer/render_view.h"
+#include "native_mate/converter.h"
#include "third_party/WebKit/public/web/WebFrame.h"
#include "third_party/WebKit/public/web/WebView.h"
namespace {
v8::Handle<v8::Object> GetProcessObject(v8::Handle<v8::Context> context) {
- v8::Handle<v8::Object> process =
- context->Global()->Get(v8::String::New("process"))->ToObject();
+ v8::Handle<v8::Object> process = context->Global()->Get(
+ mate::StringToV8(context->GetIsolate(), "process"))->ToObject();
DCHECK(!process.IsEmpty());
return process;
AtomRendererBindings::~AtomRendererBindings() {
}
-void AtomRendererBindings::BindToFrame(WebKit::WebFrame* frame) {
- v8::HandleScope handle_scope(node_isolate);
+void AtomRendererBindings::BindToFrame(blink::WebFrame* frame) {
+ v8::Isolate* isolate = v8::Isolate::GetCurrent();
+ v8::HandleScope handle_scope(isolate);
v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
if (context.IsEmpty())
return;
v8::Context::Scope scope(context);
- AtomBindings::BindTo(GetProcessObject(context));
+ AtomBindings::BindTo(isolate, GetProcessObject(context));
}
void AtomRendererBindings::OnBrowserMessage(content::RenderView* render_view,
- const string16& channel,
+ const base::string16& channel,
const base::ListValue& args) {
if (!render_view->GetWebView())
return;
- v8::HandleScope handle_scope(node_isolate);
+ v8::Isolate* isolate = v8::Isolate::GetCurrent();
+ v8::HandleScope handle_scope(isolate);
v8::Local<v8::Context> context =
render_view->GetWebView()->mainFrame()->mainWorldScriptContext();
std::vector<v8::Handle<v8::Value>> arguments;
arguments.reserve(1 + args.GetSize());
- arguments.push_back(mate::ConvertToV8(node_isolate, channel));
+ arguments.push_back(mate::ConvertToV8(isolate, channel));
for (size_t i = 0; i < args.GetSize(); i++) {
const base::Value* value;
arguments.push_back(converter->ToV8Value(value, context));
}
- node::MakeCallback(process, "emit", arguments.size(), &arguments[0]);
+ node::MakeCallback(isolate, process, "emit", arguments.size(), &arguments[0]);
}
} // namespace atom
class RenderView;
}
-namespace WebKit {
+namespace blink {
class WebFrame;
}
virtual ~AtomRendererBindings();
// Call BindTo for process object of the frame.
- void BindToFrame(WebKit::WebFrame* frame);
+ void BindToFrame(blink::WebFrame* frame);
// Dispatch messages from browser.
void OnBrowserMessage(content::RenderView* render_view,
- const string16& channel,
+ const base::string16& channel,
const base::ListValue& args);
private:
#include "atom/common/node_includes.h"
-using WebKit::WebFrame;
+using blink::WebFrame;
namespace atom {
AtomRenderViewObserver::~AtomRenderViewObserver() {
}
-void AtomRenderViewObserver::DidCreateDocumentElement(WebKit::WebFrame* frame) {
+void AtomRenderViewObserver::DidCreateDocumentElement(blink::WebFrame* frame) {
// Read --zoom-factor from command line.
std::string zoom_factor_str = CommandLine::ForCurrentProcess()->
GetSwitchValueASCII(switches::kZoomFactor);;
double zoom_factor;
if (!base::StringToDouble(zoom_factor_str, &zoom_factor))
return;
- double zoom_level = WebKit::WebView::zoomFactorToZoomLevel(zoom_factor);
+ double zoom_level = blink::WebView::zoomFactorToZoomLevel(zoom_factor);
frame->view()->setZoomLevel(zoom_level);
}
-void AtomRenderViewObserver::DraggableRegionsChanged(WebKit::WebFrame* frame) {
- WebKit::WebVector<WebKit::WebDraggableRegion> webregions =
+void AtomRenderViewObserver::DraggableRegionsChanged(blink::WebFrame* frame) {
+ blink::WebVector<blink::WebDraggableRegion> webregions =
frame->document().draggableRegions();
std::vector<DraggableRegion> regions;
for (size_t i = 0; i < webregions.size(); ++i) {
return handled;
}
-void AtomRenderViewObserver::OnBrowserMessage(const string16& channel,
+void AtomRenderViewObserver::OnBrowserMessage(const base::string16& channel,
const base::ListValue& args) {
if (!render_view()->GetWebView())
return;
- WebKit::WebFrame* frame = render_view()->GetWebView()->mainFrame();
+ blink::WebFrame* frame = render_view()->GetWebView()->mainFrame();
if (!renderer_client_->IsNodeBindingEnabled(frame))
return;
private:
// content::RenderViewObserver implementation.
- virtual void DidCreateDocumentElement(WebKit::WebFrame* frame) OVERRIDE;
- virtual void DraggableRegionsChanged(WebKit::WebFrame* frame) OVERRIDE;
+ virtual void DidCreateDocumentElement(blink::WebFrame* frame) OVERRIDE;
+ virtual void DraggableRegionsChanged(blink::WebFrame* frame) OVERRIDE;
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
- void OnBrowserMessage(const string16& channel,
+ void OnBrowserMessage(const base::string16& channel,
const base::ListValue& args);
// Weak reference to renderer client.
#include "atom/renderer/api/atom_renderer_bindings.h"
#include "atom/renderer/atom_render_view_observer.h"
#include "base/command_line.h"
+#include "native_mate/converter.h"
#include "third_party/WebKit/public/web/WebDocument.h"
#include "third_party/WebKit/public/web/WebFrame.h"
// Create a default empty environment which would be used when we need to
// run V8 code out of a window context (like running a uv callback).
- v8::HandleScope handle_scope(node_isolate);
- v8::Local<v8::Context> context = v8::Context::New(node_isolate);
+ v8::Isolate* isolate = v8::Isolate::GetCurrent();
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
global_env = node::Environment::New(context);
}
+void AtomRendererClient::RenderFrameCreated(
+ content::RenderFrame* render_frame) {
+}
+
void AtomRendererClient::RenderViewCreated(content::RenderView* render_view) {
new AtomRenderViewObserver(render_view, this);
}
-void AtomRendererClient::DidCreateScriptContext(WebKit::WebFrame* frame,
+void AtomRendererClient::DidCreateScriptContext(blink::WebFrame* frame,
v8::Handle<v8::Context> context,
int extension_group,
int world_id) {
v8::Context::Scope scope(context);
// Check the existance of process object to prevent duplicate initialization.
- if (context->Global()->Has(v8::String::New("process")))
+ if (context->Global()->Has(
+ mate::StringToV8(context->GetIsolate(), "process")))
return;
// Give the node loop a run to make sure everything is ready.
}
void AtomRendererClient::WillReleaseScriptContext(
- WebKit::WebFrame* frame,
+ blink::WebFrame* frame,
v8::Handle<v8::Context> context,
int world_id) {
if (!IsNodeBindingEnabled(frame))
}
}
-bool AtomRendererClient::ShouldFork(WebKit::WebFrame* frame,
+bool AtomRendererClient::ShouldFork(blink::WebFrame* frame,
const GURL& url,
const std::string& http_method,
bool is_initial_navigation,
return http_method == "GET";
}
-bool AtomRendererClient::IsNodeBindingEnabled(WebKit::WebFrame* frame) {
+bool AtomRendererClient::IsNodeBindingEnabled(blink::WebFrame* frame) {
if (node_integration_ == DISABLE)
return false;
// Node integration is enabled in main frame unless explictly disabled.
AtomRendererClient();
virtual ~AtomRendererClient();
- bool IsNodeBindingEnabled(WebKit::WebFrame* frame = NULL);
+ bool IsNodeBindingEnabled(blink::WebFrame* frame = NULL);
AtomRendererBindings* atom_bindings() const { return atom_bindings_.get(); }
DISABLE,
};
+ // content::ContentRendererClient:
virtual void RenderThreadStarted() OVERRIDE;
+ virtual void RenderFrameCreated(content::RenderFrame* render_frame) OVERRIDE;
virtual void RenderViewCreated(content::RenderView*) OVERRIDE;
- virtual void DidCreateScriptContext(WebKit::WebFrame* frame,
+ virtual void DidCreateScriptContext(blink::WebFrame* frame,
v8::Handle<v8::Context> context,
int extension_group,
int world_id) OVERRIDE;
- virtual void WillReleaseScriptContext(WebKit::WebFrame* frame,
+ virtual void WillReleaseScriptContext(blink::WebFrame* frame,
v8::Handle<v8::Context>,
- int world_id) OVERRIDE;
- virtual bool ShouldFork(WebKit::WebFrame* frame,
+ int world_id);
+ virtual bool ShouldFork(blink::WebFrame* frame,
const GURL& url,
const std::string& http_method,
bool is_initial_navigation,
NodeIntegration node_integration_;
// The main frame.
- WebKit::WebFrame* main_frame_;
+ blink::WebFrame* main_frame_;
DISALLOW_COPY_AND_ASSIGN(AtomRendererClient);
};
-Subproject commit 6f574c38020bdf9d6ed9dd079905f4b110fbd10e
+Subproject commit e6db1875d0259d7750ad57d58d6fecaeeaea0cf6
projects / platform / framework / web / crosswalk-tizen.git / commitdiff