mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Fix calls to deprecated node::ThrowError API

Browse source
This commit is contained in:
Cheng Zhao 2015-06-10 14:21:09 +08:00
parent 04d24f61fe
commit 132c13a11b
9 changed files with 43 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
atom/browser/api/atom_api_power_monitor.cc
View file

@ -41,8 +41,9 @@ void PowerMonitor::OnResume() {
// static // static
v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) { v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
if (!Browser::Get()->is_ready()) { if (!Browser::Get()->is_ready()) {
node::ThrowError("Cannot initialize \"power-monitor\" module" node::ThrowError(
"before app is ready"); isolate,
"Cannot initialize \"power-monitor\" module before app is ready");
return v8::Null(isolate); return v8::Null(isolate);
} }

42
atom/browser/api/atom_api_protocol.cc
View file

@ -192,28 +192,19 @@ Protocol::JsProtocolHandler Protocol::GetProtocolHandler(
mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder( mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder(
v8::Isolate* isolate) { v8::Isolate* isolate) {
return mate::ObjectTemplateBuilder(isolate) return mate::ObjectTemplateBuilder(isolate)
.SetMethod("registerProtocol", .SetMethod("registerProtocol", &Protocol::RegisterProtocol)
base::Bind(&Protocol::RegisterProtocol, .SetMethod("unregisterProtocol", &Protocol::UnregisterProtocol)
base::Unretained(this))) .SetMethod("isHandledProtocol", &Protocol::IsHandledProtocol)
.SetMethod("unregisterProtocol", .SetMethod("interceptProtocol", &Protocol::InterceptProtocol)
base::Bind(&Protocol::UnregisterProtocol, .SetMethod("uninterceptProtocol", &Protocol::UninterceptProtocol);
base::Unretained(this)))
.SetMethod("isHandledProtocol",
base::Bind(&Protocol::IsHandledProtocol,
base::Unretained(this)))
.SetMethod("interceptProtocol",
base::Bind(&Protocol::InterceptProtocol,
base::Unretained(this)))
.SetMethod("uninterceptProtocol",
base::Bind(&Protocol::UninterceptProtocol,
base::Unretained(this)));
} }
void Protocol::RegisterProtocol(const std::string& scheme, void Protocol::RegisterProtocol(v8::Isolate* isolate,
const std::string& scheme,
const JsProtocolHandler& callback) { const JsProtocolHandler& callback) {
if (ContainsKey(protocol_handlers_, scheme) || if (ContainsKey(protocol_handlers_, scheme) ||
job_factory_->IsHandledProtocol(scheme)) job_factory_->IsHandledProtocol(scheme))
return node::ThrowError("The scheme is already registered"); return node::ThrowError(isolate, "The scheme is already registered");
protocol_handlers_[scheme] = callback; protocol_handlers_[scheme] = callback;
BrowserThread::PostTask(BrowserThread::IO, BrowserThread::PostTask(BrowserThread::IO,
@ -222,10 +213,11 @@ void Protocol::RegisterProtocol(const std::string& scheme,
base::Unretained(this), scheme)); base::Unretained(this), scheme));
} }
void Protocol::UnregisterProtocol(const std::string& scheme) { void Protocol::UnregisterProtocol(v8::Isolate* isolate,
const std::string& scheme) {
ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme)); ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
if (it == protocol_handlers_.end()) if (it == protocol_handlers_.end())
return node::ThrowError("The scheme has not been registered"); return node::ThrowError(isolate, "The scheme has not been registered");
protocol_handlers_.erase(it); protocol_handlers_.erase(it);
BrowserThread::PostTask(BrowserThread::IO, BrowserThread::PostTask(BrowserThread::IO,
@ -238,13 +230,14 @@ bool Protocol::IsHandledProtocol(const std::string& scheme) {
return job_factory_->IsHandledProtocol(scheme); return job_factory_->IsHandledProtocol(scheme);
} }
void Protocol::InterceptProtocol(const std::string& scheme, void Protocol::InterceptProtocol(v8::Isolate* isolate,
const std::string& scheme,
const JsProtocolHandler& callback) { const JsProtocolHandler& callback) {
if (!job_factory_->HasProtocolHandler(scheme)) if (!job_factory_->HasProtocolHandler(scheme))
return node::ThrowError("Scheme does not exist."); return node::ThrowError(isolate, "Scheme does not exist.");
if (ContainsKey(protocol_handlers_, scheme)) if (ContainsKey(protocol_handlers_, scheme))
return node::ThrowError("Cannot intercept custom procotols"); return node::ThrowError(isolate, "Cannot intercept custom procotols");
protocol_handlers_[scheme] = callback; protocol_handlers_[scheme] = callback;
BrowserThread::PostTask(BrowserThread::IO, BrowserThread::PostTask(BrowserThread::IO,
@ -253,10 +246,11 @@ void Protocol::InterceptProtocol(const std::string& scheme,
base::Unretained(this), scheme)); base::Unretained(this), scheme));
} }
void Protocol::UninterceptProtocol(const std::string& scheme) { void Protocol::UninterceptProtocol(v8::Isolate* isolate,
const std::string& scheme) {
ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme)); ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
if (it == protocol_handlers_.end()) if (it == protocol_handlers_.end())
return node::ThrowError("The scheme has not been registered"); return node::ThrowError(isolate, "The scheme has not been registered");
protocol_handlers_.erase(it); protocol_handlers_.erase(it);
BrowserThread::PostTask(BrowserThread::IO, BrowserThread::PostTask(BrowserThread::IO,

10
atom/browser/api/atom_api_protocol.h
View file

@ -43,9 +43,10 @@ class Protocol : public mate::EventEmitter {
// Register/unregister an networking |scheme| which would be handled by // Register/unregister an networking |scheme| which would be handled by
// |callback|. // |callback|.
void RegisterProtocol(const std::string& scheme, void RegisterProtocol(v8::Isolate* isolate,
const std::string& scheme,
const JsProtocolHandler& callback); const JsProtocolHandler& callback);
void UnregisterProtocol(const std::string& scheme); void UnregisterProtocol(v8::Isolate* isolate, const std::string& scheme);
// Returns whether a scheme has been registered. // Returns whether a scheme has been registered.
// FIXME Should accept a callback and be asynchronous so we do not have to use // FIXME Should accept a callback and be asynchronous so we do not have to use
@ -53,9 +54,10 @@ class Protocol : public mate::EventEmitter {
bool IsHandledProtocol(const std::string& scheme); bool IsHandledProtocol(const std::string& scheme);
// Intercept/unintercept an existing protocol handler. // Intercept/unintercept an existing protocol handler.
void InterceptProtocol(const std::string& scheme, void InterceptProtocol(v8::Isolate* isolate,
const std::string& scheme,
const JsProtocolHandler& callback); const JsProtocolHandler& callback);
void UninterceptProtocol(const std::string& scheme); void UninterceptProtocol(v8::Isolate* isolate, const std::string& scheme);
// The networking related operations have to be done in IO thread. // The networking related operations have to be done in IO thread.
void RegisterProtocolInIO(const std::string& scheme); void RegisterProtocolInIO(const std::string& scheme);

5
atom/browser/api/atom_api_screen.cc
View file

@ -113,13 +113,14 @@ mate::ObjectTemplateBuilder Screen::GetObjectTemplateBuilder(
// static // static
v8::Local<v8::Value> Screen::Create(v8::Isolate* isolate) { v8::Local<v8::Value> Screen::Create(v8::Isolate* isolate) {
if (!Browser::Get()->is_ready()) { if (!Browser::Get()->is_ready()) {
node::ThrowError("Cannot initialize \"screen\" module before app is ready"); node::ThrowError(isolate,
"Cannot initialize \"screen\" module before app is ready");
return v8::Null(isolate); return v8::Null(isolate);
} }
gfx::Screen* screen = gfx::Screen::GetNativeScreen(); gfx::Screen* screen = gfx::Screen::GetNativeScreen();
if (!screen) { if (!screen) {
node::ThrowError("Failed to get screen information"); node::ThrowError(isolate, "Failed to get screen information");
return v8::Null(isolate); return v8::Null(isolate);
} }

4
atom/browser/api/atom_api_tray.cc
View file

@ -32,9 +32,9 @@ Tray::~Tray() {
} }
// static // static
mate::Wrappable* Tray::New(const gfx::Image& image) { mate::Wrappable* Tray::New(v8::Isolate* isolate, const gfx::Image& image) {
if (!Browser::Get()->is_ready()) { if (!Browser::Get()->is_ready()) {
node::ThrowError("Cannot create Tray before app is ready"); node::ThrowError(isolate, "Cannot create Tray before app is ready");
return nullptr; return nullptr;
} }
return new Tray(image); return new Tray(image);

2
atom/browser/api/atom_api_tray.h
View file

@ -31,7 +31,7 @@ class Menu;
class Tray : public mate::EventEmitter, class Tray : public mate::EventEmitter,
public TrayIconObserver { public TrayIconObserver {
public: public:
static mate::Wrappable* New(const gfx::Image& image); static mate::Wrappable* New(v8::Isolate* isolate, const gfx::Image& image);
static void BuildPrototype(v8::Isolate* isolate, static void BuildPrototype(v8::Isolate* isolate,
v8::Local<v8::ObjectTemplate> prototype); v8::Local<v8::ObjectTemplate> prototype);

3
atom/browser/api/atom_api_window.cc
View file

@ -189,7 +189,8 @@ void Window::OnDevToolsClosed() {
mate::Wrappable* Window::New(v8::Isolate* isolate, mate::Wrappable* Window::New(v8::Isolate* isolate,
const mate::Dictionary& options) { const mate::Dictionary& options) {
if (!Browser::Get()->is_ready()) { if (!Browser::Get()->is_ready()) {
node::ThrowError("Cannot create BrowserWindow before app is ready"); node::ThrowError(isolate,
"Cannot create BrowserWindow before app is ready");
return nullptr; return nullptr;
} }
return new Window(options); return new Window(options);

2
atom/common/api/atom_api_id_weak_map.cc
View file

@ -35,7 +35,7 @@ int32_t IDWeakMap::Add(v8::Isolate* isolate, v8::Local<v8::Object> object) {
v8::Local<v8::Value> IDWeakMap::Get(v8::Isolate* isolate, int32_t key) { v8::Local<v8::Value> IDWeakMap::Get(v8::Isolate* isolate, int32_t key) {
if (!Has(key)) { if (!Has(key)) {
node::ThrowError("Invalid key"); node::ThrowError(isolate, "Invalid key");
return v8::Undefined(isolate); return v8::Undefined(isolate);
} }

11
atom/renderer/api/atom_api_renderer_ipc.cc
View file

@ -30,7 +30,9 @@ RenderView* GetCurrentRenderView() {
return RenderView::FromWebView(view); return RenderView::FromWebView(view);
} }
void Send(const base::string16& channel, const base::ListValue& arguments) { void Send(v8::Isolate* isolate,
const base::string16& channel,
const base::ListValue& arguments) {
RenderView* render_view = GetCurrentRenderView(); RenderView* render_view = GetCurrentRenderView();
if (render_view == NULL) if (render_view == NULL)
return; return;
@ -39,10 +41,11 @@ void Send(const base::string16& channel, const base::ListValue& arguments) {
render_view->GetRoutingID(), channel, arguments)); render_view->GetRoutingID(), channel, arguments));
if (!success) if (!success)
node::ThrowError("Unable to send AtomViewHostMsg_Message"); node::ThrowError(isolate, "Unable to send AtomViewHostMsg_Message");
} }
base::string16 SendSync(const base::string16& channel, base::string16 SendSync(v8::Isolate* isolate,
const base::string16& channel,
const base::ListValue& arguments) { const base::ListValue& arguments) {
base::string16 json; base::string16 json;
@ -57,7 +60,7 @@ base::string16 SendSync(const base::string16& channel,
bool success = render_view->Send(message); bool success = render_view->Send(message);
if (!success) if (!success)
node::ThrowError("Unable to send AtomViewHostMsg_Message_Sync"); node::ThrowError(isolate, "Unable to send AtomViewHostMsg_Message_Sync");
return json; return json;
} }