Initial commit for Chrome.* APIs in Dart

sdk/lib/chrome/dart2js/chrome_dart2js.dart

Index: sdk/lib/chrome/dart2js/chrome_dart2js.dart
diff --git a/sdk/lib/chrome/dart2js/chrome_dart2js.dart b/sdk/lib/chrome/dart2js/chrome_dart2js.dart
index 9ab5df76c696946e0dabee807690710ee49f56c2..591bf772055ee60ac8265ba040184b69e6c7ff0d 100644
--- a/sdk/lib/chrome/dart2js/chrome_dart2js.dart
+++ b/sdk/lib/chrome/dart2js/chrome_dart2js.dart
@@ -1,5 +1,7 @@
 library chrome;
 
+import 'dart:html_common';
+import 'dart:html';
 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
@@ -8,39 +10,1507 @@ library chrome;
 // Auto-generated dart:chrome library.
 
 
+
+
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+/**
+ * A set of utilities for use with the Chrome Extension APIs.
+ *
+ * Allows for easy access to required JS objects.
+ */
+
+/**
+ * A dart object, that is convertible to JS. Used for creating objects in dart,
+ * then passing them to JS.
+ *
+ * Objects that are passable to JS need to implement this interface.
+ */
+abstract class ChromeObject {
+  /*
+   * Default Constructor
+   *
+   * Called by child objects during their regular construction.
+   */
+  ChromeObject() :
+    _jsObject = null;
 
-// This is an example of exposing chrome APIs in Dart and will be replaced with
-// the proper implementation in the future.
+  /*
+   * Internal proxy constructor
+   *
+   * Creates a new object using this existing proxy.
+   */
+  ChromeObject._proxy(this._jsObject);
 
-class AppModule {
-  AppModule._();
+  /*
+   * JS Object Representation
+   */
+  Object _jsObject;
+
+  /*
+   * Return a Map representation of this object's members, non-recursively.
+   */
+  Map _toMap();
+
+  /*
+   * Return a non-recursive serialized representation of this object.
+   *
+   * Returns a Map representation, if this object has not yet been proxied,
+   * or the existing proxy, if it has already been proxied.
+   */
+  Object _serialize() {
+    if (_jsObject == null)
+      return this._toMap();
+    return _jsObject;
+  }
 
-  WindowModule get window => new WindowModule._();
+  /*
+   * Returns True if this object has a matching JS object, False otherwise.
+   */
+  bool _hasProxy() {
+    return this._jsObject != null;
+  }
 }
 
-class WindowModule {
-  WindowModule._();
+/**
+ * Useful functions for converting arguments.
+ */
 
-  void create(String url) {
-    var chrome = JS('', 'chrome');
+/**
+ * Converts the given map-type argument to js-friendly format, recursively.
+ * Returns the new Map object.
+ */
+Object _convertMapArgument(Map argument) {
+  Map m = new Map();
+  for (Object key in argument.keys)
+    m[key] = convertArgument(argument[key]);
+  return convertDartToNative_Dictionary(m);
+}
 
-    if (chrome == null) {
-      throw new UnsupportedError('Not supported by current browser');
-    }
-    var app = JS('', '#.app', chrome);
-    if (app == null) {
-      throw new UnsupportedError('Not supported by current browser');
-    }
-    var window = JS('', '#.window', app);
-    if (app == null) {
-      throw new UnsupportedError('Not supported by current browser');
-    }
-    JS('void', '#.create(#)', window, url);
+/*
+Map _convertMapArgument(Map argument) {
+  var object = JS('var', '{}');
+  for (Object key in argument.keys)
+    JS('void', '#[#] = #', object, key, convertArgument(argument[key]));
+  return object;
+}
+ */
+
+/**
+ * Converts the given list-type argument to js-friendly format, recursively.
+ * Returns the new List object.
+ */
+List _convertListArgument(List argument) {
+  List l = new List();
+  for (var i = 0; i < argument.length; i ++)
+    l.add(convertArgument(argument[i]));
+  return l;
+}
+
+/**
+ * Converts the given argument Object to js-friendly format, recursively.
+ *
+ * Flattens out all Chrome objects into their corresponding ._toMap()
+ * definitions, then converts them to JS objects.
+ *
+ * Returns the new argument.
+ *
+ * Cannot be used for functions.
+ */
+Object convertArgument(var argument) {
+  if (argument == null)
+    return argument;
+
+  if (argument is num || argument is String || argument is bool)
+    return argument;
+
+  if (argument is ChromeObject)
+    return convertArgument(argument._serialize());
+
+  if (argument is List)
+    return _convertListArgument(argument);
+
+  if (argument is Map)
+    return _convertMapArgument(argument);
+
+  if (argument is Function)
+    throw new Exception("Cannot serialize Function argument ${argument}.");
+
+  // TODO(sashab): Try and detect whether the argument is already serialized.
+  return argument;
+}
+
+/**
+ * Description of a declarative rule for handling events.
+ */
+class Rule extends ChromeObject {
+  String _id;
+  List _conditions;
+  List _actions;
+  int _priority;
+
+  /*
+   * Public (Dart) constructor
+   */
+  Rule({
+    String id,
+    List conditions,
+    List actions,
+    int priority
+  }) :
+    _id = id,
+    _conditions = conditions,
+    _actions = actions,
+    _priority = priority
+  ;
+
+  /*
+   * Private (JS) constructor
+   */
+  Rule._proxy(_jsObject)
+      : super._proxy(_jsObject);
+
+  /*
+   * Serialisation method
+   */
+  Map _toMap() {
+    Map m = {};
+    if (id != null) m['id'] = id;
+    if (conditions != null) m['conditions'] = conditions;
+    if (actions != null) m['actions'] = actions;
+    if (priority != null) m['priority'] = priority;
+    return m;
+  }
+
+  /*
+   * Public accessors
+   */
+  String get id {
+    if (!this._hasProxy())
+      return this._id;
+    return JS('String', '#.id', this._jsObject);
+  }
+
+  void set id(String id) {
+    if (!this._hasProxy())
+      this._id = id;
+    else
+      JS('void', '#.id = #', this._jsObject, convertArgument(id));
+  }
+
+  List get conditions {
+    if (!this._hasProxy())
+      return this._conditions;
+    return JS('List', '#.conditions', this._jsObject);
+  }
+
+  void set conditions(List conditions) {
+    if (!this._hasProxy())
+      this._conditions = conditions;
+    else
+      JS('void', '#.conditions = #', this._jsObject, convertArgument(conditions));
+  }
+
+  List get actions {
+    if (!this._hasProxy())
+      return this._actions;
+    return JS('List', '#.actions', this._jsObject);
+  }
+
+  void set actions(List actions) {
+    if (!this._hasProxy())
+      this._actions = actions;
+    else
+      JS('void', '#.actions = #', this._jsObject, convertArgument(actions));
+  }
+
+  int get priority {
+    if (!this._hasProxy())
+      return this._priority;
+    return JS('int', '#.priority', this._jsObject);
+  }
+
+  void set priority(int priority) {
+    if (!this._hasProxy())
+      this._priority = priority;
+    else
+      JS('void', '#.priority = #', this._jsObject, convertArgument(priority));
+  }
+
+}
+
+/**
+ * The Event class.
+ *
+ * Chrome Event classes extend this interface.
+ *
+ * e.g.
+ *
+ *  // chrome.app.runtime.onLaunched
+ *  class $Event_ChromeAppRuntimeOnLaunched extends $Event {
+ *    // constructor, passing the arity of the callback
+ *    $Event_ChromeAppRuntimeOnLaunched(jsObject) :
+ *     super._(jsObject, 1);
+ *
+ *    // methods, strengthening the Function parameter specificity
+ *    void addListener(void callback(LaunchData launchData))
+ *        => super.addListener(callback);
+ *    void removeListener(void callback(LaunchData launchData))
+ *        => super.removeListener(callback);
+ *    bool hasListener(void callback(LaunchData launchData))
+ *        => super.hasListener(callback);
+ *  }
+ *
+ */
+class $Event {
+  // JS var
+  Object _jsObject;
+
+  // number of arguments the callback takes
+  int _callbackArity;
+
+  // constructor
+  $Event._(this._jsObject, this._callbackArity);
+
+  // methods
+
+  /**
+   * Registers an event listener <em>callback</em> to an event.
+   */
+  void addListener(Function callback) =>
+      JS('void',
+         '#.addListener(#)',
+         this._jsObject,
+         convertDartClosureToJS(callback, this._callbackArity)
+      );
+
+  /**
+   * Deregisters an event listener <em>callback</em> from an event.
+   */
+  void removeListener(Function callback) =>
+      JS('void',
+          '#.removeListener(#)',
+          this._jsObject,
+          convertDartClosureToJS(callback, this._callbackArity)
+      );
+
+  /**
+   * Returns True if <em>callback</em> is registered to the event.
+   */
+  bool hasListener(Function callback) =>
+      JS('bool',
+          '#.hasListener(#)',
+          this._jsObject,
+          convertDartClosureToJS(callback, this._callbackArity)
+      );
+
+  /**
+   * Returns true if any event listeners are registered to the event.
+   */
+  bool hasListeners() =>
+      JS('bool',
+          '#.hasListeners()',
+          this._jsObject
+      );
+
+  /**
+   * Registers rules to handle events.
+   *
+   * @param eventName Name of the event this function affects.
+   * @param rules Rules to be registered. These do not replace previously registered rules.
+   * @param callback Called with registered rules.
+   */
+  void addRules(String eventName, List<Rule> rules, [ void callback(List<Rule> rules) ]) {
+    // proxy the callback
+    void __proxied_callback(List rules) {};
+
+    if (callback != null)
+      void __proxied_callback(List rules) {
+        List<Rule> __proxy_rules = new List<Rule>();
+
+        for (Object o in rules)
+          __proxy_rules.add(new Rule._proxy(o));
+
+        callback(__proxy_rules);
+      }
+
+    JS('void',
+        '#.addRules(#, #, #)',
+        this._jsObject,
+        convertArgument(eventName),
+        convertArgument(rules),
+        convertDartClosureToJS(callback, 1)
+    );
   }
+
+  /**
+   * Returns currently registered rules.
+   *
+   * @param eventName Name of the event this function affects.
+   * @param ruleIdentifiers If an array is passed, only rules with identifiers contained in this array are returned.
+   * @param callback Called with registered rules.
+   */
+  void getRules(String eventName, [ List<String> ruleIdentifiers, void callback(List<Rule> rules) ]) {
+    // proxy the callback
+    void __proxied_callback(List rules) {};
+
+    if (callback != null)
+      void __proxied_callback(List rules) {
+        List<Rule> __proxy_rules = new List<Rule>();
+
+        for (Object o in rules)
+          __proxy_rules.add(new Rule._proxy(o));
+
+        callback(__proxy_rules);
+      }
+
+    JS('void',
+        '#.getRules(#, #, #)',
+        this._jsObject,
+        convertArgument(eventName),
+        convertArgument(ruleIdentifiers),
+        convertDartClosureToJS(callback, 1)
+    );
+  }
+
+  /**
+   * Unregisters currently registered rules.
+   *
+   * @param eventName Name of the event this function affects.
+   * @param ruleIdentifiers If an array is passed, only rules with identifiers contained in this array are unregistered.
+   * @param callback Called when rules were unregistered.
+   */
+  void removeRules(String eventName, [ List<String> ruleIdentifiers, void callback() ]) =>
+      JS('void',
+          '#.removeRules(#, #, #)',
+          this._jsObject,
+          convertArgument(eventName),
+          convertArgument(ruleIdentifiers),
+          convertDartClosureToJS(callback, 0)
+      );
 }
 
-final app = new AppModule._();
+
+
+
+
+
+
+
+
+
+
+
+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// TODO(sashab): Change all chrome-API object types to be JS-bound, so that the
+// proxy types are not needed. Instead, creation of an object also creates its
+// JS counterpart, and all objects are proxies from the start.
+
+// chrome.app
+class $API_ChromeApp {
+  /*
+   * JS Variable
+   */
+  Object _jsObject;
+
+  /*
+   * Members
+   */
+  $API_ChromeAppWindow window;
+  $API_ChromeAppRuntime runtime;
+
+  /*
+   * Constructor
+   */
+  $API_ChromeApp(this._jsObject) {
+    var window_object = JS('', '#.window', this._jsObject);
+    if (window_object == null)
+      throw new UnsupportedError('Not supported by current browser.');
+    window = new $API_ChromeAppWindow(window_object);
+
+    var runtime_object = JS('', '#.runtime', this._jsObject);
+    if (runtime_object == null)
+      throw new UnsupportedError('Not supported by current browser.');
+    runtime = new $API_ChromeAppRuntime(runtime_object);
+  }
+}
+
+// chrome
+class $API_Chrome {
+  /*
+   * JS Variable
+   */
+  Object _jsObject;
+
+  /*
+   * Members
+   */
+  $API_ChromeApp app;
+
+  /*
+   * Constructor
+   */
+  $API_Chrome() {
+    this._jsObject = JS("Object", "chrome");
+    if (this._jsObject == null)
+      throw new UnsupportedError('Not supported by current browser.');
+
+    var app_object = JS('', '#.app', this._jsObject);
+    if (app_object == null)
+      throw new UnsupportedError('Not supported by current browser.');
+    app = new $API_ChromeApp(app_object);
+  }
+}
+
+// The final chrome object
+final $API_Chrome chrome = new $API_Chrome();
+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// from app_runtime.idl
+
+/**
+ * Types
+ */
+
+// A WebIntents intent object. Deprecated.
+class Intent extends ChromeObject {
+  // The WebIntent being invoked.
+  String _action;
+
+  // The MIME type of the data.
+  String _type;
+
+  // Data associated with the intent.
+  var _data;
+
+  // Callback to be compatible with WebIntents.
+  Function _postResult;
+
+  // Callback to be compatible with WebIntents.
+  Function _postFailure;
+
+  /*
+   * Public (Dart) constructor
+   */
+  Intent({
+    String action,
+    String type,
+    var data,
+    Function postResult,
+    Function postFailure
+  }) :
+    _action = action,
+    _type = type,
+    _data = data,
+    _postResult = postResult,
+    _postFailure = postFailure
+  ;
+
+  /*
+   * Private (JS) constructor
+   */
+  Intent._proxy(_jsObject)
+      : super._proxy(_jsObject);
+
+  /*
+   * Serialisation method
+   */
+  Map _toMap() {
+    Map m = {};
+    if (action != null) m['action'] = action;
+    if (type != null) m['type'] = type;
+    if (data != null) m['data'] = data;
+    if (postResult != null) m['postResult'] = postResult;
+    if (postFailure != null) m['postFailure'] = postFailure;
+    return m;
+  }
+
+  /*
+   * Public accessors
+   */
+  String get action {
+    if (!this._hasProxy())
+      return this._action;
+    return JS('String', '#.action', this._jsObject);
+  }
+
+  void set action(String action) {
+    if (!this._hasProxy())
+      this._action = action;
+    else
+      JS('void', '#.action = #', this._jsObject, convertArgument(action));
+  }
+
+  String get type {
+    if (!this._hasProxy())
+      return this._type;
+    return JS('String', '#.action', this._jsObject);
+  }
+
+  void set type(String type) {
+    if (!this._hasProxy())
+      this._type = type;
+    else
+      JS('void', '#.type = #', this._jsObject, convertArgument(type));
+  }
+
+  /* TODO(sashab): What's the best way to return generic JS objects? */
+  Object get data {
+    if (!this._hasProxy())
+      return this._data;
+    return convertNativeToDart_SerializedScriptValue(JS('Object', '#.data', this._jsObject));
+  }
+
+  /* TODO(sashab): What's the best way to serialize generic JS objects? */
+  void set data(var data) {
+    if (!this._hasProxy())
+      this._data = data;
+    else
+      JS('void', '#.data = #', this._jsObject, convertArgument(data));
+  }
+
+  /*
+   * TODO(sashab): What is a NullCallback() type?
+   * Add postResult and postFailure once understanding what this type is, and
+   * how to pass functions back from JS.
+   */
+}
+
+class LaunchItem extends ChromeObject {
+  // FileEntry for the file.
+  FileEntry _entry;
+
+  // The MIME type of the file.
+  String _type;
+
+  /*
+   * Public constructor
+   */
+  LaunchItem({
+    FileEntry entry,
+    String type
+  }) :
+    _entry = entry,
+    _type = type
+  ;
+
+  /*
+   * Private constructor
+   */
+  LaunchItem._proxy(_jsObject)
+      : super._proxy(_jsObject);
+
+  /*
+   * Serialisation method
+   */
+  Map _toMap() {
+    Map m = {};
+    if (entry != null) m['entry'] = entry;
+    if (type != null) m['type'] = type;
+    return m;
+  }
+
+  /*
+   * Public accessors
+   */
+  FileEntry get entry {
+    if (!this._hasProxy())
+      return this._entry;
+    return JS('FileEntry', '#.entry', this._jsObject);
+  }
+
+  /* TODO(sashab): Find a way to serialize a html.FileEntry? */
+  void set entry(FileEntry entry) {
+    if (!this._hasProxy())
+      this._entry = entry;
+    else
+      JS('void', '#.entry = #', this._jsObject, convertArgument(entry));
+  }
+
+  String get type {
+    if (!this._hasProxy())
+      return this._type;
+    return JS('String', '#.type', this._jsObject);
+  }
+
+  void set type(String type) {
+    if (!this._hasProxy())
+      this._type = type;
+    else
+      JS('void', '#.type = #', this._jsObject, convertArgument(type));
+  }
+
+
+}
+
+// Optional data for the launch.
+class LaunchData extends ChromeObject {
+  Intent _intent;
+
+  // The id of the file handler that the app is being invoked with.
+  String _id;
+
+  List<LaunchItem> _items;
+
+  /*
+   * Public constructor
+   */
+  LaunchData({
+    Intent intent,
+    String id,
+    List<LaunchItem> items
+  }) :
+    _intent = intent,
+    _id = id,
+    _items = items
+  ;
+
+  /*
+   * Private constructor
+   */
+  LaunchData._proxy(_jsObject)
+      : super._proxy(_jsObject);
+
+  /*
+   * Serialisation method
+   */
+  Map _toMap() {
+    Map m = {};
+    if (intent != null) m['intent'] = intent;
+    if (id != null) m['id'] = id;
+    if (items != null) m['items'] = items;
+    return m;
+  }
+
+  /*
+   * Public accessors
+   */
+  Intent get intent {
+    if (!this._hasProxy())
+      return this._intent;
+    return new Intent._proxy(JS('Object', '#.intent', this._jsObject));
+  }
+
+  void set intent(Intent intent) {
+    if (!this._hasProxy())
+      this._intent = intent;
+    else
+      JS('void', '#.intent = #', this._jsObject, convertArgument(intent));
+  }
+
+  String get id {
+    if (!this._hasProxy())
+      return this._id;
+    return JS('String', '#.id', this._jsObject);
+  }
+
+  void set id(String id) {
+    if (!this._hasProxy())
+      this._id = id;
+    else
+      JS('void', '#.id = #', this._jsObject, convertArgument(id));
+  }
+
+  /* TODO(sashab): Wrap lists of custom types when returning. */
+  List<LaunchItem> get items {
+    if (!this._hasProxy())
+      return this._items;
+    return JS('List', '#.items', this._jsObject);
+  }
+
+  void set items(List<LaunchItem> items) {
+    if (!this._hasProxy())
+      this._items = items;
+    else
+      JS('void', '#.items = #', this._jsObject, convertArgument(items));
+  }
+}
+
+class IntentResponse extends ChromeObject {
+  // Identifies the intent.
+  int _intentId;
+
+  // Was this intent successful? (i.e., postSuccess vs postFailure).
+  bool _success;
+
+  // Data associated with the intent response.
+  Object _data;
+
+  /*
+   * Public constructor
+   */
+  IntentResponse({
+    int intentId,
+    bool success,
+    Object data
+  }) :
+    _intentId = intentId,
+    _success = success,
+    _data = data
+  ;
+
+  /*
+   * Private constructor
+   */
+  IntentResponse._proxy(JSObject _jsObject)
+      : super._proxy(_jsObject);
+
+  /*
+   * Serialisation method
+   */
+  Map _toMap() {
+    Map m = {};
+    if (intentId != null) m['intentId'] = intentId;
+    if (success != null) m['success'] = success;
+    if (data != null) m['data'] = data;
+    return m;
+  }
+
+  /*
+   * Public accessors
+   */
+  int get intentId {
+    if (!this._hasProxy())
+      return this._intentId;
+    return JS('int', '#.intentId', this._jsObject);
+  }
+
+  void set intentId(int intentId) {
+    if (!this._hasProxy())
+      this._intentId = intentId;
+    else
+      JS('void', '#.intentId = #', this._jsObject, convertArgument(intentId));
+  }
+
+  bool get success {
+    if (!this._hasProxy())
+      return this._success;
+    return JS('bool', '#.success', this._jsObject);
+  }
+
+  void set success(bool success) {
+    if (!this._hasProxy())
+      this._success = success;
+    else
+      JS('void', '#.success = #', this._jsObject, convertArgument(success));
+  }
+
+  /* TODO(sashab): What's the best way to return generic JS objects? */
+  Object get data {
+    if (!this._hasProxy())
+      return this._data;
+    return convertNativeToDart_SerializedScriptValue(JS('Object', '#.data', this._jsObject));
+  }
+
+  /* TODO(sashab): What's the best way to serialize generic JS objects? */
+  void set data(var data) {
+    if (!this._hasProxy())
+      this._data = data;
+    else
+      JS('void', '#.data = #', this._jsObject, convertArgument(data));
+  }
+}
+
+/**
+ * Events
+ */
+
+// Fired at Chrome startup to apps that were running when Chrome last shut
+// down.
+class $Event_ChromeAppRuntimeOnRestarted extends $Event {
+  /*
+   * Override callback type definitions
+   */
+  void addListener(void callback())
+      => super.addListener(callback);
+  void removeListener(void callback())
+      => super.removeListener(callback);
+  bool hasListener(void callback())
+      => super.hasListener(callback);
+
+  /*
+   * Constructor
+   */
+  $Event_ChromeAppRuntimeOnRestarted(jsObject) :
+    super._(jsObject, 0);
+}
+
+// Fired when an app is launched from the launcher or in response to a web
+// intent.
+class $Event_ChromeAppRuntimeOnLaunched extends $Event {
+  /*
+   * Override callback type definitions
+   */
+  void addListener(void callback(LaunchData launchData))
+      => super.addListener(callback);
+  void removeListener(void callback(LaunchData launchData))
+      => super.removeListener(callback);
+  bool hasListener(void callback(LaunchData launchData))
+      => super.hasListener(callback);
+
+  /*
+   * Constructor
+   */
+  $Event_ChromeAppRuntimeOnLaunched(jsObject) :
+    super._(jsObject, 1);
+}
+
+/**
+ * Functions
+ */
+class $API_ChromeAppRuntime {
+  /*
+   * API connection
+   */
+  Object _jsObject;
+
+  /*
+   * Events
+   */
+  $Event_ChromeAppRuntimeOnRestarted onRestarted;
+  $Event_ChromeAppRuntimeOnLaunched onLaunched;
+
+  /*
+   * Functions
+   */
+  void postIntentResponse(IntentResponse intentResponse) {
+    JS('void', '#.postIntentResponse(#)', this._jsObject, convertArgument(intentResponse));
+  }
+
+  /*
+   * Constructor
+   */
+  $API_ChromeAppRuntime(this._jsObject) {
+    onRestarted = new $Event_ChromeAppRuntimeOnRestarted(JS('Object', '#.onRestarted', this._jsObject));
+    onLaunched = new $Event_ChromeAppRuntimeOnLaunched(JS('Object', '#.onLaunched', this._jsObject));
+  }
+}
+
+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// from app.window.idl
+
+/**
+ * Types
+ */
+class CreateWindowOptions extends ChromeObject {
+  // Id to identify the window. This will be used to remember the size
+  // and position of the window and restore that geometry when a window
+  // with the same id (and no explicit size or position) is later opened.
+  String _id;
+
+  // Default width of the window. (Deprecated; regular bounds act like this
+  // now.)
+  int _defaultWidth;
+
+  // Default height of the window. (Deprecated; regular bounds act like this
+  // now.)
+  int _defaultHeight;
+
+  // Default X coordinate of the window. (Deprecated; regular bounds act like
+  // this now.)
+  int _defaultLeft;
+
+  // Default Y coordinate of the window. (Deprecated; regular bounds act like
+  // this now.)
+  int _defaultTop;
+
+  // Width of the window. (Deprecated; use 'bounds'.)
+  int _width;
+
+  // Height of the window. (Deprecated; use 'bounds'.)
+  int _height;
+
+  // X coordinate of the window. (Deprecated; use 'bounds'.)
+  int _left;
+
+  // Y coordinate of the window. (Deprecated; use 'bounds'.)
+  int _top;
+
+  // Minimium width of the window.
+  int _minWidth;
+
+  // Minimum height of the window.
+  int _minHeight;
+
+  // Maximum width of the window.
+  int _maxWidth;
+
+  // Maximum height of the window.
+  int _maxHeight;
+
+  // Window type: 'shell' (the default) is the only currently supported value.
+  String _type;
+
+  // Frame type: 'none' or 'chrome' (defaults to 'chrome').
+  String _frame;
+
+  // Size of the content in the window (excluding the titlebar). If specified
+  // in addition to any of the left/top/width/height parameters, this field
+  // takes precedence. If a frameBounds is specified, the frameBounds take
+  // precedence.
+  Bounds _bounds;
+
+  // If true, the window will be created in a hidden state. Call show() on
+  // the window to show it once it has been created. Defaults to false.
+  bool _hidden;
+
+  /*
+   * Public constructor
+   */
+  CreateWindowOptions({
+    String id,
+    int defaultWidth,
+    int defaultHeight,
+    int defaultLeft,
+    int defaultTop,
+    int width,
+    int height,
+    int left,
+    int top,
+    int minWidth,
+    int minHeight,
+    int maxWidth,
+    int maxHeight,
+    String type,
+    String frame,
+    Bounds bounds,
+    bool hidden
+  }) :
+    _id = id,
+    _defaultWidth = defaultWidth,
+    _defaultHeight = defaultHeight,
+    _defaultLeft = defaultLeft,
+    _defaultTop = defaultTop,
+    _width = width,
+    _height = height,
+    _left = left,
+    _top = top,
+    _minWidth = minWidth,
+    _minHeight = minHeight,
+    _maxWidth = maxWidth,
+    _maxHeight = maxHeight,
+    _type = type,
+    _frame = frame,
+    _bounds = bounds,
+    _hidden = hidden
+  ;
+
+  /*
+   * Private constructor
+   */
+  CreateWindowOptions._proxy(_jsObject)
+      : super._proxy(_jsObject);
+
+  /*
+   * Serialisation method
+   */
+  Map _toMap() {
+    Map m = {};
+    if (id != null) m['id'] = id;
+    if (defaultWidth != null) m['defaultWidth'] = defaultWidth;
+    if (defaultHeight != null) m['defaultHeight'] = defaultHeight;
+    if (defaultLeft != null) m['defaultLeft'] = defaultLeft;
+    if (defaultTop != null) m['defaultTop'] = defaultTop;
+    if (width != null) m['width'] = width;
+    if (height != null) m['height'] = height;
+    if (left != null) m['left'] = left;
+    if (top != null) m['top'] = top;
+    if (minWidth != null) m['minWidth'] = minWidth;
+    if (minHeight != null) m['minHeight'] = minHeight;
+    if (maxWidth != null) m['maxWidth'] = maxWidth;
+    if (maxHeight != null) m['maxHeight'] = maxHeight;
+    if (type != null) m['type'] = type;
+    if (frame != null) m['frame'] = frame;
+    if (bounds != null) m['bounds'] = bounds;
+    if (hidden != null) m['hidden'] = hidden;
+    return m;
+  }
+
+  /*
+   * Public accessors
+   */
+  String get id {
+    if (!this._hasProxy())
+      return this._id;
+    return JS('String', '#.id', this._jsObject);
+  }
+
+  void set id(String id) {
+    if (!this._hasProxy())
+      this._id = id;
+    else
+      JS('void', '#.id = #', this._jsObject, convertArgument(id));
+  }
+
+  int get defaultWidth {
+    if (!this._hasProxy())
+      return this._defaultWidth;
+    return JS('int', '#.defaultWidth', this._jsObject);
+  }
+
+  void set defaultWidth(int defaultWidth) {
+    if (!this._hasProxy())
+      this._defaultWidth = defaultWidth;
+    else
+      JS('void', '#.defaultWidth = #', this._jsObject, convertArgument(defaultWidth));
+  }
+
+  int get defaultHeight {
+    if (!this._hasProxy())
+      return this._defaultHeight;
+    return JS('int', '#.defaultHeight', this._jsObject);
+  }
+
+  void set defaultHeight(int defaultHeight) {
+    if (!this._hasProxy())
+      this._defaultHeight = defaultHeight;
+    else
+      JS('void', '#.defaultHeight = #', this._jsObject, convertArgument(defaultHeight));
+  }
+
+  int get defaultLeft {
+    if (!this._hasProxy())
+      return this._defaultLeft;
+    return JS('int', '#.defaultLeft', this._jsObject);
+  }
+
+  void set defaultLeft(int defaultLeft) {
+    if (!this._hasProxy())
+      this._defaultLeft = defaultLeft;
+    else
+      JS('void', '#.defaultLeft = #', this._jsObject, convertArgument(defaultLeft));
+  }
+
+  int get defaultTop {
+    if (!this._hasProxy())
+      return this._defaultTop;
+    return JS('int', '#.defaultTop', this._jsObject);
+  }
+
+  void set defaultTop(int defaultTop) {
+    if (!this._hasProxy())
+      this._defaultTop = defaultTop;
+    else
+      JS('void', '#.defaultTop = #', this._jsObject, convertArgument(defaultTop));
+  }
+
+  int get width {
+    if (!this._hasProxy())
+      return this._width;
+    return JS('int', '#.width', this._jsObject);
+  }
+
+  void set width(int width) {
+    if (!this._hasProxy())
+      this._width = width;
+    else
+      JS('void', '#.width = #', this._jsObject, convertArgument(width));
+  }
+
+  int get height {
+    if (!this._hasProxy())
+      return this._height;
+    return JS('int', '#.height', this._jsObject);
+  }
+
+  void set height(int height) {
+    if (!this._hasProxy())
+      this._height = height;
+    else
+      JS('void', '#.height = #', this._jsObject, convertArgument(height));
+  }
+
+  int get left {
+    if (!this._hasProxy())
+      return this._left;
+    return JS('int', '#.left', this._jsObject);
+  }
+
+  void set left(int left) {
+    if (!this._hasProxy())
+      this._left = left;
+    else
+      JS('void', '#.left = #', this._jsObject, convertArgument(left));
+  }
+
+  int get top {
+    if (!this._hasProxy())
+      return this._top;
+    return JS('int', '#.top', this._jsObject);
+  }
+
+  void set top(int top) {
+    if (!this._hasProxy())
+      this._top = top;
+    else
+      JS('void', '#.top = #', this._jsObject, convertArgument(top));
+  }
+
+  int get minWidth {
+    if (!this._hasProxy())
+      return this._minWidth;
+    return JS('int', '#.minWidth', this._jsObject);
+  }
+
+  void set minWidth(int minWidth) {
+    if (!this._hasProxy())
+      this._minWidth = minWidth;
+    else
+      JS('void', '#.minWidth = #', this._jsObject, convertArgument(minWidth));
+  }
+
+  int get minHeight {
+    if (!this._hasProxy())
+      return this._minHeight;
+    return JS('int', '#.minHeight', this._jsObject);
+  }
+
+  void set minHeight(int minHeight) {
+    if (!this._hasProxy())
+      this._minHeight = minHeight;
+    else
+      JS('void', '#.minHeight = #', this._jsObject, convertArgument(minHeight));
+  }
+
+  int get maxWidth {
+    if (!this._hasProxy())
+      return this._maxWidth;
+    return JS('int', '#.maxWidth', this._jsObject);
+  }
+
+  void set maxWidth(int maxWidth) {
+    if (!this._hasProxy())
+      this._maxWidth = maxWidth;
+    else
+      JS('void', '#.maxWidth = #', this._jsObject, convertArgument(maxWidth));
+  }
+
+  int get maxHeight {
+    if (!this._hasProxy())
+      return this._maxHeight;
+    return JS('int', '#.maxHeight', this._jsObject);
+  }
+
+  void set maxHeight(int maxHeight) {
+    if (!this._hasProxy())
+      this._maxHeight = maxHeight;
+    else
+      JS('void', '#.maxHeight = #', this._jsObject, convertArgument(maxHeight));
+  }
+
+  String get type {
+    if (!this._hasProxy())
+      return this._type;
+    return JS('String', '#.type', this._jsObject);
+  }
+
+  void set type(String type) {
+    if (!this._hasProxy())
+      this._type = type;
+    else
+      JS('void', '#.type = #', this._jsObject, convertArgument(type));
+  }
+
+  String get frame {
+    if (!this._hasProxy())
+      return this._frame;
+    return JS('String', '#.frame', this._jsObject);
+  }
+
+  void set frame(String frame) {
+    if (!this._hasProxy())
+      this._frame = frame;
+    else
+      JS('void', '#.frame = #', this._jsObject, convertArgument(frame));
+  }
+
+  Bounds get bounds {
+    if (!this._hasProxy())
+      return this._bounds;
+    return new Bounds._proxy(JS('Bounds', '#.bounds', this._jsObject));
+  }
+
+  void set bounds(Bounds bounds) {
+    if (!this._hasProxy())
+      this._bounds = bounds;
+    else
+      JS('void', '#.bounds = #', this._jsObject, convertArgument(bounds));
+  }
+
+  bool get hidden {
+    if (!this._hasProxy())
+      return this._hidden;
+    return JS('String', '#.hidden', this._jsObject);
+  }
+
+  void set hidden(bool hidden) {
+    if (!this._hasProxy())
+      this._hidden = hidden;
+    else
+      JS('void', '#.hidden = #', this._jsObject, convertArgument(hidden));
+  }
+}
+
+class Bounds extends ChromeObject {
+  int _left;
+  int _top;
+  int _width;
+  int _height;
+
+  /*
+   * Public constructor
+   */
+  Bounds({
+    int left,
+    int top,
+    int width,
+    int height
+  }) :
+    _left = left,
+    _top = top,
+    _width = width,
+    _height = height
+  ;
+
+
+  /*
+   * Private constructor
+   */
+  Bounds._proxy(_jsObject)
+      : super._proxy(_jsObject);
+
+  /*
+   * Serialisation method
+   */
+  Map _toMap() {
+    Map m = {};
+    if (left != null) m['left'] = left;
+    if (top != null) m['top'] = top;
+    if (width != null) m['width'] = width;
+    if (height != null) m['height'] = height;
+    return m;
+  }
+
+  /*
+   * Public accessors
+   */
+  int get width {
+    if (!this._hasProxy())
+      return this._width;
+    return JS('int', '#.width', this._jsObject);
+  }
+
+  void set width(int width) {
+    if (!this._hasProxy())
+      this._width = width;
+    else
+      JS('void', '#.width = #', this._jsObject, convertArgument(width));
+  }
+
+  int get height {
+    if (!this._hasProxy())
+      return this._height;
+    return JS('int', '#.height', this._jsObject);
+  }
+
+  void set height(int height) {
+    if (!this._hasProxy())
+      this._height = height;
+    else
+      JS('void', '#.height = #', this._jsObject, convertArgument(height));
+  }
+
+  int get left {
+    if (!this._hasProxy())
+      return this._left;
+    return JS('int', '#.left', this._jsObject);
+  }
+
+  void set left(int left) {
+    if (!this._hasProxy())
+      this._left = left;
+    else
+      JS('void', '#.left = #', this._jsObject, convertArgument(left));
+  }
+
+  int get top {
+    if (!this._hasProxy())
+      return this._top;
+    return JS('int', '#.top', this._jsObject);
+  }
+
+  void set top(int top) {
+    if (!this._hasProxy())
+      this._top = top;
+    else
+      JS('void', '#.top = #', this._jsObject, convertArgument(top));
+  }
+}
+
+class AppWindow extends ChromeObject {
+  /*
+   * Public constructor
+   * TODO(sashab): Does it make sense to be able to create a new AppWindow this way?
+   */
+  //AppWindow();
+
+  /*
+   * Private constructor
+   */
+  AppWindow._proxy(jsObject)
+      : super._proxy(jsObject);
+
+  /*
+   * Serialisation method
+   */
+  Map _toMap() {
+    return {};
+  }
+
+  /*
+   * Public accessors
+   */
+  // The JavaScript 'window' object for the created child.
+  // TODO(sashab, sra): Detect whether this is the current window, or an
+  // external one, and return an appropriately-typed object
+  WindowBase get contentWindow {
+    return JS("Window", "#.contentWindow", this._jsObject);
+  }
+
+  /*
+   * Functions
+   */
+
+  // Focus the window.
+  void focus() =>
+      JS("void", "#.focus()", this._jsObject);
+
+  // Minimize the window.
+  void minimize() =>
+      JS("void", "#.minimize()", this._jsObject);
+
+  // Is the window minimized?
+  bool isMinimized() =>
+      JS("bool", "#.isMinimized()", this._jsObject);
+
+  // Maximize the window.
+  void maximize() =>
+    JS("void", "#.maximize()", this._jsObject);
+
+  // Is the window maximized?
+  bool isMaximized() =>
+      JS("bool", "c#.isMaximized()", this._jsObject);
+
+  // Restore the window.
+  void restore() =>
+      JS("void", "#.restore()", this._jsObject);
+
+  // Move the window to the position (|left|, |top|).
+  void moveTo(int left, int top) =>
+      JS("void", "#.moveTo(#, #)", this._jsObject, left, top);
+
+  // Resize the window to |width|x|height| pixels in size.
+  void resizeTo(int width, int height) =>
+      JS("void", "#.resizeTo(#, #)", this._jsObject, width, height);
+
+  // Draw attention to the window.
+  void drawAttention() =>
+      JS("void", "#.drawAttention()", this._jsObject);
+
+  // Clear attention to the window.
+  void clearAttention() =>
+      JS("void", "#.clearAttention()", this._jsObject);
+
+  // Close the window.
+  void close() =>
+      JS("void", "#.close()", this._jsObject);
+
+  // Show the window. Does nothing if the window is already visible.
+  void show() =>
+      JS("void", "#.show()", this._jsObject);
+
+  // Hide the window. Does nothing if the window is already hidden.
+  void hide() =>
+      JS("void", "#.hide()", this._jsObject);
+
+  // Set the window's bounds.
+  void setBounds(Bounds bounds) =>
+      JS("void", "#.setBounds(#)", this._jsObject, convertArgument(bounds));
+
+}
+
+/**
+ * Functions
+ */
+class $API_ChromeAppWindow {
+  /**
+   * JS object
+   */
+  Object _jsObject;
+
+  /**
+   * Constructor
+   */
+  $API_ChromeAppWindow(this._jsObject);
+
+  /**
+   * Functions
+   */
+
+  // Returns an <a href="#type-AppWindow">AppWindow</a> object for the
+  // current script context (ie JavaScript 'window' object). This can also be
+  // called on a handle to a script context for another page, for example:
+  // otherWindow.chrome.app.window.current().
+  AppWindow current() =>
+      new AppWindow._proxy(JS("Object", "#.current()", this._jsObject));
+
+  // The size and position of a window can be specified in a number of
+  // different ways. The most simple option is not specifying anything at
+  // all, in which case a default size and platform dependent position will
+  // be used.
+  //
+  // Another option is to use the top/left and width/height properties,
+  // which will always put the window at the specified coordinates with the
+  // specified size.
+  //
+  // Yet another option is to give the window a (unique) id. This id is then
+  // used to remember the size and position of the window whenever it is
+  // moved or resized. This size and position is then used instead of the
+  // specified bounds on subsequent opening of a window with the same id. If
+  // you need to open a window with an id at a location other than the
+  // remembered default, you can create it hidden, move it to the desired
+  // location, then show it.
+  //
+  // You can also combine these various options, explicitly specifying for
+  // example the size while having the position be remembered or other
+  // combinations like that. Size and position are dealt with seperately,
+  // but individual coordinates are not. So if you specify a top (or left)
+  // coordinate, you should also specify a left (or top) coordinate, and
+  // similar for size.
+  //
+  // If you specify both a regular and a default value for the same option
+  // the regular value is the only one that takes effect.
+  void create(String url, [ CreateWindowOptions options, void callback(AppWindow created_window) ]) {
+    void __proxy_callback(Object created_window) {
+      if (?callback)
+        callback(new AppWindow._proxy(created_window));
+    }
+
+    JS("void", "#.create(#, #, #)",
+       this._jsObject,
+       url,
+       convertArgument(options),
+       convertDartClosureToJS(__proxy_callback, 1)
+    );
+  }
+}