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.

Improve the way to integrate libuv.

Now we poll libuv's events in embed thread by adding main loop's backend
fd to a new kqueue fd, instead of directly polling on main loop's
backend fd. In this way we can avoid dealing with one shot events
overselves.

Update to latest brightray.

Add Window.url API.

Emit 'page-title-updated' as javascript event for window.

Emulate DOM's Event class.

Add observers list for NativeWindow.

Add convenient accessors for Window API.

Complete a few APIs for getters.

Add partial APIs for WebContents and NavigationController.

Add GetTitle for window API.

Expose interface of NativeWindow in javascript.

Use JavaScript to open the main window.

Fix README.

Initial empty window javascript binding.

Internal built-in module code should be wrapped under api namespace.

Initial javascript startup code.

Copy the default_app to bundle.

Write js codes in coffee script.

Add script to check coding styles.

:lipstick: for cpplint.

Add our own built-in native module system.

Don't quit browser when get fatal js error.

Use node's error reporting system in browser.

Integrate libuv with browser's message loop.

Load atom.js on startup.

Initialize node in browser process.

:lipstick:

Give URL of my libchromiumcontent build.

Build with node.

Pass brightray.gypi via parameters.

We need to make sure node.gyp can get variables in brightray.gypi, this
needs minimum modifications.

Set our WebKit preferences.

Handle keyboard events with AtomEventProcessingWindow.

Some system events like cmd+` will be handled by it automatically.

Fix devtools.

AtomBrowserMainParts is platform-independent now.

use AtomEventProcessingWindow as native window.

Steal ChromeEventProcessingWindow from chrome.

Chromium has done quite a lot of low level works for us, steal them to
ease our lives.

Implement generic native window class.

Initial empty browser.

Add submodules.