Merge pull request #569 from Gozala/bug/layout-change@787346

fix Bug 787346 - Implement layout changes r=@ochameau

@@ -8,9 +8,6 @@ doc/index.html
 doc/packages/
 doc/status.md5
 packages/*
-!packages/addon-kit/
-!packages/api-utils/
-!packages/test-harness/
 
 # Python
 *.pyc

@@ -298,7 +298,7 @@ they contain.
 
 See the
 [tutorial on unit testing](dev-guide/tutorials/unit-testing.html) and the
-[reference documentation for the `assert` module](packages/api-utils/test/assert.html)
+[reference documentation for the `assert` module](modules/sdk/test/assert.html)
 for details.
 
 #### Supported Options #####
@@ -806,7 +806,7 @@ one run of `cfx` will not, by default, be available in the next run.
 
 This includes, for example, any extra add-ons you installed, or your
 history, or any data stored using the
-[simple-storage](packages/addon-kit/simple-storage.html) API.
+[simple-storage](modules/sdk/simple-storage.html) API.
 
 To make `cfx` use a specific profile, pass the `--profiledir` option,
 specifying the path to the profile you wish to use.

@@ -109,27 +109,27 @@ Modules in the `api-utils` package implement low-level APIs. These
 modules fall roughly into three categories:
 
 * fundamental utilities such as
-[collection](packages/api-utils/collection.html) and
-[url](packages/api-utils/url.html). Many add-ons are likely to
+[collection](modules/sdk/platform/xpcom.html) and
+[url](modules/sdk/url.html). Many add-ons are likely to
 want to use modules from this category.
 
 * building blocks for higher level modules, such as
-[event/core](packages/api-utils/event/core.html),
-[event/target](packages/api-utils/event/target.html),
-[heritage](packages/api-utils/heritage.html), and
-[namespace](packages/api-utils/namespace.html). You're more
+[event/core](modules/sdk/event/core.html),
+[event/target](modules/sdk/event/target.html),
+[heritage](modules/sdk/core/heritage.html), and
+[namespace](modules/sdk/core/namespace.html). You're more
 likely to use these if you are building your own modules that
 implement new APIs, thus extending the SDK itself.
 
 * privileged modules that expose powerful low-level capabilities
-such as [xhr](packages/api-utils/xhr.html) and
-[xpcom](packages/api-utils/xpcom.html). You can use these
+such as [xhr](modules/sdk/net/xhr.html) and
+[xpcom](modules/sdk/platform/xpcom.html). You can use these
 modules in your add-on if you need to, but should be aware that
 the cost of privileged access is the need to take more elaborate
 security precautions. In many cases these modules have simpler,
 more restricted analogs in the high-level addon-kit package (for
-example, [tabs](packages/addon-kit/tabs.html) or
-[request](packages/addon-kit/request.html)).
+example, [tabs](modules/sdk/tabs.html) or
+[request](modules/sdk/request.html)).
 
 <div class="warning">
 <p>These modules are still in active development,

@@ -72,7 +72,7 @@ Suppose we have a page called "listen.html" hosted at "my-domain.org", and we wa
 from the add-on to a script embedded in that page.
 
 In the main add-on code, we have a
-[`page-mod`](packages/addon-kit/page-mod.html) that attaches the content script
+[`page-mod`](modules/sdk/page-mod.html) that attaches the content script
 "talk.js" to the right page:
 
     var data = require("self").data;
@@ -114,7 +114,7 @@ messages from the content script:
 Sending messages from the page script to the content script is just
 the same, but in reverse.
 
-Here "main.js" creates a [`page-mod`](packages/addon-kit/page-mod.html)
+Here "main.js" creates a [`page-mod`](modules/sdk/page-mod.html)
 that attaches "listen.js" to the web page:
 
     var data = require("self").data;
@@ -164,7 +164,7 @@ to communicate between page scripts and content scripts.
 Here's an example showing how to use custom DOM events to send a message
 from a content script to a page script.
 
-First, "main.js" will create a [`page-mod`](packages/addon-kit/page-mod.html)
+First, "main.js" will create a [`page-mod`](modules/sdk/page-mod.html)
 that will attach "talk.js" to the target web page:
 
     var data = require("self").data;
@@ -206,7 +206,7 @@ Finally "listen.html" listens for the new event and examines its
 Sending messages using custom DOM events from the page script
 to the content script is just the same, but in reverse.
 
-Again, "main.js" creates a [`page-mod`](packages/addon-kit/page-mod.html)
+Again, "main.js" creates a [`page-mod`](modules/sdk/page-mod.html)
 to target the page we are interested in:
 
     var data = require("self").data;

@@ -10,19 +10,19 @@ content of web pages or be notified when the user clicks a link.
 
 The SDK provides several core modules to support this:
 
-**[panel](packages/addon-kit/panel.html)**<br>
+**[panel](modules/sdk/panel.html)**<br>
 Create a dialog that can host web content.
 
-**[page-worker](packages/addon-kit/page-worker.html)**<br>
+**[page-worker](modules/sdk/page-worker.html)**<br>
 Retrieve a page and access its content, without displaying it to the user.
 
-**[page-mod](packages/addon-kit/page-mod.html)**<br>
+**[page-mod](modules/sdk/page-mod.html)**<br>
 Execute scripts in the context of selected web pages.
 
-**[widget](packages/addon-kit/widget.html)**<br>
+**[widget](modules/sdk/widget.html)**<br>
 Host an add-on's user interface, including web content.
 
-**[context-menu](packages/addon-kit/context-menu.html)**<br>
+**[context-menu](modules/sdk/context-menu.html)**<br>
 Add items to the browser's context menu.
 
 Firefox is moving towards a model in which it uses separate
@@ -57,7 +57,7 @@ relationships. The gray fill represents code written by the add-on developer.
 alt="Content script events">
 
 This might sound complicated but it doesn't need to be. The following add-on
-uses the [page-mod](packages/addon-kit/page-mod.html) module to replace the
+uses the [page-mod](modules/sdk/page-mod.html) module to replace the
 content of any web page in the `.co.uk` domain by executing a content script
 in the context of that page:
 

@@ -42,7 +42,7 @@ link clicks.
 
 Finally, it registers a listener to the user-defined `click` event which in
 turn passes the URL into the `open` function of the
-[tabs](packages/addon-kit/tabs.html) module.
+[tabs](modules/sdk/tabs.html) module.
 
 This is the `panel.js` content script that intercepts link clicks:
 

@@ -51,7 +51,7 @@ the recipient but just emits the event and continues processing.
 ## Accessing `port` in the Content Script ##
 
 <span class="aside">Note that the global `self` object is completely
-different from the [`self` module](packages/addon-kit/self.html), which
+different from the [`self` module](modules/sdk/self.html), which
 provides an API for an add-on to access its data files and ID.</span>
 
 In the content script the `port` object is available as a property of the
@@ -67,7 +67,7 @@ To receive an event from the add-on code:
 
 Compare this to the technique used to receive _built-in_ events in the
 content script. For example, to receive the `context` event in a content script
-associated with a [context menu](packages/addon-kit/context-menu.html)
+associated with a [context menu](modules/sdk/context-menu.html)
 object, you would call the `on` function attached to the global `self` object:
 
     self.on("context", function() {

@@ -5,7 +5,7 @@
 # Working with Events #
 
 The Add-on SDK supports event-driven programming through its
-[`EventEmitter`](packages/api-utils/events.html) framework.
+[`EventEmitter`](modules/sdk/deprecated/events.html) framework.
 
 Objects emit events on state changes that might be of interest to add-on code,
 such as browser windows opening, pages loading, network requests completing,
@@ -52,7 +52,7 @@ whenever the event occurs. The arguments that will be passed to the listener
 are specific to an event type and are documented with the event emitter.
 
 For example, the following add-on registers two listeners with the
-[`private-browsing`](packages/addon-kit/private-browsing.html) module to
+[`private-browsing`](modules/sdk/private-browsing.html) module to
 listen for the `start` and `stop` events, and logs a string to the console
 reporting the change:
 
@@ -83,7 +83,7 @@ with "on": for example, "onOpen", "onReady" and so on. Then in the constructor
 you can assign a listener function to this property as an alternative to
 calling the object's `on()` method.
 
-For example: the [`widget`](packages/addon-kit/widget.html) object emits
+For example: the [`widget`](modules/sdk/widget.html) object emits
 an event when the widget is clicked.
 
 The following add-on creates a widget and assigns a listener to the

@@ -5,7 +5,7 @@
 # Firefox Compatibility #
 
 One of the promises the SDK makes is to maintain compatibility for its
-["supported" or "high-level" APIs](packages/addon-kit/index.html):
+["supported" or "high-level" APIs]FIXME:
 meaning that code written against them will not need to change as new
 versions of Firefox are released.
 

@@ -72,7 +72,7 @@ access to the un-proxied DOM window, so they can see the objects added by
 libraries, so we’ll need to use the experimental [unsafeWindow](dev-guide/guides/content-scripts/accessing-the-dom.html#unsafeWindow)
 
 The main add-on script, `main.js`, will use a
-[`page-mod`](packages/addon-kit/page-mod.html)
+[`page-mod`](modules/sdk/page-mod.html)
 to inject the content script into every new page.
 
 The content script, which we'll call `library-detector.js`, will keep most of
@@ -101,7 +101,7 @@ the array of library names, and post it back to `main.js`:
 
 `main.js` responds to that message by fetching the tab
 corresponding to that worker using
-[`worker.tab`](packages/api-utils/content/worker.html#tab), and adding
+[`worker.tab`](modules/sdk/content/worker.html#tab), and adding
 the array of library names to that tab's `libraries` property:
 
     pageMod.PageMod({
@@ -134,11 +134,11 @@ a page contains more than one iframe, and those iframes use the same library.
 
 #### Showing the Library Array ####
 
-The [`widget`](packages/addon-kit/widget.html) module is a natural fit
+The [`widget`](modules/sdk/widget.html) module is a natural fit
 for displaying the library list. We'll specify its content using HTML, so we
 can display an array of icons. The widget must be able to display different
 content for different windows, so we'll use the
-[`WidgetView`](packages/addon-kit/widget.html) object.
+[`WidgetView`](modules/sdk/widget.html) object.
 
 `main.js` will create an array of icons corresponding to the array of library
 names, and use that to build the widget's HTML content dynamically:
@@ -163,7 +163,7 @@ names, and use that to build the widget's HTML content dynamically:
     }
 
 `main.js` will
-use the [`tabs`](packages/addon-kit/tabs.html) module to update the
+use the [`tabs`](modules/sdk/tabs.html) module to update the
 widget's content when necessary (for example, when the user switches between
 tabs):
 

@@ -21,7 +21,7 @@ The module-search logic needs to provide features like:
 * support for "packages": groups of related modules that are bundled together
   for easy distribution
 * easy and concise use of "stdlib" modules like `panel` and `page-mod` in
-  `packages/addon-kit/lib`, perhaps searching multiple packages for a module
+  `FIXMElib`, perhaps searching multiple packages for a module
   with the right name
 * "absolute" imports: minimize searching (and ambiguity) by specifying
   exactly which package contains the module of interest

@@ -11,7 +11,7 @@ add-on for distribution using `cfx xpi`, it will become the
 The ID is used for a variety
 of purposes. For example: [addons.mozilla.org](http://addons.mozilla.org) uses
 it to distinguish between new add-ons and updates to existing add-ons, and the
-[`simple-storage`](packages/addon-kit/simple-storage.html) module uses it
+[`simple-storage`](modules/sdk/simple-storage.html) module uses it
 to figure out which stored data belongs to which add-on.
 
 It is read from the `id` key in your add-on's [`package.json`](dev-guide/package-spec.html) file.

@@ -81,7 +81,7 @@ registers a listener function for messages from the content script
 * the content script (3) extracts the data from the page and (4) sends
 it to the main add-on code in a message
 * the main add-on code (5) receives the message and (6) sends the request,
-using the SDK's [`request`](packages/addon-kit/request.html) API
+using the SDK's [`request`](modules/sdk/request.html) API
 
 <img class="image-center" src="static-files/media/xul-migration-cs.png"
 alt="Content script organization">
@@ -101,7 +101,7 @@ There's much more information on content scripts in the
 The SDK provides a set of high level APIs providing some basic user
 interface components and functionality commonly required by add-ons.
 These are collected together in the
-[`addon-kit`](packages/addon-kit/index.html)
+[`addon-kit`]FIXME
 package. Because we expect to keep these APIs compatible as new versions
 of Firefox are released, we call them the "supported" APIs.
 
@@ -111,8 +111,8 @@ If the supported APIs do what you need, they're the best option: you get the
 benefits of compatibility across Firefox releases and of the SDK's security
 model.
 
-APIs like [`widget`](packages/addon-kit/widget.html) and
-[`panel`](packages/addon-kit/panel.html) are very generic and with the
+APIs like [`widget`](modules/sdk/widget.html) and
+[`panel`](modules/sdk/panel.html) are very generic and with the
 right content can be used to replace many specific XUL elements. But there are
 some notable limitations in the SDK APIs and even a fairly simple UI may need
 some degree of redesign to work with them.
@@ -166,8 +166,8 @@ continue to work as new versions of Firefox are released.
 
 In addition to the High-Level APIs, the SDK includes a number of
 Low-Level APIs some of which, such
-as [`tab-browser`](packages/api-utils/tab-browser.html), [`xhr`](packages/api-utils/xhr.html), and
-[`window-utils`](packages/api-utils/window-utils.html), expose powerful
+as [`tab-browser`](modules/sdk/deprecated/tab-browser.html), [`xhr`](modules/sdk/net/xhr.html), and
+[`window-utils`](modules/sdk/deprecated/window-utils.html), expose powerful
 browser capabilities.
 
 In this section we'll use low-level modules how to:
@@ -178,7 +178,7 @@ object
 
 ### <a name="browser-chrome">Modifying the Browser Chrome</a> ###
 
-The [`window-utils`](packages/api-utils/window-utils.html) module gives
+The [`window-utils`](modules/sdk/deprecated/window-utils.html) module gives
 you direct access to chrome windows, including the browser's chrome window.
 Here's a really simple example add-on that modifies the browser chrome using
 `window-utils`:
@@ -206,7 +206,7 @@ collection of [third party modules](https://wiki.mozilla.org/Jetpack/Modules).
 ### <a name="accessing-tabbrowser">Accessing <a href="https://developer.mozilla.org/en/XUL/tabbrowser">tabbrowser</a> ###
 
 
-The [`tab-browser`](packages/api-utils/tab-browser.html) module gives
+The [`tab-browser`](modules/sdk/deprecated/tab-browser.html) module gives
 you direct access to the
 [tabbrowser](https://developer.mozilla.org/en/XUL/tabbrowser) object. This
 simple example modifies the selected tab's CSS to enable the user to highlight
@@ -241,9 +241,9 @@ APIs it explicitly imports via `require()`. This is useful, because it means
 that if a malicious web page is able to inject code into your add-on's
 context, it is only able to use the APIs you have imported. For example, if
 you have only imported the
-[`notifications`](packages/addon-kit/notifications.html) module, then
+[`notifications`](modules/sdk/notifications.html) module, then
 even if a malicious web page manages to inject code into your add-on, it
-can't use the SDK's [`file`](packages/api-utils/file.html) module to
+can't use the SDK's [`file`](modules/sdk/io/file.html) module to
 access the user's data.
 
 But this means that the more powerful modules you `require()`, the greater

@@ -131,9 +131,9 @@ Learn about common development techniques, such as
     <td>
       <h4>API reference</h4>
       Reference documentation for the high-level SDK APIs found in the
-      <a href="packages/addon-kit/index.html">addon-kit</a>
+      FIXME
       package, and the low-level APIs found in the
-      <a href="packages/api-utils/index.html">api-utils</a> package.
+      FIXME.
     </td>
 
     <td>

@@ -8,27 +8,27 @@ Modules in this section implement low-level APIs. These
 modules fall roughly into three categories:
 
 * fundamental utilities such as
-[collection](packages/api-utils/collection.html) and
-[url](packages/api-utils/url.html). Many add-ons are likely to
+[collection](modules/sdk/platform/xpcom.html) and
+[url](modules/sdk/url.html). Many add-ons are likely to
 want to use modules from this category.
 
 * building blocks for higher level modules, such as
-[events](packages/api-utils/events.html),
-[worker](packages/api-utils/content/worker.html), and
-[api-utils](packages/api-utils/api-utils.html). You're more
+[events](modules/sdk/deprecated/events.html),
+[worker](modules/sdk/content/worker.html), and
+[api-utils](modules/sdk/deprecated/api-utils.html). You're more
 likely to use these if you are building your own modules that
 implement new APIs, thus extending the SDK itself.
 
 * privileged modules that expose powerful low-level capabilities
-such as [tab-browser](packages/api-utils/tab-browser.html),
-[xhr](packages/api-utils/xhr.html), and
-[xpcom](packages/api-utils/xpcom.html). You can use these
+such as [tab-browser](modules/sdk/deprecated/tab-browser.html),
+[xhr](modules/sdk/net/xhr.html), and
+[xpcom](modules/sdk/platform/xpcom.html). You can use these
 modules in your add-on if you need to, but should be aware that
 the cost of privileged access is the need to take more elaborate
 security precautions. In many cases these modules have simpler,
 more restricted analogs among the "High-Level APIs" (for
-example, [tabs](packages/addon-kit/tabs.html) or
-[request](packages/addon-kit/request.html)).
+example, [tabs](modules/sdk/tabs.html) or
+[request](modules/sdk/request.html)).
 
 These modules are still in active development, and we expect to
-make incompatible changes to them in future releases.
+make incompatible changes to them in future releases.

@@ -56,7 +56,7 @@ called `package.json`. This file is also referred to as the
   An array of JSON objects that use the following keys `name`, `type`, `value`,
   `title`, and `description`.  These JSON objects will be used to automatically
   create a preferences interface for the addon in the Add-ons Manager.
-  For more information see the documentation of [simple-prefs](packages/addon-kit/simple-prefs.html).
+  For more information see the documentation of [simple-prefs](modules/sdk/simple-prefs.html).
 
 * `license` - the name of the license as a String, with an optional
   URL in parentheses.
@@ -113,7 +113,7 @@ API documentation.
 Packages may optionally contain a directory called `data` into which
 arbitrary files may be placed, such as images or text files. The
 URL for these resources may be reached using the
-[self](packages/addon-kit/self.html) module.
+[self](modules/sdk/self.html) module.
 
   [Markdown]: http://daringfireball.net/projects/markdown/
   [non-bootstrapped XUL extension]: #guide/xul-extensions

@@ -12,7 +12,7 @@ and learned the
 </span>
 
 To add items and submenus to the Firefox context menu, use the
-[`context-menu`](packages/addon-kit/context-menu.html) module.
+[`context-menu`](modules/sdk/context-menu.html) module.
 
 Here's an add-on that adds a new context menu item. The item is
 displayed whenever something in the page is selected. When it's
@@ -86,4 +86,4 @@ is passed the selected text, which it logs
 ## Learning More ##
 
 To learn more about the `context-menu` module, see the
-[`context-menu` API reference](packages/addon-kit/context-menu.html).
+[`context-menu` API reference](modules/sdk/context-menu.html).

@@ -30,8 +30,8 @@ Third-party packages like `menuitems` can be installed in three
 different places:
 
 * in the `packages` directory under the SDK root, alongside built-in
-packages like [`addon-kit`](packages/addon-kit/index.html) and
-[`api-utils`](packages/api-utils/index.html). If you do this the package is
+packages like [`addon-kit`]FIXME and
+[`api-utils`]FIXME. If you do this the package is
 available to any other add-ons you're developing using that SDK instance,
 and the package's documentation is visible through `cfx docs`.
 * in a `packages` directory you create under your add-on's root: if you
@@ -109,7 +109,7 @@ In your add-on's `package.json` add the line:
 Note that due to
 [bug 663480](https://bugzilla.mozilla.org/show_bug.cgi?id=663480), if you
 add a `dependencies` line to `package.json`, and you use any modules from
-built-in packages like [`addon-kit`](packages/addon-kit/index.html), then
+built-in packages like [`addon-kit`]FIXME, then
 you must also declare your dependency on that built-in package, like this:
 
 <pre>

@@ -12,7 +12,7 @@ and learned the
 </span>
 
 To add a button to the toolbar, use the
-[`widget`](packages/addon-kit/widget.html) module.
+[`widget`](modules/sdk/widget.html) module.
 
 Create a new directory, navigate to it, and execute `cfx init`.
 Then open the file called "main.js" in the "lib" directory and
@@ -164,7 +164,7 @@ To learn more about working with panels, see the tutorial on
 ## Learning More ##
 
 To learn more about the widget module, see its
-[API reference documentation](packages/addon-kit/widget.html).
+[API reference documentation](modules/sdk/widget.html).
 
 To learn more about content scripts, see the
 [content scripts guide](dev-guide/guides/content-scripts/index.html).

@@ -119,11 +119,11 @@ version you downloaded.
 The page-mod matches all pages, so each time the user loads a page the page-mod
 emits the `attach` event, which will call the listener function we've assigned
 to `onAttach`. The handler is passed a
-[worker](packages/api-utils/content/worker.html) object. Each worker
+[worker](modules/sdk/content/worker.html) object. Each worker
 represents a channel of communication between the add-on code and any content
 scripts running in that particular page context. For a more detailed discussion
 of the way `page-mod` uses workers, see the
-[page-mod documentation](packages/addon-kit/page-mod.html).
+[page-mod documentation](modules/sdk/page-mod.html).
 
 In the attach handler we do three things:
 

@@ -5,7 +5,7 @@
 # Storing Annotations #
 
 Now we are able to create annotations, let's store them using the
-[`simple-storage`](packages/addon-kit/simple-storage.html) module. In
+[`simple-storage`](modules/sdk/simple-storage.html) module. In
 this chapter we will cover three topics relating to persistent storage:
 
 * using `simple-storage` to persist objects

@@ -12,7 +12,7 @@ and learned the
 </span>
 
 To display a popup dialog, use the
-[`panel`](packages/addon-kit/panel.html) module. A panel's content is
+[`panel`](modules/sdk/panel.html) module. A panel's content is
 defined using HTML. You can run content scripts in the panel: although the
 script running in the panel can't directly access your main add-on code,
 you can exchange messages between the panel script and the add-on code.
@@ -145,7 +145,7 @@ in the console.
 ## Learning More ##
 
 To learn more about the `panel` module, see the
-[`panel` API reference](packages/addon-kit/panel.html).
+[`panel` API reference](modules/sdk/panel.html).
 
 To learn more about attaching panels to widgets, see the
-[`widget` API reference](packages/addon-kit/widget.html).
+[`widget` API reference](modules/sdk/widget.html).

@@ -10,8 +10,8 @@ incompatible changes to them in future releases.</span>
 
 The [guide to event-driven programming with the SDK](dev-guide/guides/events.html)
 describes how to consume events: that is, how to listen to events generated
-by event targets. For example, you can listen to [`private-browsing`'s `start` event](packages/addon-kit/private-browsing.html#start) or the
-[`Panel` object's `show` event](packages/addon-kit/panel.html#show).
+by event targets. For example, you can listen to [`private-browsing`'s `start` event](modules/sdk/private-browsing.html#start) or the
+[`Panel` object's `show` event](modules/sdk/panel.html#show).
 
 With the SDK, it's also simple to implement your own event targets.
 This is especially useful if you want to
@@ -65,7 +65,7 @@ the output in the console.
 We can adapt this code into a separate module that exposes the SDK's
 standard event interface.
 
-To do this we'll use the [`event/core`](packages/api-utils/event/core.html)
+To do this we'll use the [`event/core`](modules/sdk/event/core.html)
 module.
 
 Create a new file in "lib" called "bookmarks.js", and add the following code:
@@ -113,7 +113,7 @@ function is implemented by calling the underlying `off()` function.
 
 We can use this module in the same way we use any other module that emits
 module-level events, such as
-[`private-browsing`](packages/addon-kit/private-browsing.html). For example,
+[`private-browsing`](modules/sdk/private-browsing.html). For example,
 we can adapt "main.js" as follows:
 
     var bookmarks = require("./bookmarks");
@@ -142,7 +142,7 @@ Sometimes we want to emit events at the level of individual objects,
 rather than at the level of the module.
 
 To do this, we can inherit from the SDK's
-[`EventTarget`](packages/api-utils/event/target.html) class. `EventTarget`
+[`EventTarget`](modules/sdk/event/target.html) class. `EventTarget`
 provides an implementation of the functions needed to add and remove
 event listeners: `on()`, `once()`, and `removeListener()`.
 
@@ -188,13 +188,13 @@ Open "bookmarks.js" and replace its contents with this code:
 The code to interact with the Places API is the same here. However:
 
 * we're now importing from four modules:
-    * [`event/core`](packages/api-utils/event/core.html) gives us
+    * [`event/core`](modules/sdk/event/core.html) gives us
 `emit()`: note that we don't need `on`, `once`, or `off`,
 since we will use `EventTarget` for adding and removing listeners
-    * [`event/target`](packages/api-utils/event/target.html) gives us
+    * [`event/target`](modules/sdk/event/target.html) gives us
 `EventTarget`, which implements the interface for adding and removing
 listeners
-    * [`heritage`](packages/api-utils/heritage.html) gives us
+    * [`heritage`](modules/sdk/core/heritage.html) gives us
 `Class()`, which we can use to inherit from `EventTarget`
     * `utils/object` gives us `merge()`, which just simplifies setting up the
 `BookmarkManager`'s properties
@@ -236,7 +236,7 @@ To use this event target we can create it and call the `on()`, `once()`, and
 Finally, most event targets accept options of the form "onEvent", where
 "Event" is the capitalized form of the event type. For example, you
 can listen to the
-[`Panel` object's `show` event](packages/addon-kit/panel.html#show)
+[`Panel` object's `show` event](modules/sdk/panel.html#show)
 either by calling:
 
     myPanel.on("show", listenerFunction);

@@ -101,9 +101,9 @@ logo. Click the icon, and a new tab will open with
 [http://www.mozilla.org/](http://www.mozilla.org/) loaded into it.
 
 This add-on uses two SDK modules: the
-[`widget`](packages/addon-kit/widget.html) module, which enables you
+[`widget`](modules/sdk/widget.html) module, which enables you
 to add buttons to the browser, and the
-[`tabs`](packages/addon-kit/tabs.html) module, which enables you to
+[`tabs`](modules/sdk/tabs.html) module, which enables you to
 perform basic operations with tabs. In this case, we've created a widget
 whose icon is the Mozilla favicon, and added a click handler that loads
 the Mozilla home page in a new tab.

@@ -93,12 +93,12 @@ on the left for the full list of APIs.
     <td>
       <h4><a href="dev-guide/tutorials/open-a-web-page.html">Open a web page</a></h4>
       Open a web page in a new browser tab or window using the
-      <code><a href="packages/addon-kit/tabs.html">tabs</a></code> module, and access its content.
+      <code><a href="modules/sdk/tabs.html">tabs</a></code> module, and access its content.
     </td>
 
     <td>
       <h4><a href="dev-guide/tutorials/list-open-tabs.html">Get the list of open tabs</a></h4>
-      Use the <code><a href="packages/addon-kit/tabs.html">tabs</a></code>
+      Use the <code><a href="modules/sdk/tabs.html">tabs</a></code>
       module to iterate through the currently open tabs, and access their content.
     </td>
 
@@ -107,7 +107,7 @@ on the left for the full list of APIs.
   <tr>
     <td>
       <h4><a href="dev-guide/tutorials/listen-for-page-load.html">Listen for page load</a></h4>
-      Use the <code><a href="packages/addon-kit/tabs.html">tabs</a></code>
+      Use the <code><a href="modules/sdk/tabs.html">tabs</a></code>
       module to get notified when new web pages are loaded, and access their content.
     </td>
 

@@ -307,7 +307,7 @@ info: London is Bob's home town.
 ## Using Localized Strings in Preferences ##
 
 By including a
-[`"preferences"` structure in your add-on's "package.json" file](packages/addon-kit/simple-prefs.html ), you can define
+[`"preferences"` structure in your add-on's "package.json" file](modules/sdk/simple-prefs.html ), you can define
 preferences for your add-on that the user can see and edit
 using Firefox's
 [Add-ons Manager](https://support.mozilla.org/en-US/kb/Using%20extensions%20with%20Firefox#w_how-to-change-extension-settings).

@@ -12,10 +12,10 @@ and learned the
 </span>
 
 To list the open tabs, you can iterate over the
-[`tabs`](packages/addon-kit/tabs.html) object itself.
+[`tabs`](modules/sdk/tabs.html) object itself.
 
 The following add-on adds a
-[`widget`](packages/addon-kit/widget.html) that logs
+[`widget`](modules/sdk/widget.html) that logs
 the URLs of open tabs when the user clicks it:
 
     var widget = require("widget").Widget({
@@ -67,7 +67,7 @@ tabs. The script adds a red border to the tab's document:
 ## Learning More ##
 
 To learn more about working with tabs in the SDK, see the
-[`tabs` API reference](packages/addon-kit/tabs.html).
+[`tabs` API reference](modules/sdk/tabs.html).
 
 To learn more about running scripts in tabs, see the
 [tutorial on using `tab.attach()`](dev-guide/tutorials/modifying-web-pages-tab.html).

@@ -12,7 +12,7 @@ and learned the
 </span>
 
 You can get notifications about new pages loading using the
-[`tabs`](packages/addon-kit/tabs.html) module. The following add-on
+[`tabs`](modules/sdk/tabs.html) module. The following add-on
 listens to the tab's built-in `ready` event and just logs the URL of each
 tab as the user loads it:
 
@@ -48,7 +48,7 @@ and specify "*" as the match-pattern.)
 ## Learning More ##
 
 To learn more about working with tabs in the SDK, see the
-[`tabs` API reference](packages/addon-kit/tabs.html). You can listen
+[`tabs` API reference](modules/sdk/tabs.html). You can listen
 for a number of other tab events, including `open`, `close`, and `activate`.
 
 To learn more about running scripts in tabs, see the

@@ -28,16 +28,15 @@ and `cfx xpi` when targeting Firefox Mobile.
 
 Right now only the following modules are fully functional:
 
-* [addon-page](packages/addon-kit/addon-page.html)
-* [page-mod](packages/addon-kit/page-mod.html)
-* [page-worker](packages/addon-kit/page-worker.html)
-* [passwords](packages/addon-kit/passwords.html)
-* [private-browsing](packages/addon-kit/private-browsing.html)
-* [request](packages/addon-kit/request.html)
-* [self](packages/addon-kit/self.html)
-* [simple-prefs](packages/addon-kit/simple-prefs.html)
-* [simple-storage](packages/addon-kit/simple-storage.html)
-* [timers](packages/addon-kit/timers.html)
+* [page-mod](modules/sdk/page-mod.html)
+* [page-worker](modules/sdk/page-worker.html)
+* [passwords](modules/sdk/passwords.html)
+* [private-browsing](modules/sdk/private-browsing.html)
+* [request](modules/sdk/request.html)
+* [self](modules/sdk/self.html)
+* [simple-prefs](modules/sdk/simple-prefs.html)
+* [simple-storage](modules/sdk/simple-storage.html)
+* [timers](modules/sdk/timers.html)
 
 We're working on adding support for the other modules.
 

@@ -13,7 +13,7 @@ and learned the
 
 To modify the page hosted by a particular tab, load a script into it
 using the `attach()` method of the
-[tab](packages/addon-kit/tabs.html) object. Because their job is
+[tab](modules/sdk/tabs.html) object. Because their job is
 to interact with web content, these scripts are called *content scripts*.
 
 Here's a simple example:
@@ -147,7 +147,7 @@ To learn more about working with tabs in the SDK, see the
 [Open a Web Page](dev-guide/tutorials/open-a-web-page.html)
 tutorial, the
 [List Open Tabs](dev-guide/tutorials/list-open-tabs.html)
-tutorial, and the [`tabs` API reference](packages/addon-kit/tabs.html).
+tutorial, and the [`tabs` API reference](modules/sdk/tabs.html).
 
 To learn more about content scripts, see the
 [content scripts guide](dev-guide/guides/content-scripts/index.html).

@@ -13,7 +13,7 @@ and learned the
 
 To modify any pages that match a particular pattern
 (for example, "http://example.org/") as they are loaded, use the
-[`page-mod`](packages/addon-kit/page-mod.html) module.
+[`page-mod`](modules/sdk/page-mod.html) module.
 
 To create a page-mod you need to specify two things:
 
@@ -52,7 +52,7 @@ alt="ietf.org eaten by page-mod" />
 ## Specifying the Match Pattern ##
 
 The match pattern uses the
-[`match-pattern`](packages/api-utils/match-pattern.html)
+[`match-pattern`](modules/sdk/page-mod/match-pattern.html)
 syntax. You can pass a single match-pattern string, or an array.
 
 ## Keeping the Content Script in a Separate File ##
@@ -214,14 +214,14 @@ You can't currently use relative URLs in style sheets loaded with
 by the relative URLs will not be found.
 
 To learn more about this, and read about a workaround, see the
-[relevant section in the page-mod API documentation](packages/addon-kit/page-mod.html#Working_with_Relative_URLs_in_CSS_Rules).
+[relevant section in the page-mod API documentation](modules/sdk/page-mod.html#Working_with_Relative_URLs_in_CSS_Rules).
 
 </div>
 
 ## Learning More ##
 
 To learn more about `page-mod`, see its
-[API reference page](packages/addon-kit/page-mod.html).
+[API reference page](modules/sdk/page-mod.html).
 In particular, the `PageMod` constructor takes several additional options
 to control its behavior:
 

@@ -12,13 +12,13 @@ and learned the
 </span>
 
 To open a new web page, you can use the
-[`tabs`](packages/addon-kit/tabs.html) module:
+[`tabs`](modules/sdk/tabs.html) module:
 
     var tabs = require("tabs");
     tabs.open("http://www.example.com");
 
 This function is asynchronous, so you don't immediately get back a
-[`tab` object](packages/addon-kit/tabs.html#Tab) which you can examine.
+[`tab` object](modules/sdk/tabs.html#Tab) which you can examine.
 To do this, pass a callback function into `open()`. The callback is assigned
 to the `onReady` property, and will be passed the tab as an argument:
 
@@ -51,7 +51,7 @@ the page which adds a red border to it:
 ## Learning More ##
 
 To learn more about working with tabs in the SDK, see the
-[`tabs` API reference](packages/addon-kit/tabs.html).
+[`tabs` API reference](modules/sdk/tabs.html).
 
 To learn more about running scripts in tabs, see the
 [tutorial on using `tab.attach()`](dev-guide/tutorials/modifying-web-pages-tab.html).

@@ -16,8 +16,8 @@ file. You can split your code into separate modules with clearly defined
 interfaces between them. You then import and use these modules from other
 parts of your add-on using the `require()` statement, in exactly that same
 way that you import core SDK modules like
-[`widget`](packages/addon-kit/widget.html) or
-[`panel`](packages/addon-kit/panel.html).
+[`widget`](modules/sdk/widget.html) or
+[`panel`](modules/sdk/panel.html).
 
 It can often make sense to structure a larger or more complex add-on as a
 collection of modules. This makes the design of the add-on easier to

@@ -0,0 +1,5 @@
+# Creating Event Emitters #
+
+The [guide to event-driven programming with the SDK](dev-guide/guides/events.html) describes
+how to consume events: that is, how to listen to events generated
+by event-emitting objects.

@@ -24,7 +24,7 @@ In a web page, you can perform Base64 encoding and decoding using the
 to the `window` object: since this object is not available in your
 main add-on code, `atob()` and `btoa()` aren't available either. Using the
 low-level
-[window-utils](packages/api-utils/window-utils.html) module you
+[window-utils](modules/sdk/deprecated/window-utils.html) module you
 can access `window`, enabling you to call these functions.
 
 However, it's good practice to encapsulate the code that directly accesses
@@ -103,16 +103,16 @@ require("test").run(exports);
 
 This file: exports three functions, each of which expects to receive a single
 argument which is an `assert` object. `assert` is supplied by the
-[`test/assert`](packages/api-utils/test/assert.html) module and implements
+[`test/assert`](modules/sdk/test/assert.html) module and implements
 the [CommonJS Unit Testing specification](http://wiki.commonjs.org/wiki/Unit_Testing/1.1).
 
 * The first two functions call `atob()` and `btoa()` and use
-[`assert.ok()`](packages/api-utils/test/assert.html)
+[`assert.ok()`](modules/sdk/test/assert.html)
 to check that the output is as expected.
 
 * The second function tests the module's error-handling code by passing an
 empty string into `atob()` and using
-[`assert.throws()`](packages/api-utils/test/assert.html)
+[`assert.throws()`](modules/sdk/test/assert.html)
 to check that the expected exception is raised.
 
 At this point your add-on ought to look like this:
@@ -157,7 +157,7 @@ modules called "test_myCode.js" or "testMyCode.js".</span>
 package
 * loads any modules whose names start with the word `test-`
 *  calls each exported function whose name starts with "test", passing it
-an [`assert`](packages/api-utils/test/assert.html) object as its only argument.
+an [`assert`](modules/sdk/test/assert.html) object as its only argument.
 
 Obviously, you don't have to pass the `--verbose` option to `cfx` if you don't
 want to; doing so just makes the output easier to read.

@@ -9,7 +9,7 @@ The `content` module exports three different traits [Loader][], [Worker][] and
 Rather, they are intended to be used by other modules that provide high
 level APIs to programs or libraries.
 
-[Loader]:packages/api-utils/content/loader.html
-[Worker]:packages/api-utils/content/worker.html
-[Symbiont]:packages/api-utils/content/symbiont.html
+[Loader]:modules/sdk/content/loader.html
+[Worker]:modules/sdk/content/worker.html
+[Symbiont]:modules/sdk/content/symbiont.html
 

@@ -9,7 +9,7 @@ validations. Trait is useful for all the compositions providing high level
 APIs for creating JavaScript contexts that can access web content.
 
 Loader is composed from the
-[EventEmitter](packages/api-utils/events.html) trait, therefore
+[EventEmitter](modules/sdk/deprecated/events.html) trait, therefore
 instances of Loader and their descendants expose all the public properties
 exposed by EventEmitter along with additional public properties:
 

@@ -40,7 +40,7 @@ Examples
 
 See the [panel][] module for a real-world example of usage of this module.
 
-[panel]:packages/addon-kit/panel.html
+[panel]:modules/sdk/panel.html
 
 Reference
 ---------
@@ -52,14 +52,14 @@ of Symbiont and their descendants expose all the public properties
 exposed by [Worker][] along with additional public properties that
 are listed below:
 
-[Worker]:packages/api-utils/content/worker.html
+[Worker]:modules/sdk/content/worker.html
 
 <api name="Symbiont">
 @constructor
 Creates a content symbiont.
 @param options {object}
   Options for the constructor. Includes all the keys that
-the [Worker](packages/api-utils/content/worker.html)
+the [Worker](modules/sdk/content/worker.html)
 constructor accepts and a few more:
 
   @prop [frame] {object}

@@ -40,7 +40,7 @@ are listed below.
       console.log(location);
     });
 
-[EventEmitter]:packages/api-utils/events.html
+[EventEmitter]:modules/sdk/deprecated/events.html
 
 <api name="Worker">
 @constructor
@@ -65,7 +65,7 @@ Options for the constructor, with the following keys:
 
 <api name="port">
 @property {EventEmitter}
-[EventEmitter](packages/api-utils/events.html) object that allows you to:
+[EventEmitter](modules/sdk/deprecated/events.html) object that allows you to:
 
 * send customized messages to the worker using the `port.emit` function
 * receive events from the worker using the `port.on` function
@@ -94,7 +94,7 @@ The URL of the content.
 <api name="tab">
 @property {object}
 If this worker is attached to a content document, returns the related 
-[tab](packages/addon-kit/tabs.html).
+[tab](modules/sdk/tabs.html).
 </api>
 
 <api name="message">

@@ -122,9 +122,9 @@ exported by the `context-menu` module.
       match pattern strings.  When <code>matchPattern</code> is an array, the
       context occurs when the menu is invoked on a page whose URL matches any of
       the patterns.  These are the same match pattern strings that you use with
-      the <a href="packages/addon-kit/page-mod.html"><code>page-mod</code></a>
+      the <a href="modules/sdk/page-mod.html"><code>page-mod</code></a>
       <code>include</code> property.
-      <a href="packages/api-utils/match-pattern.html">Read more about patterns</a>.
+      <a href="modules/sdk/page-mod/match-pattern.html">Read more about patterns</a>.
     </td>
   </tr>
   <tr>
@@ -718,7 +718,7 @@ top-level context menu.
   Creates a context that matches pages with particular URLs.  See Specifying
   Contexts above.
 @param matchPattern {string,array}
-  A [match pattern](packages/api-utils/match-pattern.html) string or an array of
+  A [match pattern](modules/sdk/page-mod/match-pattern.html) string or an array of
   match pattern strings.
 </api>
 </api>

@@ -23,7 +23,7 @@ if your add-on uses literal Unix-style path specifications, it won't work for
 users on Windows.
 
 To ensure your add-on works for everyone, generate paths using the
-[`join`](packages/api-utils/file.html#join(...)) function.  Unfortunately
+[`join`](modules/sdk/io/file.html#join(...)) function.  Unfortunately
 this API does not currently provide a way to obtain an absolute base path which
 you could then use with `join`.  For now, you need to
 [`require("chrome")`](dev-guide/tutorials/chrome.html) and use the
@@ -112,11 +112,11 @@ more about escaping characters in strings at
 @returns {stream}
   If the file is opened in text read-only `mode`, a `TextReader` is returned,
   and if text write-only mode, a `TextWriter` is returned.  See
-  [`text-streams`](packages/api-utils/text-streams.html) for information on
+  [`text-streams`](modules/sdk/io/text-streams.html) for information on
   these text stream objects.  If the file is opened in binary read-only `mode`,
   a `ByteReader` is returned, and if binary write-only mode, a `ByteWriter` is
   returned.  See
-  [`byte-streams`](packages/api-utils/byte-streams.html) for more
+  [`byte-streams`](modules/sdk/io/byte-streams.html) for more
   information on these byte stream objects.  Opened files should always be
   closed after use by calling `close` on the returned stream.
 </api>

@@ -2,11 +2,11 @@
    - License, v. 2.0. If a copy of the MPL was not distributed with this
    - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
 
-The `url/io` module provides functionality for read URLs' content.
+The `net/url` module provides functionality for read URLs' content.
 
 <api name="readURI">
 @function
-  Reads a URI and returns a [promise](packages/api-utils/promise.html).
+  Reads a URI and returns a [promise](modules/sdk/core/promise.html).
 
 @param uri {string}
   The URL, as a string, to load.

@@ -32,7 +32,7 @@ the console.
     });
 
 This one displays an icon that's stored in the add-on's `data` directory.  (See
-the [`self`](packages/addon-kit/self.html) module documentation for more information.)
+the [`self`](modules/sdk/self.html) module documentation for more information.)
 
     var notifications = require("notifications");
     var self = require("self");
@@ -54,7 +54,7 @@ the [`self`](packages/addon-kit/self.html) module documentation for more informa
     A string to display as the body of the message.
   @prop [iconURL] {string}
     The URL of an icon to display inside the message.  It may be a remote URL,
-    a data URI, or a URL returned by the [`self`](packages/addon-kit/self.html)
+    a data URI, or a URL returned by the [`self`](modules/sdk/self.html)
     module.
   @prop [onClick] {function}
     A function to be called when the user clicks the message.  It will be passed

@@ -31,7 +31,7 @@ You can modify the document in your script:
     pageMod.PageMod({
       include: "*.mozilla.org",
       contentScript: 'document.body.innerHTML = ' +
-                     ' "<h1>Page matches ruleset</h1>";'
+                     ' "<h1>Page mpackages_diratches ruleset</h1>";'
     });
 
 You can supply the content script(s) in one of two ways:
@@ -40,7 +40,7 @@ You can supply the content script(s) in one of two ways:
 * as separate files supplied in your add-on's "data" directory.