Save the latest version when uploading distribution.

Update node: cleanup unused hacks.

Add script to download atom-shell.

The scripts are stolen from aroben/libchromiumcontent.

Add script to make distribution and upload.

The scripts are stolen from aroben/libchromiumcontent.

Ship the custom node binary build with atom-shell.

This is required by the child_process.fork, which is indeed executing
the node binary to start a script.

The node fork can be found at:
https://github.com/atom/cefode-node/tree/chromium-v8

Expose dialog.showMessageBox API.

:lipstick:

Modify Window API to be more consistent.

* '_' becomes '-'
* removes 'position' field
* adds 'center' method.

Rename atom module to atom_delegate to avoid conflicts with Atom.

Make sure the 'closed' event is emitted before 'window-all-closed'.

Update to lastest brightray.

Fix whitespace/line_length warnings of cpplint.

Expose MenuModel's methods in js.

Add Menu API. (WIP)

Pass the native window object directly in native dialog API.

Make the CallbacksRegistry a separate module, though rather small.

Use cross-platform callbacks in the dialog API.

Don't send ATOM_BROWSER_DEREFERENCE message if context is already gone.

It's possible that the object gets destructed after reloading, however
since we already released all objects in browser when unloading, it
would cause troubles when sending message in an unexist context. We just
rely on the closure to mark whether the context is gone.

A more suitable solution, however, is to restart renderer process when
doing reloading.

The unwrapArgs relies on the valueToMeta function.

Check whether id is valid when adding to weak map.

It's possible that the object has been added to weak map before and then
erased, so having an id property doesn't mean it's added in the weak map.

Clear listeners on process object when unloading.

The process object is created under node context, and it will live
through the reloading, so we are responsible for clearing the listeners
to make sure resources are not leaked.

Modify funtion's names to make RPC code more easy to understand.

Resupport cross-process callback.

It seems that it's avoidable to make callback cross-process when we
start to emitting events for GUI elements, without this feature our
implementation will be much more complicated. I will find a way to warn
about resources leak in browser.

Pass remote objects from renderer to browser by ID.

Cache remote.getCurrentWindow.

Add the generialized showMessageBox API.

Add dialog API.

Supported APIs:
* openFile
* openMultiFiles
* openFolder
* saveAs

Each API is asynchronous and accepts a callback.

URL => Url, ID => Id in coffee script.

Add 'quit' and 'window-all-closed' events for app module.

Add the 'app' built-in module.

Add Browser class to controll when the application should quit.

Add _mac suffix for obj-c files.

Add WindowList class to manage all windows.

Quiting the application is now equivalent to close all windows.

Make sure WindowClosed message is sent when window is destroyed.

Add 'closed' and 'destroyed' event for Window.

Correctly handle window's lifetime when it's closed.

Add window closing related methods for window observer.

Simply the closing model.

Closing a window requires closing web contents now.

In this way, we can prevent the close of window by using beforeunload
handler.

Release resources in browser when renderer view is gonna unloaded.

Implement beforeunload event.

Unlike normal browser which would show a dialog to choose whether to
continue, you can just return a empty string in the handler to prevent
unloading.

Drop support for cross-process callbacks.

Now it's forbidden for browser to store reference to objects (including
functions) in renderer, because when the renderer is destroyed, it's
extremely hard to clean all of corresponding objects in browser
correctly, which would cause very bad resources leak.

Enable getting window from routing id and process id.

Update to newest brightray.

Add API to get any global variable from browser.

Add Clipboard API.

Add shell.beep() API.

Add Shell API.

Include APIs:
shell.showItemInFolder
shell.openItem
shell.openExternal
shell.moveItemToTrash

Add platform_util from Chrome.

The platform_util files just come from chrome/browser/ with slight
modifications so it doesn't depend on grit/generate_resources.h, which
is not availabe in libchromiumcontent because it's generated by chrome's
chrome/app/generated_resources.grd.

Fix header guard.

:lipstick:

Add vendor/ to .gitignore, so ag won't search it.

Avoid using destoryed native objects in js API.

Uniform message names.

Messages sent to browser should be prefixed with ATOM_BROWSER_, and
messages sent to renderer should be prefixed with ATOM_RENDERER_.

Support passing callbacks from renderer to browser.

Use camelCase not under_score, I forgot it's coffee script.

Add remote.getCurrentWindow() API in renderer.

Add API to return all keys of weak map.

Make the RPC stuff code more understandable.

Allow renderer to get object in browser for arbitrary times.

Now, when creating a remote object in renderer, the browser will
reference the corresponding object by storing it in a strong map. And
when the remote object in renderer is GCed, the corresponding object
will be dereferenced in browser.

Keep an id for each object added to global weak map.

Add remote.getObject API to get object in browser by it's ID.

Should wrap WeakCallback with handle scope.

Separate stored objects by the render view.

When a render view is closed, it's not guarrenteed that all objects'
weak callback would be called. So we must clean up all objects manually
after the render view gets closed.

Add WeakMap built-in module.

Notify creation and destruction of native objects.

Enable idle GC in browser.

Tell browser to release remote object when the object is GCed.

Add v8_util.setDestructor.

This API can monitor when the object is GCed by V8, this is required by
the RPC API since we want to make sure the remote object got destroied
when object in renderer is GCed.

Cheat on the remote object's constructor name.

Add built-in v8_util module for internal use.

Better support of array type in RPC.

Module names starting with atom_common_ can be loaded by both sides.

Return object instead of function for remote object type.

Add renference links.

No more C++ RecordedObject and ObjectsRegistry code.

All RPC API will be implemented in pure javascript.

Initial RPC API implementation.

Basic usage is:
remote = require 'remote'
Window = remote.require 'window'
w = new Window { width: 800, height: 600 }

Still need to do:
* Beter support for Array type.
* Remote objects should cheat devtools.
* Support cross-process callbacks.

No more plan for ipc.sendSync in browser.

I want the browser to be fully asynchronous, so sending synchronous
messages from browser to renderer will be unacceptable.

Add ipc.sendSync in renderer.

small tune of IPC interface.

Add getRoutingID and getProcessID for window API.

Use require('ipc').send to communicate between browser and renderer.

Messages from renderer will be emitted to the process object in browser.

Renderer can now use process.send to send messages to browser.

Separate AtomBindings for renderer.

Remove RemoteObject, C++ layer should only have basic bridges.

Simpler way of inheriting EventEmitter.

Add the RemoteObject API in renderer. (not implemented yet)

Remove recorded object from registry in desturctor.

Ignore api_messages.{cc,h} for cpplint.

Share same native bindings code on both renderer and browser.

Add API messages for IPC.

Record all objects created by API in browser.

:lipstick: for cpplint.

Implement window.open.

Enable creating window with existing web contents.

Remembers all opened web frames.

There is a hack in WebKit to switch to the creation context of exception
when under node context, so we need to remember all window contexts.

Remove this when we have multi-context node.

Disable renderer sandbox.

Inject node bindings to renderer's DOM.