Use JavaScript to open the main window.

This commit is contained in:
Cheng Zhao 2013-04-17 20:05:43 +08:00
parent b313d94a2f
commit 60528e53ee
11 changed files with 479 additions and 25 deletions

View file

@ -7,6 +7,7 @@
],
'coffee_sources': [
'browser/api/lib/atom.coffee',
'browser/api/lib/window.coffee',
'browser/atom/atom.coffee',
],
'lib_sources': [
@ -38,6 +39,8 @@
'common/node_bindings_mac.mm',
'common/options_switches.cc',
'common/options_switches.h',
'common/v8_value_converter_impl.cc',
'common/v8_value_converter_impl.h',
'renderer/atom_render_view_observer.cc',
'renderer/atom_render_view_observer.h',
'renderer/atom_renderer_client.cc',

View file

@ -7,7 +7,8 @@
#include "base/values.h"
#include "browser/atom_browser_context.h"
#include "browser/native_window.h"
#include "content/public/renderer/v8_value_converter.h"
#include "common/v8_value_converter_impl.h"
#include "content/public/browser/web_contents.h"
using content::V8ValueConverter;
@ -18,6 +19,12 @@ namespace api {
Window::Window(v8::Handle<v8::Object> wrapper, base::DictionaryValue* options)
: EventEmitter(wrapper),
window_(NativeWindow::Create(AtomBrowserContext::Get(), options)) {
window_->InitFromOptions(options);
window_->GetWebContents()->GetController().LoadURL(
GURL("https://github.com"),
content::Referrer(),
content::PAGE_TRANSITION_AUTO_TOPLEVEL,
std::string());
}
Window::~Window() {
@ -30,7 +37,7 @@ v8::Handle<v8::Value> Window::New(const v8::Arguments &args) {
if (!args[0]->IsObject())
return node::ThrowTypeError("Bad argument");
scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
scoped_ptr<base::Value> options(
converter->FromV8Value(args[0], v8::Context::GetCurrent()));

View file

@ -4,6 +4,7 @@
#include "browser/api/atom_bindings.h"
#include "base/logging.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
@ -31,6 +32,21 @@ void AtomBindings::BindTo(v8::Handle<v8::Object> process) {
node::SetMethod(process, "atom_binding", Binding);
}
void AtomBindings::AfterLoad() {
v8::HandleScope scope;
v8::Context::Scope context_scope(node::g_context);
v8::Handle<v8::Object> global = node::g_context->Global();
v8::Handle<v8::Object> atom =
global->Get(v8::String::New("__atom"))->ToObject();
DCHECK(!atom.IsEmpty());
browser_main_parts_ = v8::Persistent<v8::Object>::New(
node_isolate,
atom->Get(v8::String::New("browserMainParts"))->ToObject());
DCHECK(!browser_main_parts_.IsEmpty());
}
// static
v8::Handle<v8::Value> AtomBindings::Binding(const v8::Arguments& args) {
v8::HandleScope scope;

View file

@ -17,13 +17,23 @@ class AtomBindings {
// Add process.atom_binding function, which behaves like process.binding but
// load native code from atom-shell instead.
void BindTo(v8::Handle<v8::Object> process);
virtual void BindTo(v8::Handle<v8::Object> process);
// Called when the node.js main script has been loaded.
virtual void AfterLoad();
// The require('atom').browserMainParts object.
v8::Handle<v8::Object> browser_main_parts() {
return browser_main_parts_;
}
private:
static v8::Handle<v8::Value> Binding(const v8::Arguments& args);
static v8::Persistent<v8::Object> binding_cache_;
v8::Persistent<v8::Object> browser_main_parts_;
DISALLOW_COPY_AND_ASSIGN(AtomBindings);
};

View file

@ -0,0 +1,3 @@
Window = process.atom_binding('window').Window
module.exports = Window

View file

@ -4,14 +4,11 @@
#include "browser/atom_browser_main_parts.h"
#include "base/values.h"
#include "browser/api/atom_bindings.h"
#include "browser/atom_browser_context.h"
#include "browser/native_window.h"
#include "brightray/browser/browser_context.h"
#include "brightray/browser/inspectable_web_contents.h"
#include "brightray/browser/inspectable_web_contents_view.h"
#include "common/node_bindings.h"
#include "vendor/node/src/node.h"
#include "vendor/node/src/node_internals.h"
namespace atom {
@ -36,6 +33,8 @@ void AtomBrowserMainParts::PostEarlyInitialization() {
atom_bindings_->BindTo(node::process);
node_bindings_->Load();
atom_bindings_->AfterLoad();
}
void AtomBrowserMainParts::PreMainMessageLoopStart() {
@ -47,22 +46,17 @@ void AtomBrowserMainParts::PreMainMessageLoopStart() {
void AtomBrowserMainParts::PreMainMessageLoopRun() {
brightray::BrowserMainParts::PreMainMessageLoopRun();
{
v8::HandleScope scope;
v8::Context::Scope context_scope(node::g_context);
v8::Handle<v8::Value> args;
node::MakeCallback(atom_bindings_->browser_main_parts(),
"preMainMessageLoopRun",
0, &args);
}
node_bindings_->RunMessageLoop();
scoped_ptr<base::DictionaryValue> options(new base::DictionaryValue);
options->SetInteger("width", 800);
options->SetInteger("height", 600);
options->SetString("title", "Atom");
// FIXME: Leak object here.
NativeWindow* window = NativeWindow::Create(browser_context(), options.get());
window->InitFromOptions(options.get());
window->GetWebContents()->GetController().LoadURL(
GURL("http://localhost"),
content::Referrer(),
content::PAGE_TRANSITION_AUTO_TOPLEVEL,
std::string());
}
} // namespace atom

View file

@ -6,7 +6,6 @@
#define ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_
#include "brightray/browser/browser_main_parts.h"
#include "common/node_bindings.h"
namespace atom {

View file

@ -1,5 +1,8 @@
var atom = require('atom');
var Window = require('window');
var mainWindow = null;
atom.browserMainParts.preMainMessageLoopRun = function() {
console.log('Create new window');
mainWindow = new Window({ width: 800, height: 600 });
}

View file

@ -0,0 +1,333 @@
// Copyright (c) 2013 GitHub, Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "common/v8_value_converter_impl.h"
#include <string>
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/values.h"
#include "v8/include/v8.h"
namespace atom {
V8ValueConverterImpl::V8ValueConverterImpl()
: date_allowed_(false),
reg_exp_allowed_(false),
function_allowed_(false),
strip_null_from_objects_(false),
avoid_identity_hash_for_testing_(false) {}
void V8ValueConverterImpl::SetDateAllowed(bool val) {
date_allowed_ = val;
}
void V8ValueConverterImpl::SetRegExpAllowed(bool val) {
reg_exp_allowed_ = val;
}
void V8ValueConverterImpl::SetFunctionAllowed(bool val) {
function_allowed_ = val;
}
void V8ValueConverterImpl::SetStripNullFromObjects(bool val) {
strip_null_from_objects_ = val;
}
v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Value(
const base::Value* value, v8::Handle<v8::Context> context) const {
v8::Context::Scope context_scope(context);
v8::HandleScope handle_scope;
return handle_scope.Close(ToV8ValueImpl(value));
}
Value* V8ValueConverterImpl::FromV8Value(
v8::Handle<v8::Value> val,
v8::Handle<v8::Context> context) const {
v8::Context::Scope context_scope(context);
v8::HandleScope handle_scope;
HashToHandleMap unique_map;
return FromV8ValueImpl(val, &unique_map);
}
v8::Handle<v8::Value> V8ValueConverterImpl::ToV8ValueImpl(
const base::Value* value) const {
CHECK(value);
switch (value->GetType()) {
case base::Value::TYPE_NULL:
return v8::Null();
case base::Value::TYPE_BOOLEAN: {
bool val = false;
CHECK(value->GetAsBoolean(&val));
return v8::Boolean::New(val);
}
case base::Value::TYPE_INTEGER: {
int val = 0;
CHECK(value->GetAsInteger(&val));
return v8::Integer::New(val);
}
case base::Value::TYPE_DOUBLE: {
double val = 0.0;
CHECK(value->GetAsDouble(&val));
return v8::Number::New(val);
}
case base::Value::TYPE_STRING: {
std::string val;
CHECK(value->GetAsString(&val));
return v8::String::New(val.c_str(), val.length());
}
case base::Value::TYPE_LIST:
return ToV8Array(static_cast<const base::ListValue*>(value));
case base::Value::TYPE_DICTIONARY:
return ToV8Object(static_cast<const base::DictionaryValue*>(value));
default:
LOG(ERROR) << "Unexpected value type: " << value->GetType();
return v8::Null();
}
}
v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Array(
const base::ListValue* val) const {
v8::Handle<v8::Array> result(v8::Array::New(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);
CHECK(!child_v8.IsEmpty());
v8::TryCatch try_catch;
result->Set(static_cast<uint32>(i), child_v8);
if (try_catch.HasCaught())
LOG(ERROR) << "Setter for index " << i << " threw an exception.";
}
return result;
}
v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Object(
const base::DictionaryValue* val) const {
v8::Handle<v8::Object> result(v8::Object::New());
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());
CHECK(!child_v8.IsEmpty());
v8::TryCatch try_catch;
result->Set(v8::String::New(key.c_str(), key.length()), child_v8);
if (try_catch.HasCaught()) {
LOG(ERROR) << "Setter for property " << key.c_str() << " threw an "
<< "exception.";
}
}
return result;
}
Value* V8ValueConverterImpl::FromV8ValueImpl(v8::Handle<v8::Value> val,
HashToHandleMap* unique_map) const {
CHECK(!val.IsEmpty());
if (val->IsNull())
return base::Value::CreateNullValue();
if (val->IsBoolean())
return new base::FundamentalValue(val->ToBoolean()->Value());
if (val->IsInt32())
return new base::FundamentalValue(val->ToInt32()->Value());
if (val->IsNumber())
return new base::FundamentalValue(val->ToNumber()->Value());
if (val->IsString()) {
v8::String::Utf8Value utf8(val->ToString());
return new base::StringValue(std::string(*utf8, utf8.length()));
}
if (val->IsUndefined())
// JSON.stringify ignores undefined.
return NULL;
if (val->IsDate()) {
if (!date_allowed_)
// JSON.stringify would convert this to a string, but an object is more
// consistent within this class.
return FromV8Object(val->ToObject(), unique_map);
v8::Date* date = v8::Date::Cast(*val);
return new base::FundamentalValue(date->NumberValue() / 1000.0);
}
if (val->IsRegExp()) {
if (!reg_exp_allowed_)
// JSON.stringify converts to an object.
return FromV8Object(val->ToObject(), unique_map);
return new base::StringValue(*v8::String::Utf8Value(val->ToString()));
}
// v8::Value doesn't have a ToArray() method for some reason.
if (val->IsArray())
return FromV8Array(val.As<v8::Array>(), unique_map);
if (val->IsFunction()) {
if (!function_allowed_)
// JSON.stringify refuses to convert function(){}.
return NULL;
return FromV8Object(val->ToObject(), unique_map);
}
if (val->IsObject()) {
return FromV8Object(val->ToObject(), unique_map);
}
LOG(ERROR) << "Unexpected v8 value type encountered.";
return NULL;
}
Value* V8ValueConverterImpl::FromV8Array(v8::Handle<v8::Array> val,
HashToHandleMap* unique_map) const {
if (!UpdateAndCheckUniqueness(unique_map, val))
return base::Value::CreateNullValue();
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())
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);
if (try_catch.HasCaught()) {
LOG(ERROR) << "Getter for index " << i << " threw an exception.";
child_v8 = v8::Null();
}
if (!val->HasRealIndexedProperty(i))
continue;
base::Value* child = FromV8ValueImpl(child_v8, unique_map);
if (child)
result->Append(child);
else
// JSON.stringify puts null in places where values don't serialize, for
// example undefined and functions. Emulate that behavior.
result->Append(base::Value::CreateNullValue());
}
return result;
}
Value* V8ValueConverterImpl::FromV8Object(
v8::Handle<v8::Object> val,
HashToHandleMap* unique_map) const {
if (!UpdateAndCheckUniqueness(unique_map, val))
return base::Value::CreateNullValue();
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())
scope.reset(new v8::Context::Scope(val->CreationContext()));
scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
v8::Handle<v8::Array> property_names(val->GetOwnPropertyNames());
for (uint32 i = 0; i < property_names->Length(); ++i) {
v8::Handle<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) << "\" "
"is neither a string nor a number";
continue;
}
// Skip all callbacks: crbug.com/139933
if (val->HasRealNamedCallbackProperty(key->ToString()))
continue;
v8::String::Utf8Value name_utf8(key->ToString());
v8::TryCatch try_catch;
v8::Handle<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();
}
scoped_ptr<base::Value> child(FromV8ValueImpl(child_v8, unique_map));
if (!child.get())
// JSON.stringify skips properties whose values don't serialize, for
// example undefined and functions. Emulate that behavior.
continue;
// Strip null if asked (and since undefined is turned into null, undefined
// too). The use case for supporting this is JSON-schema support,
// specifically for extensions, where "optional" JSON properties may be
// represented as null, yet due to buggy legacy code elsewhere isn't
// treated as such (potentially causing crashes). For example, the
// "tabs.create" function takes an object as its first argument with an
// optional "windowId" property.
//
// Given just
//
// tabs.create({})
//
// this will work as expected on code that only checks for the existence of
// a "windowId" property (such as that legacy code). However given
//
// tabs.create({windowId: null})
//
// 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))
continue;
result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
child.release());
}
return result.release();
}
bool V8ValueConverterImpl::UpdateAndCheckUniqueness(
HashToHandleMap* map,
v8::Handle<v8::Object> handle) const {
typedef HashToHandleMap::const_iterator Iterator;
int hash = avoid_identity_hash_for_testing_ ? 0 : handle->GetIdentityHash();
// We only compare using == with handles to objects with the same identity
// hash. Different hash obviously means different objects, but two objects in
// a couple of thousands could have the same identity hash.
std::pair<Iterator, Iterator> range = map->equal_range(hash);
for (Iterator it = range.first; it != range.second; ++it) {
// Operator == for handles actually compares the underlying objects.
if (it->second == handle)
return false;
}
map->insert(std::pair<int, v8::Handle<v8::Object> >(hash, handle));
return true;
}
} // namespace atom

View file

@ -0,0 +1,86 @@
// Copyright (c) 2013 GitHub, Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ATOM_COMMON_V8_VALUE_CONVERTER_IMPL_H_
#define ATOM_COMMON_V8_VALUE_CONVERTER_IMPL_H_
#include <map>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "content/public/renderer/v8_value_converter.h"
namespace base {
class BinaryValue;
class DictionaryValue;
class ListValue;
class Value;
}
namespace atom {
// The content::V8ValueConverter depends on WebKit, we get rid of the WebKit
// dependency by removing support of binary data.
class V8ValueConverterImpl : public content::V8ValueConverter {
public:
V8ValueConverterImpl();
// V8ValueConverter implementation.
virtual void SetDateAllowed(bool val) OVERRIDE;
virtual void SetRegExpAllowed(bool val) OVERRIDE;
virtual void SetFunctionAllowed(bool val) OVERRIDE;
virtual void SetStripNullFromObjects(bool val) OVERRIDE;
virtual v8::Handle<v8::Value> ToV8Value(
const base::Value* value,
v8::Handle<v8::Context> context) const OVERRIDE;
virtual base::Value* FromV8Value(
v8::Handle<v8::Value> value,
v8::Handle<v8::Context> context) const OVERRIDE;
private:
friend class ScopedAvoidIdentityHashForTesting;
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(
const base::DictionaryValue* dictionary) const;
base::Value* FromV8ValueImpl(v8::Handle<v8::Value> value,
HashToHandleMap* unique_map) const;
base::Value* FromV8Array(v8::Handle<v8::Array> array,
HashToHandleMap* unique_map) const;
base::Value* FromV8Object(v8::Handle<v8::Object> object,
HashToHandleMap* unique_map) const;
// If |handle| is not in |map|, then add it to |map| and return true.
// Otherwise do nothing and return false. Here "A is unique" means that no
// other handle B in the map points to the same object as A. Note that A can
// 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;
// If true, we will convert Date JavaScript objects to doubles.
bool date_allowed_;
// If true, we will convert RegExp JavaScript objects to string.
bool reg_exp_allowed_;
// If true, we will convert Function JavaScript objects to dictionaries.
bool function_allowed_;
// If true, undefined and null values are ignored when converting v8 objects
// into Values.
bool strip_null_from_objects_;
bool avoid_identity_hash_for_testing_;
DISALLOW_COPY_AND_ASSIGN(V8ValueConverterImpl);
};
} // namespace atom
#endif // ATOM_COMMON_V8_VALUE_CONVERTER_IMPL_H_

2
vendor/node vendored

@ -1 +1 @@
Subproject commit ff00d60bcf92fdb229cf0326e31d1aff82ed357e
Subproject commit 44cac2fd2486151f13b7ce3f033158154eedbfbd