--- a/CLOBBER
+++ b/CLOBBER
@@ -12,10 +12,9 @@
 #          O               O
 #          |               |
 #          O <-- Clobber   O  <-- Clobber
 #
 # Note: The description below will be part of the error message shown to users.
 #
 # Modifying this file will now automatically clobber the buildbot machines \o/
 #
-Bug 895173: Rename context menu id's to "home_" for home context menu.
-Android resource changes
+Removal of XPIDL for bug 893117 requires a clobber to make sure interfaces aren't generated.

--- a/accessible/public/msaa/Makefile.in
+++ b/accessible/public/msaa/Makefile.in
@@ -34,18 +34,16 @@ MIDL_GENERATED_FILES = \
 	ISimpleDOMDocument.h \
 	ISimpleDOMDocument_p.c \
 	ISimpleDOMDocument_i.c \
 	ISimpleDOMText.h \
 	ISimpleDOMText_p.c \
 	ISimpleDOMText_i.c \
 	$(NULL)
 
-SRCDIR_CSRCS	= $(addprefix $(srcdir)/,$(CSRCS))
-
 OS_LIBS = $(call EXPAND_LIBNAME,kernel32 rpcns4 rpcrt4 oleaut32)
 
 $(MIDL_GENERATED_FILES): done_gen
 
 done_gen: ISimpleDOMNode.idl \
           ISimpleDOMDocument.idl \
           ISimpleDOMText.idl
 

--- a/accessible/src/base/ARIAMap.cpp
+++ b/accessible/src/base/ARIAMap.cpp
@@ -614,17 +614,17 @@ static nsRoleMapEntry sWAIRoleMaps[] =
     &nsGkAtoms::treegrid,
     roles::TREE_TABLE,
     kUseMapRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
     eSelect | eTable,
     kNoReqStates,
-    eARIAReadonly,
+    eARIAReadonlyOrEditable,
     eARIAMultiSelectable,
     eFocusableUntilDisabled
   },
   { // treeitem
     &nsGkAtoms::treeitem,
     roles::OUTLINEITEM,
     kUseMapRole,
     eNoValue,

--- a/accessible/src/base/ARIAStateMap.cpp
+++ b/accessible/src/base/ARIAStateMap.cpp
@@ -361,34 +361,29 @@ MapEnumType(dom::Element* aElement, uint
 
   *aState |= aData.mDefaultState;
 }
 
 static void
 MapTokenType(dom::Element* aElement, uint64_t* aState,
              const TokenTypeData& aData)
 {
-  if (aElement->HasAttr(kNameSpaceID_None, aData.mAttrName)) {
+  if (nsAccUtils::HasDefinedARIAToken(aElement, aData.mAttrName)) {
     if ((aData.mType & eMixedType) &&
         aElement->AttrValueIs(kNameSpaceID_None, aData.mAttrName,
                               nsGkAtoms::mixed, eCaseMatters)) {
       *aState |= aData.mPermanentState | states::MIXED;
       return;
     }
 
     if (aElement->AttrValueIs(kNameSpaceID_None, aData.mAttrName,
                               nsGkAtoms::_false, eCaseMatters)) {
       *aState |= aData.mPermanentState | aData.mFalseState;
       return;
     }
 
-    if (!aElement->AttrValueIs(kNameSpaceID_None, aData.mAttrName,
-                               nsGkAtoms::_undefined, eCaseMatters) &&
-        !aElement->AttrValueIs(kNameSpaceID_None, aData.mAttrName,
-                               nsGkAtoms::_empty, eCaseMatters)) {
-      *aState |= aData.mPermanentState | aData.mTrueState;
-    }
+    *aState |= aData.mPermanentState | aData.mTrueState;
     return;
   }
 
   if (aData.mType & eDefinedIfAbsent)
     *aState |= aData.mPermanentState | aData.mFalseState;
 }

--- a/accessible/src/base/ARIAStateMap.h
+++ b/accessible/src/base/ARIAStateMap.h
@@ -2,17 +2,17 @@
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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/. */
 
 #ifndef _mozilla_a11y_aria_ARIAStateMap_h_
 #define _mozilla_a11y_aria_ARIAStateMap_h_
 
-#include "mozilla/StandardInteger.h"
+#include <stdint.h>
 
 namespace mozilla {
 
 namespace dom {
 class Element;
 }
 
 namespace a11y {

--- a/accessible/src/base/EventQueue.cpp
+++ b/accessible/src/base/EventQueue.cpp
@@ -298,17 +298,17 @@ EventQueue::CoalesceSelChangeEvents(AccS
       aTailEvent->mPackedEvent = aThisEvent;
       return;
     }
 
     if (aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd &&
         aTailEvent->mSelChangeType == AccSelChangeEvent::eSelectionRemove) {
       aTailEvent->mEventRule = AccEvent::eDoNotEmit;
       aThisEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION;
-      aThisEvent->mPackedEvent = aThisEvent;
+      aThisEvent->mPackedEvent = aTailEvent;
       return;
     }
   }
 
   // Unpack the packed selection change event because we've got one
   // more selection add/remove.
   if (aThisEvent->mEventType == nsIAccessibleEvent::EVENT_SELECTION) {
     if (aThisEvent->mPackedEvent) {
@@ -467,16 +467,39 @@ EventQueue::ProcessEventQueue()
           hyperText->GetSelectionCount(&selectionCount);
           if (selectionCount)
             nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED,
                                     hyperText);
         }
         continue;
       }
 
+      // Fire selected state change events in support to selection events.
+      if (event->mEventType == nsIAccessibleEvent::EVENT_SELECTION_ADD) {
+        nsEventShell::FireEvent(event->mAccessible, states::SELECTED,
+                                true, event->mIsFromUserInput);
+
+      } else if (event->mEventType == nsIAccessibleEvent::EVENT_SELECTION_REMOVE) {
+        nsEventShell::FireEvent(event->mAccessible, states::SELECTED,
+                                false, event->mIsFromUserInput);
+
+      } else if (event->mEventType == nsIAccessibleEvent::EVENT_SELECTION) {
+        AccSelChangeEvent* selChangeEvent = downcast_accEvent(event);
+        nsEventShell::FireEvent(event->mAccessible, states::SELECTED,
+                                (selChangeEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd),
+                                event->mIsFromUserInput);
+
+        if (selChangeEvent->mPackedEvent) {
+          nsEventShell::FireEvent(selChangeEvent->mPackedEvent->mAccessible,
+                                  states::SELECTED,
+                                  (selChangeEvent->mPackedEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd),
+                                  selChangeEvent->mPackedEvent->mIsFromUserInput);
+        }
+      }
+
       nsEventShell::FireEvent(event);
 
       // Fire text change events.
       AccMutationEvent* mutationEvent = downcast_accEvent(event);
       if (mutationEvent) {
         if (mutationEvent->mTextChangeEvent)
           nsEventShell::FireEvent(mutationEvent->mTextChangeEvent);
       }

--- a/accessible/src/base/Filters.h
+++ b/accessible/src/base/Filters.h
@@ -1,16 +1,16 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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/. */
 
 #ifndef mozilla_a11y_Filters_h__
 #define mozilla_a11y_Filters_h__
 
-#include "mozilla/StandardInteger.h"
+#include <stdint.h>
 
 /**
  * Predefined filters used for nsAccIterator and nsAccCollector.
  */
 namespace mozilla {
 namespace a11y {
 
 class Accessible;

--- a/accessible/src/base/NotificationController.cpp
+++ b/accessible/src/base/NotificationController.cpp
@@ -43,16 +43,18 @@ NotificationController::~NotificationCon
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NotificationCollector: AddRef/Release and cycle collection
 
 NS_IMPL_CYCLE_COLLECTING_NATIVE_ADDREF(NotificationController)
 NS_IMPL_CYCLE_COLLECTING_NATIVE_RELEASE(NotificationController)
 
+NS_IMPL_CYCLE_COLLECTION_CLASS(NotificationController)
+
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(NotificationController)
   if (tmp->mDocument)
     tmp->Shutdown();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(NotificationController)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHangingChildDocuments)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContentInsertions)

--- a/accessible/src/base/RoleAsserts.cpp
+++ b/accessible/src/base/RoleAsserts.cpp
@@ -7,13 +7,13 @@
 #include "nsIAccessibleRole.h"
 #include "Role.h"
 
 #include "mozilla/Assertions.h"
 
 using namespace mozilla::a11y;
 
 #define ROLE(geckoRole, stringRole, atkRole, macRole, msaaRole, ia2Role, nameRule) \
-  MOZ_STATIC_ASSERT(static_cast<uint32_t>(roles::geckoRole) \
-                    == static_cast<uint32_t>(nsIAccessibleRole::ROLE_ ## geckoRole), \
-                    "internal and xpcom roles differ!");
+  static_assert(static_cast<uint32_t>(roles::geckoRole) \
+                == static_cast<uint32_t>(nsIAccessibleRole::ROLE_ ## geckoRole), \
+                "internal and xpcom roles differ!");
 #include "RoleMap.h"
 #undef ROLE

--- a/accessible/src/base/States.h
+++ b/accessible/src/base/States.h
@@ -2,17 +2,17 @@
 /* vim: set expandtab shiftwidth=2 tabstop=2: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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/. */
 
 #ifndef _states_h_
 #define _states_h_
 
-#include "mozilla/StandardInteger.h"
+#include <stdint.h>
 
 namespace mozilla {
 namespace a11y {
 namespace states {
 
   /**
    * The object is disabled, opposite to enabled and sensitive.
    */

--- a/accessible/src/base/nsCoreUtils.cpp
+++ b/accessible/src/base/nsCoreUtils.cpp
@@ -36,16 +36,18 @@
 
 #include "nsComponentManagerUtils.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "mozilla/dom/Element.h"
 
 #include "nsITreeBoxObject.h"
 #include "nsITreeColumns.h"
 
+using namespace mozilla;
+
 ////////////////////////////////////////////////////////////////////////////////
 // nsCoreUtils
 ////////////////////////////////////////////////////////////////////////////////
 
 bool
 nsCoreUtils::HasClickListener(nsIContent *aContent)
 {
   NS_ENSURE_TRUE(aContent, false);
@@ -125,17 +127,17 @@ nsCoreUtils::DispatchClickEvent(nsITreeB
 void
 nsCoreUtils::DispatchMouseEvent(uint32_t aEventType, int32_t aX, int32_t aY,
                                 nsIContent *aContent, nsIFrame *aFrame,
                                 nsIPresShell *aPresShell, nsIWidget *aRootWidget)
 {
   nsMouseEvent event(true, aEventType, aRootWidget,
                      nsMouseEvent::eReal, nsMouseEvent::eNormal);
 
-  event.refPoint = nsIntPoint(aX, aY);
+  event.refPoint = LayoutDeviceIntPoint(aX, aY);
 
   event.clickCount = 1;
   event.button = nsMouseEvent::eLeftButton;
   event.time = PR_IntervalNow();
   event.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN;
 
   nsEventStatus status = nsEventStatus_eIgnore;
   aPresShell->HandleEventWithTarget(&event, aFrame, aContent, &status);

--- a/accessible/src/base/nsEventShell.h
+++ b/accessible/src/base/nsEventShell.h
@@ -31,16 +31,30 @@ public:
    * @param  aEventType   [in] the event type
    * @param  aAccessible  [in] the event target
    */
   static void FireEvent(uint32_t aEventType,
                         mozilla::a11y::Accessible* aAccessible,
                         mozilla::a11y::EIsFromUserInput aIsFromUserInput = mozilla::a11y::eAutoDetect);
 
   /**
+   * Fire state change event.
+   */
+  static void FireEvent(mozilla::a11y::Accessible* aTarget, uint64_t aState,
+                        bool aIsEnabled, bool aIsFromUserInput)
+  {
+    nsRefPtr<mozilla::a11y::AccStateChangeEvent> stateChangeEvent =
+      new mozilla::a11y::AccStateChangeEvent(aTarget, aState, aIsEnabled,
+                                             (aIsFromUserInput ?
+                                               mozilla::a11y::eFromUserInput :
+                                               mozilla::a11y::eNoUserInput));
+    FireEvent(stateChangeEvent);
+  }
+
+  /**
    * Append 'event-from-input' object attribute if the accessible event has
    * been fired just now for the given node.
    *
    * @param  aNode        [in] the DOM node
    * @param  aAttributes  [in, out] the attributes
    */
   static void GetEventAttributes(nsINode *aNode,
                                  nsIPersistentProperties *aAttributes);

--- a/accessible/src/generic/Accessible.cpp
+++ b/accessible/src/generic/Accessible.cpp
@@ -835,17 +835,17 @@ Accessible::ChildAtPoint(int32_t aX, int
   nsIWidget* rootWidget = rootFrame->GetView()->GetNearestWidget(nullptr);
   NS_ENSURE_TRUE(rootWidget, nullptr);
 
   nsIntRect rootRect;
   rootWidget->GetScreenBounds(rootRect);
 
   nsMouseEvent dummyEvent(true, NS_MOUSE_MOVE, rootWidget,
                           nsMouseEvent::eSynthesized);
-  dummyEvent.refPoint = nsIntPoint(aX - rootRect.x, aY - rootRect.y);
+  dummyEvent.refPoint = LayoutDeviceIntPoint(aX - rootRect.x, aY - rootRect.y);
 
   nsIFrame* popupFrame = nsLayoutUtils::
     GetPopupFrameForEventCoordinates(accDocument->PresContext()->GetRootPresContext(),
                                      &dummyEvent);
   if (popupFrame) {
     // If 'this' accessible is not inside the popup then ignore the popup when
     // searching an accessible at point.
     DocAccessible* popupDoc =
@@ -3348,24 +3348,24 @@ Accessible::GetLevelInternal()
   }
 
   return level;
 }
 
 void
 Accessible::StaticAsserts() const
 {
-  MOZ_STATIC_ASSERT(eLastChildrenFlag <= (2 << kChildrenFlagsBits) - 1,
-                    "Accessible::mChildrenFlags was oversized by eLastChildrenFlag!");
-  MOZ_STATIC_ASSERT(eLastStateFlag <= (2 << kStateFlagsBits) - 1,
-                    "Accessible::mStateFlags was oversized by eLastStateFlag!");
-  MOZ_STATIC_ASSERT(eLastAccType <= (2 << kTypeBits) - 1,
-                    "Accessible::mType was oversized by eLastAccType!");
-  MOZ_STATIC_ASSERT(eLastAccGenericType <= (2 << kGenericTypesBits) - 1,
-                    "Accessible::mGenericType was oversized by eLastAccGenericType!");
+  static_assert(eLastChildrenFlag <= (2 << kChildrenFlagsBits) - 1,
+                "Accessible::mChildrenFlags was oversized by eLastChildrenFlag!");
+  static_assert(eLastStateFlag <= (2 << kStateFlagsBits) - 1,
+                "Accessible::mStateFlags was oversized by eLastStateFlag!");
+  static_assert(eLastAccType <= (2 << kTypeBits) - 1,
+                "Accessible::mType was oversized by eLastAccType!");
+  static_assert(eLastAccGenericType <= (2 << kGenericTypesBits) - 1,
+                "Accessible::mGenericType was oversized by eLastAccGenericType!");
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // KeyBinding class
 
 void
 KeyBinding::ToPlatformFormat(nsAString& aValue) const

--- a/accessible/src/generic/Accessible.h
+++ b/accessible/src/generic/Accessible.h
@@ -718,16 +718,25 @@ public:
   bool HasOwnContent() const
     { return mContent && !(mStateFlags & eSharedNode); }
 
   /**
   * Return true if the accessible has a numeric value.
   */
   bool HasNumericValue() const;
 
+  /**
+   * Return true if the accessible state change is processed by handling proper
+   * DOM UI event, if otherwise then false. For example, HTMLCheckboxAccessible
+   * process nsIDocumentObserver::ContentStateChanged instead
+   * 'CheckboxStateChange' event.
+   */
+  bool NeedsDOMUIEvent() const
+    { return !(mStateFlags & eIgnoreDOMUIEvent); }
+
 protected:
 
   /**
    * Return the accessible name provided by native markup. It doesn't take
    * into account ARIA markup used to specify the name.
    */
   virtual mozilla::a11y::ENameValueFlag NativeName(nsString& aName);
 
@@ -784,16 +793,17 @@ protected:
    * @note keep these flags in sync with ChildrenFlags
    */
   enum StateFlags {
     eIsDefunct = 1 << 0, // accessible is defunct
     eIsNotInDocument = 1 << 1, // accessible is not in document
     eSharedNode = 1 << 2, // accessible shares DOM node from another accessible
     eNotNodeMapEntry = 1 << 3, // accessible shouldn't be in document node map
     eHasNumericValue = 1 << 4, // accessible has a numeric value
+    eIgnoreDOMUIEvent = 1 << 5, // don't process DOM UI events for a11y events
 
     eLastStateFlag = eHasNumericValue
   };
 
 protected:
 
   //////////////////////////////////////////////////////////////////////////////
   // Miscellaneous helpers

--- a/accessible/src/generic/DocAccessible.cpp
+++ b/accessible/src/generic/DocAccessible.cpp
@@ -98,16 +98,18 @@ DocAccessible::~DocAccessible()
 {
   NS_ASSERTION(!mPresShell, "LastRelease was never called!?!");
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsISupports
 
+NS_IMPL_CYCLE_COLLECTION_CLASS(DocAccessible)
+
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(DocAccessible, Accessible)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNotificationController)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mVirtualCursor)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChildDocuments)
   tmp->mDependentIDsHash.EnumerateRead(CycleCollectorTraverseDepIDsEntry, &cb);
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAccessibleCache)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAnchorJumpElm)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
@@ -1151,17 +1153,23 @@ DocAccessible::ContentStateChanged(nsIDo
     Accessible* widget = accessible->ContainerWidget();
     if (widget && widget->IsSelect()) {
       AccSelChangeEvent::SelChangeType selChangeType =
         aContent->AsElement()->State().HasState(NS_EVENT_STATE_CHECKED) ?
           AccSelChangeEvent::eSelectionAdd : AccSelChangeEvent::eSelectionRemove;
       nsRefPtr<AccEvent> event =
         new AccSelChangeEvent(widget, accessible, selChangeType);
       FireDelayedEvent(event);
+      return;
     }
+
+    nsRefPtr<AccEvent> event =
+      new AccStateChangeEvent(accessible, states::CHECKED,
+                              aContent->AsElement()->State().HasState(NS_EVENT_STATE_CHECKED));
+    FireDelayedEvent(event);
   }
 
   if (aStateMask.HasState(NS_EVENT_STATE_INVALID)) {
     nsRefPtr<AccEvent> event =
       new AccStateChangeEvent(accessible, states::INVALID, true);
     FireDelayedEvent(event);
   }
 
@@ -1825,20 +1833,26 @@ DocAccessible::UpdateTree(Accessible* aC
 }
 
 uint32_t
 DocAccessible::UpdateTreeInternal(Accessible* aChild, bool aIsInsert,
                                   AccReorderEvent* aReorderEvent)
 {
   uint32_t updateFlags = eAccessible;
 
+  // If a focused node has been shown then it could mean its frame was recreated
+  // while the node stays focused and we need to fire focus event on
+  // the accessible we just created. If the queue contains a focus event for
+  // this node already then it will be suppressed by this one.
+  Accessible* focusedAcc = nullptr;
+
   nsINode* node = aChild->GetNode();
   if (aIsInsert) {
     // Create accessible tree for shown accessible.
-    CacheChildrenInSubtree(aChild);
+    CacheChildrenInSubtree(aChild, &focusedAcc);
 
   } else {
     // Fire menupopup end event before hide event if a menu goes away.
 
     // XXX: We don't look into children of hidden subtree to find hiding
     // menupopup (as we did prior bug 570275) because we don't do that when
     // menu is showing (and that's impossible until bug 606924 is fixed).
     // Nevertheless we should do this at least because layout coalesces
@@ -1865,57 +1879,59 @@ DocAccessible::UpdateTreeInternal(Access
       // Fire EVENT_MENUPOPUP_START if ARIA menu appears.
       FireDelayedEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_START, aChild);
 
     } else if (ariaRole == roles::ALERT) {
       // Fire EVENT_ALERT if ARIA alert appears.
       updateFlags = eAlertAccessible;
       FireDelayedEvent(nsIAccessibleEvent::EVENT_ALERT, aChild);
     }
-
-    // If focused node has been shown then it means its frame was recreated
-    // while it's focused. Fire focus event on new focused accessible. If
-    // the queue contains focus event for this node then it's suppressed by
-    // this one.
-    // XXX: do we really want to send focus to focused DOM node not taking into
-    // account active item?
-    if (FocusMgr()->IsFocused(aChild))
-      FocusMgr()->DispatchFocusEvent(this, aChild);
-
   } else {
     // Update the tree for content removal.
     // The accessible parent may differ from container accessible if
     // the parent doesn't have own DOM node like list accessible for HTML
     // selects.
     Accessible* parent = aChild->Parent();
     NS_ASSERTION(parent, "No accessible parent?!");
     if (parent)
       parent->RemoveChild(aChild);
 
     UncacheChildrenInSubtree(aChild);
   }
 
+  // XXX: do we really want to send focus to focused DOM node not taking into
+  // account active item?
+  if (focusedAcc)
+    FocusMgr()->DispatchFocusEvent(this, focusedAcc);
+
   return updateFlags;
 }
 
 void
-DocAccessible::CacheChildrenInSubtree(Accessible* aRoot)
+DocAccessible::CacheChildrenInSubtree(Accessible* aRoot,
+                                      Accessible** aFocusedAcc)
 {
+  // If the accessible is focused then report a focus event after all related
+  // mutation events.
+  if (aFocusedAcc && !*aFocusedAcc &&
+      FocusMgr()->HasDOMFocus(aRoot->GetContent()))
+    *aFocusedAcc = aRoot;
+
   aRoot->EnsureChildren();
 
   // Make sure we create accessible tree defined in DOM only, i.e. if accessible
   // provides specific tree (like XUL trees) then tree creation is handled by
   // this accessible.
   uint32_t count = aRoot->ContentChildCount();
   for (uint32_t idx = 0; idx < count; idx++) {
     Accessible* child = aRoot->ContentChildAt(idx);
     NS_ASSERTION(child, "Illicit tree change while tree is created!");
     // Don't cross document boundaries.
     if (child && child->IsContent())
-      CacheChildrenInSubtree(child);
+      CacheChildrenInSubtree(child, aFocusedAcc);
   }
 
   // Fire document load complete on ARIA documents.
   // XXX: we should delay an event if the ARIA document has aria-busy.
   if (aRoot->HasARIARole() && !aRoot->IsDoc()) {
     a11y::role role = aRoot->ARIARole();
     if (role == roles::DIALOG || role == roles::DOCUMENT)
       FireDelayedEvent(nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE, aRoot);

--- a/accessible/src/generic/DocAccessible.h
+++ b/accessible/src/generic/DocAccessible.h
@@ -444,18 +444,23 @@ protected:
     eAlertAccessible = 2
   };
 
   uint32_t UpdateTreeInternal(Accessible* aChild, bool aIsInsert,
                               AccReorderEvent* aReorderEvent);
 
   /**
    * Create accessible tree.
+   *
+   * @param aRoot       [in] a root of subtree to create
+   * @param aFocusedAcc [in, optional] a focused accessible under created
+   *                      subtree if any
    */
-  void CacheChildrenInSubtree(Accessible* aRoot);
+  void CacheChildrenInSubtree(Accessible* aRoot,
+                              Accessible** aFocusedAcc = nullptr);
 
   /**
    * Remove accessibles in subtree from node to accessible map.
    */
   void UncacheChildrenInSubtree(Accessible* aRoot);
 
   /**
    * Shutdown any cached accessible in the subtree.

--- a/accessible/src/generic/FormControlAccessible.h
+++ b/accessible/src/generic/FormControlAccessible.h
@@ -16,17 +16,19 @@ namespace a11y {
   */
 template<int Max>
 class ProgressMeterAccessible : public LeafAccessible
 {
 public:
   ProgressMeterAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     LeafAccessible(aContent, aDoc)
   {
-    mStateFlags |= eHasNumericValue;
+    // Ignore 'ValueChange' DOM event in lieu of @value attribute change
+    // notifications.
+    mStateFlags |= eHasNumericValue | eIgnoreDOMUIEvent;
     mType = eProgressType;
   }
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIACCESSIBLEVALUE
 
   // Accessible
   virtual void Value(nsString& aValue);

--- a/accessible/src/generic/RootAccessible.cpp
+++ b/accessible/src/generic/RootAccessible.cpp
@@ -305,47 +305,44 @@ RootAccessible::ProcessDOMEvent(nsIDOMEv
       HandleTreeInvalidatedEvent(aDOMEvent, treeAcc);
       return;
     }
   }
 #endif
 
   if (eventType.EqualsLiteral("RadioStateChange")) {
     uint64_t state = accessible->State();
-
-    // radiogroup in prefWindow is exposed as a list,
-    // and panebutton is exposed as XULListitem in A11y.
-    // XULListitemAccessible::GetStateInternal uses STATE_SELECTED in this case,
-    // so we need to check states::SELECTED also.
     bool isEnabled = (state & (states::CHECKED | states::SELECTED)) != 0;
 
-    nsRefPtr<AccEvent> accEvent =
-      new AccStateChangeEvent(accessible, states::CHECKED, isEnabled);
-    nsEventShell::FireEvent(accEvent);
+    if (accessible->NeedsDOMUIEvent()) {
+      nsRefPtr<AccEvent> accEvent =
+        new AccStateChangeEvent(accessible, states::CHECKED, isEnabled);
+      nsEventShell::FireEvent(accEvent);
+    }
 
     if (isEnabled) {
       FocusMgr()->ActiveItemChanged(accessible);
 #ifdef A11Y_LOG
       if (logging::IsEnabled(logging::eFocus))
         logging::ActiveItemChangeCausedBy("RadioStateChange", accessible);
 #endif
     }
 
     return;
   }
 
   if (eventType.EqualsLiteral("CheckboxStateChange")) {
-    uint64_t state = accessible->State();
-
-    bool isEnabled = !!(state & states::CHECKED);
+    if (accessible->NeedsDOMUIEvent()) {
+      uint64_t state = accessible->State();
+      bool isEnabled = !!(state & states::CHECKED);
 
-    nsRefPtr<AccEvent> accEvent =
-      new AccStateChangeEvent(accessible, states::CHECKED, isEnabled);
-
-    nsEventShell::FireEvent(accEvent);
+      nsRefPtr<AccEvent> accEvent =
+        new AccStateChangeEvent(accessible, states::CHECKED, isEnabled);
+      nsEventShell::FireEvent(accEvent);
+    }
     return;
   }
 
   Accessible* treeItemAcc = nullptr;
 #ifdef MOZ_XUL
   // If it's a tree element, need the currently selected item.
   if (treeAcc) {
     treeItemAcc = accessible->CurrentItem();
@@ -450,24 +447,20 @@ RootAccessible::ProcessDOMEvent(nsIDOMEv
                             accessible, eFromUserInput);
 
     FocusMgr()->ActiveItemChanged(nullptr);
 #ifdef A11Y_LOG
     if (logging::IsEnabled(logging::eFocus))
       logging::ActiveItemChangeCausedBy("DOMMenuBarInactive", accessible);
 #endif
   }
-  else if (eventType.EqualsLiteral("ValueChange")) {
-
-    //We don't process 'ValueChange' events for progress meters since we listen
-    //@value attribute change for them.
-    if (!accessible->IsProgress()) {
-      targetDocument->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE,
-                                       accessible);
-    }
+  else if (accessible->NeedsDOMUIEvent() &&
+           eventType.EqualsLiteral("ValueChange")) {
+     targetDocument->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE,
+                                      accessible);
   }
 #ifdef DEBUG_DRAGDROPSTART
   else if (eventType.EqualsLiteral("mouseover")) {
     nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_DRAGDROP_START,
                             accessible);
   }
 #endif
 }

--- a/accessible/src/generic/TableCellAccessible.h
+++ b/accessible/src/generic/TableCellAccessible.h
@@ -3,17 +3,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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/. */
 
 #ifndef mozilla_a11y_TableCellAccessible_h__
 #define mozilla_a11y_TableCellAccessible_h__
 
 #include "nsTArray.h"
-#include "mozilla/StandardInteger.h"
+#include <stdint.h>
 
 namespace mozilla {
 namespace a11y {
 
 class Accessible;
 class TableAccessible;
 
 /**

--- a/accessible/src/html/HTMLFormControlAccessible.cpp
+++ b/accessible/src/html/HTMLFormControlAccessible.cpp
@@ -34,22 +34,16 @@
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLCheckboxAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
-HTMLCheckboxAccessible::
-  HTMLCheckboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
-  LeafAccessible(aContent, aDoc)
-{
-}
-
 role
 HTMLCheckboxAccessible::NativeRole()
 {
   return roles::CHECKBUTTON;
 }
 
 uint8_t
 HTMLCheckboxAccessible::ActionCount()
@@ -114,22 +108,16 @@ HTMLCheckboxAccessible::IsWidget() const
   return true;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLRadioButtonAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
-HTMLRadioButtonAccessible::
-  HTMLRadioButtonAccessible(nsIContent* aContent, DocAccessible* aDoc) :
-  RadioButtonAccessible(aContent, aDoc)
-{
-}
-
 uint64_t
 HTMLRadioButtonAccessible::NativeState()
 {
   uint64_t state = AccessibleWrap::NativeState();
 
   state |= states::CHECKABLE;
 
   HTMLInputElement* input = HTMLInputElement::FromContent(mContent);

--- a/accessible/src/html/HTMLFormControlAccessible.h
+++ b/accessible/src/html/HTMLFormControlAccessible.h
@@ -21,17 +21,23 @@ typedef ProgressMeterAccessible<1> HTMLP
  * Accessible for HTML input@type="checkbox".
  */
 class HTMLCheckboxAccessible : public LeafAccessible
 {
 
 public:
   enum { eAction_Click = 0 };
 
-  HTMLCheckboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
+  HTMLCheckboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
+    LeafAccessible(aContent, aDoc)
+  {
+    // Ignore "CheckboxStateChange" DOM event in lieu of document observer
+    // state change notification.
+    mStateFlags |= eIgnoreDOMUIEvent;
+  }
 
   // nsIAccessible
   NS_IMETHOD GetActionName(uint8_t aIndex, nsAString& aName);
   NS_IMETHOD DoAction(uint8_t index);
 
   // Accessible
   virtual mozilla::a11y::role NativeRole();
   virtual uint64_t NativeState();
@@ -46,17 +52,23 @@ public:
 
 /**
  * Accessible for HTML input@type="radio" element.
  */
 class HTMLRadioButtonAccessible : public RadioButtonAccessible
 {
 
 public:
-  HTMLRadioButtonAccessible(nsIContent* aContent, DocAccessible* aDoc);
+  HTMLRadioButtonAccessible(nsIContent* aContent, DocAccessible* aDoc) :
+    RadioButtonAccessible(aContent, aDoc)
+  {
+    // Ignore "RadioStateChange" DOM event in lieu of document observer
+    // state change notification.
+    mStateFlags |= eIgnoreDOMUIEvent;
+  }
 
   // Accessible
   virtual uint64_t NativeState();
   virtual void GetPositionAndSizeInternal(int32_t *aPosInSet,
                                           int32_t *aSetSize);
 };
 
 

--- a/accessible/src/windows/msaa/AccessibleWrap.cpp
+++ b/accessible/src/windows/msaa/AccessibleWrap.cpp
@@ -1612,18 +1612,18 @@ AccessibleWrap::HandleAccEvent(AccEvent*
   // when running in metro mode. This confuses input focus tracking
   // in metro's UIA implementation.
   if (XRE_GetWindowsEnvironment() == WindowsEnvironmentType_Metro) {
     return NS_OK;
   }
 
   uint32_t eventType = aEvent->GetEventType();
 
-  MOZ_STATIC_ASSERT(sizeof(gWinEventMap)/sizeof(gWinEventMap[0]) == nsIAccessibleEvent::EVENT_LAST_ENTRY,
-                    "MSAA event map skewed");
+  static_assert(sizeof(gWinEventMap)/sizeof(gWinEventMap[0]) == nsIAccessibleEvent::EVENT_LAST_ENTRY,
+                "MSAA event map skewed");
 
   NS_ENSURE_TRUE(eventType > 0 && eventType < ArrayLength(gWinEventMap), NS_ERROR_FAILURE);
 
   uint32_t winEvent = gWinEventMap[eventType];
   if (!winEvent)
     return NS_OK;
 
   // Means we're not active.

--- a/accessible/src/windows/msaa/Compatibility.h
+++ b/accessible/src/windows/msaa/Compatibility.h
@@ -2,17 +2,17 @@
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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/. */
 
 #ifndef COMPATIBILITY_MANAGER_H
 #define COMPATIBILITY_MANAGER_H
 
-#include "mozilla/StandardInteger.h"
+#include <stdint.h>
 
 namespace mozilla {
 namespace a11y {
 
 /**
  * Used to get compatibility modes. Note, modes are computed at accessibility
  * start up time and aren't changed during lifetime.
  */

--- a/accessible/tests/mochitest/events.js
+++ b/accessible/tests/mochitest/events.js
@@ -503,69 +503,74 @@ function eventQueue(aEventType)
             ok(false,
                "Unique type " +
                eventQueue.getEventTypeAsString(checker) + " event was handled.");
           }
         }
       }
     }
 
-    var matchedChecker = null;
+    var hasMatchedCheckers = false;
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
 
       // Check if handled event matches expected sync event.
       var nextChecker = this.getNextExpectedEvent(eventSeq);
       if (nextChecker) {
         if (eventQueue.compareEvents(nextChecker, aEvent)) {
-          matchedChecker = nextChecker;
-          matchedChecker.wasCaught++;
-          break;
+          this.processMatchedChecker(aEvent, nextChecker, scnIdx, eventSeq.idx);
+          hasMatchedCheckers = true;
+          continue;
         }
       }
 
       // Check if handled event matches any expected async events.
       for (idx = 0; idx < eventSeq.length; idx++) {
         if (!eventSeq[idx].unexpected && eventSeq[idx].async) {
           if (eventQueue.compareEvents(eventSeq[idx], aEvent)) {
-            matchedChecker = eventSeq[idx];
-            matchedChecker.wasCaught++;
+            this.processMatchedChecker(aEvent, eventSeq[idx], scnIdx, idx);
+            hasMatchedCheckers = true;
             break;
           }
         }
       }
     }
 
-    // Call 'check' functions on invoker's side.
-    if (matchedChecker) {
-      if ("check" in matchedChecker)
-        matchedChecker.check(aEvent);
-
+    if (hasMatchedCheckers) {
       var invoker = this.getInvoker();
       if ("check" in invoker)
         invoker.check(aEvent);
     }
 
-    // Dump handled event.
-    eventQueue.logEvent(aEvent, matchedChecker, this.areExpectedEventsLeft(),
-                        this.mNextInvokerStatus);
-
     // If we don't have more events to wait then schedule next invoker.
-    if (!this.areExpectedEventsLeft() &&
+    if (this.hasMatchedScenario() &&
         (this.mNextInvokerStatus == kInvokerNotScheduled)) {
       this.processNextInvokerInTimeout();
       return;
     }
 
     // If we have scheduled a next invoker then cancel in case of match.
-    if ((this.mNextInvokerStatus == kInvokerPending) && matchedChecker)
+    if ((this.mNextInvokerStatus == kInvokerPending) && hasMatchedCheckers)
       this.mNextInvokerStatus = kInvokerCanceled;
   }
 
   // Helpers
+  this.processMatchedChecker =
+    function eventQueue_function(aEvent, aMatchedChecker, aScenarioIdx, aEventIdx)
+  {
+    aMatchedChecker.wasCaught++;
+
+    if ("check" in aMatchedChecker)
+      aMatchedChecker.check(aEvent);
+
+    eventQueue.logEvent(aEvent, aMatchedChecker, aScenarioIdx, aEventIdx,
+                        this.areExpectedEventsLeft(),
+                        this.mNextInvokerStatus);
+  }
+
   this.getNextExpectedEvent =
     function eventQueue_getNextExpectedEvent(aEventSeq)
   {
     if (!("idx" in aEventSeq))
       aEventSeq.idx = 0;
 
     while (aEventSeq.idx < aEventSeq.length &&
            (aEventSeq[aEventSeq.idx].unexpected ||
@@ -630,16 +635,26 @@ function eventQueue(aEventType)
           break;
       }
       if (idx == eventSeq.length)
         return true;
     }
 
     return false;
   }
+  
+  this.hasMatchedScenario =
+    function eventQueue_hasMatchedScenario()
+  {
+    for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
+      if (!this.areExpectedEventsLeft(this.mScenarios[scnIdx]))
+        return true;
+    }
+    return false;
+  }
 
   this.getInvoker = function eventQueue_getInvoker()
   {
     return this.mInvokers[this.mIndex];
   }
 
   this.getNextInvoker = function eventQueue_getNextInvoker()
   {
@@ -853,16 +868,17 @@ eventQueue.isSameEvent = function eventQ
   // target, thus we should filter text change and state change events since
   // they may occur on the same element because of complex changes.
   return this.compareEvents(aChecker, aEvent) &&
     !(aEvent instanceof nsIAccessibleTextChangeEvent) &&
     !(aEvent instanceof nsIAccessibleStateChangeEvent);
 }
 
 eventQueue.logEvent = function eventQueue_logEvent(aOrigEvent, aMatchedChecker,
+                                                   aScenarioIdx, aEventIdx,
                                                    aAreExpectedEventsLeft,
                                                    aInvokerStatus)
 {
   if (!gLogger.isEnabled()) // debug stuff
     return;
 
   // Dump DOM event information. Skip a11y event since it is dumped by
   // gA11yEventObserver.
@@ -892,17 +908,18 @@ eventQueue.logEvent = function eventQueu
   if (!aMatchedChecker)
     return;
 
   var msg = "EQ: ";
   var emphText = "matched ";
 
   var currType = eventQueue.getEventTypeAsString(aMatchedChecker);
   var currTargetDescr = eventQueue.getEventTargetDescr(aMatchedChecker);
-  var consoleMsg = "*****\nEQ matched: " + currType + "\n*****";
+  var consoleMsg = "*****\nScenario " + aScenarioIdx + 
+    ", event " + aEventIdx + " matched: " + currType + "\n*****";
   gLogger.logToConsole(consoleMsg);
 
   msg += " event, type: " + currType + ", target: " + currTargetDescr;
 
   gLogger.logToDOM(msg, true, emphText);
 }
 
 
@@ -1722,17 +1739,18 @@ function stateChangeChecker(aState, aIsE
     var unxpdExtraState = aIsEnabled ? 0 : (aIsExtraState ? aState : 0);
     testStates(event.accessible, state, extraState, unxpdState, unxpdExtraState);
   }
 
   this.match = function stateChangeChecker_match(aEvent)
   {
     if (aEvent instanceof nsIAccessibleStateChangeEvent) {
       var scEvent = aEvent.QueryInterface(nsIAccessibleStateChangeEvent);
-      return aEvent.accessible = this.target && scEvent.state == aState;
+      return (aEvent.accessible == getAccessible(this.target)) &&
+        (scEvent.state == aState);
     }
     return false;
   }
 }
 
 function asyncStateChangeChecker(aState, aIsExtraState, aIsEnabled,
                                  aTargetOrFunc, aTargetFuncArg)
 {
@@ -1767,16 +1785,69 @@ function expandedStateChecker(aIsEnabled
       "Wrong state of statechange event state");
 
     testStates(event.accessible,
                (aIsEnabled ? STATE_EXPANDED : STATE_COLLAPSED));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Event sequances (array of predefined checkers)
+
+/**
+ * Event seq for single selection change.
+ */
+function selChangeSeq(aUnselectedID, aSelectedID)
+{
+  if (!aUnselectedID) {
+    return [
+      new stateChangeChecker(STATE_SELECTED, false, true, aSelectedID),
+      new invokerChecker(EVENT_SELECTION, aSelectedID)
+    ];
+  }
+
+  // Return two possible scenarios: depending on widget type when selection is
+  // moved the the order of items that get selected and unselected may vary. 
+  return [
+    [
+      new stateChangeChecker(STATE_SELECTED, false, false, aUnselectedID),
+      new stateChangeChecker(STATE_SELECTED, false, true, aSelectedID),
+      new invokerChecker(EVENT_SELECTION, aSelectedID)
+    ],
+    [
+      new stateChangeChecker(STATE_SELECTED, false, true, aSelectedID),
+      new stateChangeChecker(STATE_SELECTED, false, false, aUnselectedID),
+      new invokerChecker(EVENT_SELECTION, aSelectedID)
+    ]
+  ];
+}
+
+/**
+ * Event seq for item removed form the selection.
+ */
+function selRemoveSeq(aUnselectedID)
+{
+  return [
+    new stateChangeChecker(STATE_SELECTED, false, false, aUnselectedID),
+    new invokerChecker(EVENT_SELECTION_REMOVE, aUnselectedID)
+  ];
+}
+
+/**
+ * Event seq for item added to the selection.
+ */
+function selAddSeq(aSelectedID)
+{
+  return [
+    new stateChangeChecker(STATE_SELECTED, false, true, aSelectedID),
+    new invokerChecker(EVENT_SELECTION_ADD, aSelectedID)
+  ];
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Private implementation details.
 ////////////////////////////////////////////////////////////////////////////////
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // General
 
 var gA11yEventListeners = {};
@@ -2038,23 +2109,30 @@ function sequenceItem(aProcessor, aEvent
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Event queue invokers
 
 /**
  * Invoker base class for prepare an action.
  */
-function synthAction(aNodeOrID, aCheckerOrEventSeq)
+function synthAction(aNodeOrID, aEventsObj)
 {
   this.DOMNode = getNode(aNodeOrID);
 
-  if (aCheckerOrEventSeq) {
-    if (aCheckerOrEventSeq instanceof Array) {
-      this.eventSeq = aCheckerOrEventSeq;
+  if (aEventsObj) {
+    var scenarios = null;
+    if (aEventsObj instanceof Array) {
+      if (aEventsObj[0] instanceof Array)
+        scenarios = aEventsObj; // scenarios
+      else
+        scenarios = [ aEventsObj ]; // event sequance
     } else {
-      this.eventSeq = [ aCheckerOrEventSeq ];
+      scenarios = [ [ aEventsObj ] ]; // a single checker object
     }
+
+    for (var i = 0; i < scenarios.length; i++)
+      defineScenario(this, scenarios[i]);
   }
 
   this.getID = function synthAction_getID()
     { return prettyName(aNodeOrID) + " action"; }
 }

--- a/accessible/tests/mochitest/events/test_selection.html
+++ b/accessible/tests/mochitest/events/test_selection.html
@@ -33,56 +33,61 @@
     function doTests()
     {
       gQueue = new eventQueue();
 
       // open combobox
       gQueue.push(new synthClick("combobox",
                                  new invokerChecker(EVENT_FOCUS, "cb1_item1")));
       gQueue.push(new synthDownKey("cb1_item1",
-                                   new invokerChecker(EVENT_SELECTION, "cb1_item2")));
+                                   selChangeSeq("cb1_item1", "cb1_item2")));
 
       // closed combobox
       gQueue.push(new synthEscapeKey("combobox",
                                      new invokerChecker(EVENT_FOCUS, "combobox")));
       gQueue.push(new synthDownKey("cb1_item2",
-                                   new invokerChecker(EVENT_SELECTION, "cb1_item3")));
+                                   selChangeSeq("cb1_item2", "cb1_item3")));
 
       // listbox
       gQueue.push(new synthClick("lb1_item1",
                                  new invokerChecker(EVENT_SELECTION, "lb1_item1")));
       gQueue.push(new synthDownKey("lb1_item1",
-                                   new invokerChecker(EVENT_SELECTION, "lb1_item2")));
+                                   selChangeSeq("lb1_item1", "lb1_item2")));
 
       // multiselectable listbox
       gQueue.push(new synthClick("lb2_item1",
-                                 new invokerChecker(EVENT_SELECTION, "lb2_item1")));
+                                 selChangeSeq(null, "lb2_item1")));
       gQueue.push(new synthDownKey("lb2_item1",
-                                   new invokerChecker(EVENT_SELECTION_ADD, "lb2_item2"),
+                                   selAddSeq("lb2_item2"),
                                    { shiftKey: true }));
       gQueue.push(new synthUpKey("lb2_item2",
-                                 new invokerChecker(EVENT_SELECTION_REMOVE, "lb2_item2"),
+                                 selRemoveSeq("lb2_item2"),
                                  { shiftKey: true }));
       gQueue.push(new synthKey("lb2_item1", " ", { ctrlKey: true },
-                               new invokerChecker(EVENT_SELECTION_REMOVE, "lb2_item1")));
+                               selRemoveSeq("lb2_item1")));
 
       gQueue.invoke(); // Will call SimpleTest.finish();
     }
 
     SimpleTest.waitForExplicitFinish();
     addA11yLoadEvent(doTests);
   </script>
 </head>
 
 <body>
 
   <a target="_blank"
      href="https://bugzilla.mozilla.org/show_bug.cgi?id=414302"
      title="Incorrect selection events in HTML, XUL and ARIA">
-    Mozilla Bug 414302
+    Bug 414302
+  </a>
+  <a target="_blank"
+     href="https://bugzilla.mozilla.org/show_bug.cgi?id=810268"
+     title="There's no way to know unselected item when selection in single selection was changed">
+    Bug 810268
   </a>
 
   <p id="display"></p>
   <div id="content" style="display: none"></div>
   <pre id="test">
   </pre>
 
   <select id="combobox">

--- a/accessible/tests/mochitest/events/test_selection_aria.html
+++ b/accessible/tests/mochitest/events/test_selection_aria.html
@@ -31,17 +31,17 @@
 
       this.eventSeq = [
         new invokerChecker(EVENT_SELECTION, aItemID)
       ];
 
       this.invoke = function selectItem_invoke() {
         var itemNode = this.selectNode.querySelector("*[aria-selected='true']");
         if (itemNode)
-          itemNode.removeAttribute("aria-selected", "true");
+          itemNode.removeAttribute("aria-selected");
 
         this.itemNode.setAttribute("aria-selected", "true");
       }
 
       this.getID = function selectItem_getID()
       {
         return "select item " + prettyName(aItemID);
       }

--- a/accessible/tests/mochitest/events/test_statechange.html
+++ b/accessible/tests/mochitest/events/test_statechange.html
@@ -67,16 +67,36 @@
         testStates(aNodeOrID, STATE_INVALID);
       };
 
       this.getID = function invalidInput_getID() {
         return prettyName(aNodeOrID) + " became invalid";
       };
     }
 
+    function changeCheckInput(aID, aIsChecked)
+    {
+      this.DOMNode = getNode(aID);
+
+      this.eventSeq = [
+        new stateChangeChecker(STATE_CHECKED, false, aIsChecked, this.DOMNode)
+      ];
+
+      this.invoke = function changeCheckInput_invoke()
+      {
+        this.DOMNode.checked = aIsChecked;
+      }
+
+      this.getID = function changeCheckInput_getID()
+      {
+        return "change checked state to '" + aIsChecked + "' for " +
+          prettyName(aID);
+      }
+    }
+
     function stateChangeOnFileInput(aID, aAttr, aValue,
                                     aState, aIsExtraState, aIsEnabled)
     {
       this.fileControlNode = getNode(aID);
       this.fileControl = getAccessible(this.fileControlNode);
       this.browseButton = this.fileControl.firstChild;
       // No state change events on the label.
 
@@ -149,16 +169,22 @@
 
       // Test delayed editable state change
       var doc = document.getElementById("iframe").contentDocument;
       gQueue.push(new makeEditableDoc(doc));
 
       // invalid state change
       gQueue.push(new invalidInput("email"));
 
+      // checked state change
+      gQueue.push(new changeCheckInput("checkbox", true));
+      gQueue.push(new changeCheckInput("checkbox", false));
+      gQueue.push(new changeCheckInput("radio", true));
+      gQueue.push(new changeCheckInput("radio", false));
+
       // file input inherited state changes
       gQueue.push(new stateChangeOnFileInput("file", "aria-busy", "true",
                                              STATE_BUSY, false, true));
       gQueue.push(new stateChangeOnFileInput("file", "aria-required", "true",
                                              STATE_REQUIRED, false, true));
       gQueue.push(new stateChangeOnFileInput("file", "aria-invalid", "true",
                                              STATE_INVALID, false, true));
 
@@ -175,39 +201,47 @@
   </script>
 </head>
 
 <body>
 
   <a target="_blank"
      href="https://bugzilla.mozilla.org/show_bug.cgi?id=564471"
      title="Make state change events async">
-    Mozilla Bug 564471
-  </a><br>
+    Bug 564471
+  </a>
   <a target="_blank"
      href="https://bugzilla.mozilla.org/show_bug.cgi?id=555728"
      title="Fire a11y event based on HTML5 constraint validation">
-    Mozilla Bug 555728
+    Bug 555728
   </a>
   <a target="_blank"
      href="https://bugzilla.mozilla.org/show_bug.cgi?id=699017"
      title="File input control should be propogate states to descendants">
-    Mozilla Bug 699017
+    Bug 699017
+  </a>
+  <a target="_blank"
+     href="https://bugzilla.mozilla.org/show_bug.cgi?id=788389"
+     title="Fire statechange event whenever checked state is changed not depending on focused state">
+    Bug 788389
   </a>
 
   <p id="display"></p>
   <div id="content" style="display: none"></div>
   <pre id="test">
   </pre>
 
   <div id="testContainer">
     <iframe id="iframe"></iframe>
   </div>
 
   <input id="email" type='email'>
 
+  <input id="checkbox" type="checkbox">
+  <input id="radio" type="radio">
+
   <input id="file" type="file">
 
   <div id="div"></div>
 
   <div id="eventdump"></div>
 </body>
 </html>

--- a/accessible/tests/mochitest/states/test_aria.html
+++ b/accessible/tests/mochitest/states/test_aria.html
@@ -136,16 +136,47 @@
                  STATE_READONLY, 0);
       testStates("aria_grid_readonly_rowheader_inherited", STATE_READONLY, 0,
                  0, EXT_STATE_EDITABLE);
       testStates("aria_grid_readonly_cell_editable", 0, EXT_STATE_EDITABLE,
                  STATE_READONLY, 0);
       testStates("aria_grid_readonly_cell_inherited", STATE_READONLY, 0,
                  0, EXT_STATE_EDITABLE);
 
+      // readonly/editable on treegrid and gridcell
+      testStates("aria_treegrid_default", 0, EXT_STATE_EDITABLE,
+                 STATE_READONLY, 0);
+      testStates("aria_treegrid_default_colheader_readonly", STATE_READONLY, 0,
+                 0, EXT_STATE_EDITABLE);
+      testStates("aria_treegrid_default_colheader_inherited", 0, EXT_STATE_EDITABLE,
+                 STATE_READONLY, 0);
+      testStates("aria_treegrid_default_rowheader_readonly", STATE_READONLY, 0,
+                 0, EXT_STATE_EDITABLE);
+      testStates("aria_treegrid_default_rowheader_inherited", 0, EXT_STATE_EDITABLE,
+                 STATE_READONLY, 0);
+      testStates("aria_treegrid_default_cell_readonly", STATE_READONLY, 0,
+                 0, EXT_STATE_EDITABLE);
+      testStates("aria_treegrid_default_cell_inherited", 0, EXT_STATE_EDITABLE,
+                 STATE_READONLY, 0);
+
+      testStates("aria_treegrid_readonly", STATE_READONLY, 0,
+                 0, EXT_STATE_EDITABLE);
+      testStates("aria_treegrid_readonly_colheader_editable", 0, EXT_STATE_EDITABLE,
+                 STATE_READONLY, 0);
+      testStates("aria_treegrid_readonly_colheader_inherited", STATE_READONLY, 0,
+                 0, EXT_STATE_EDITABLE);
+      testStates("aria_treegrid_readonly_rowheader_editable", 0, EXT_STATE_EDITABLE,
+                 STATE_READONLY, 0);
+      testStates("aria_treegrid_readonly_rowheader_inherited", STATE_READONLY, 0,
+                 0, EXT_STATE_EDITABLE);
+      testStates("aria_treegrid_readonly_cell_editable", 0, EXT_STATE_EDITABLE,
+                 STATE_READONLY, 0);
+      testStates("aria_treegrid_readonly_cell_inherited", STATE_READONLY, 0,
+                 0, EXT_STATE_EDITABLE);
+
       // aria-selectable
       testStates("aria_selectable_listitem", STATE_SELECTABLE | STATE_SELECTED);
 
       // active state caused by aria-activedescendant
       testStates("as_item1", 0, EXT_STATE_ACTIVE);
       testStates("as_item2", 0, 0, 0, EXT_STATE_ACTIVE);
 
       // universal ARIA properties inherited from file input control
@@ -268,16 +299,21 @@
     Mozilla Bug 740851
   </a>
   <a target="_blank"
      href="https://bugzilla.mozilla.org/show_bug.cgi?id=762876"
      title="fix default horizontal / vertical state of role=scrollbar and ensure only one of horizontal / vertical states is exposed">
     Mozilla Bug 762876
   </a>
   <a target="_blank"
+     href="https://bugzilla.mozilla.org/show_bug.cgi?id=892091"
+     title="ARIA treegrid should be editable by default">
+    Bug 892091
+  </a>
+  <a target="_blank"
      href="https://bugzilla.mozilla.org/show_bug.cgi?id=835121"
      title="ARIA grid should be editable by default">
     Mozilla Bug 835121
   </a>
 
   <p id="display"></p>
   <div id="content" style="display: none"></div>
   <pre id="test">
@@ -354,16 +390,58 @@
     <div role="row">
       <div id="aria_grid_readonly_cell_editable"
            role="gridcell" aria-readonly="false">gridcell1</div>
       <div id="aria_grid_readonly_cell_inherited"
            role="gridcell">gridcell2</div>
     </div>
   </div>
 
+  <div id="aria_treegrid_default" role="grid">
+    <div role="row">
+      <div id="aria_treegrid_default_colheader_readonly"
+           role="columnheader" aria-readonly="true">colheader1</div>
+      <div id="aria_treegrid_default_colheader_inherited"
+           role="columnheader">colheader2</div>
+    </div>
+    <div role="row">
+      <div id="aria_treegrid_default_rowheader_readonly"
+           role="rowheader" aria-readonly="true">rowheader1</div>
+      <div id="aria_treegrid_default_rowheader_inherited"
+           role="rowheader">rowheader2</div>
+    </div>
+    <div role="row">
+      <div id="aria_treegrid_default_cell_readonly"
+           role="gridcell" aria-readonly="true">gridcell1</div>
+      <div id="aria_treegrid_default_cell_inherited"
+           role="gridcell">gridcell2</div>
+    </div>
+  </div>
+
+  <div id="aria_treegrid_readonly" role="grid" aria-readonly="true">
+    <div role="row">
+      <div id="aria_treegrid_readonly_colheader_editable"
+           role="columnheader" aria-readonly="false">colheader1</div>
+      <div id="aria_treegrid_readonly_colheader_inherited"
+           role="columnheader">colheader2</div>
+    </div>
+    <div role="row">
+      <div id="aria_treegrid_readonly_rowheader_editable"
+           role="rowheader" aria-readonly="false">rowheader1</div>
+      <div id="aria_treegrid_readonly_rowheader_inherited"
+           role="rowheader">rowheader2</div>
+    </div>
+    <div role="row">
+      <div id="aria_treegrid_readonly_cell_editable"
+           role="gridcell" aria-readonly="false">gridcell1</div>
+      <div id="aria_treegrid_readonly_cell_inherited"
+           role="gridcell">gridcell2</div>
+    </div>
+  </div>
+
   <div role="listbox">
     <div id="aria_selectable_listitem" role="option" aria-selected="true">Item1</div>
   </div>
 
   <!-- Test that aria-disabled state gets propagated to all descendants -->
   <div id="group" role="group" aria-disabled="true">
     <button>hi</button>
     <div tabindex="0" role="listbox" aria-activedescendant="item1">

--- a/accessible/tests/mochitest/test_aria_token_attrs.html
+++ b/accessible/tests/mochitest/test_aria_token_attrs.html
@@ -32,18 +32,18 @@ https://bugzilla.mozilla.org/show_bug.cg
       testStates("button_pressed_false", STATE_CHECKABLE, 0, STATE_PRESSED);
       testStates("button_pressed_empty", 0, 0, STATE_PRESSED | STATE_CHECKABLE);
       testStates("button_pressed_undefined", 0, 0, STATE_PRESSED | STATE_CHECKABLE);
       testStates("button_pressed_absent", 0, 0, STATE_PRESSED | STATE_CHECKABLE);
 
       // test (checkbox) checkable and checked states
       testStates("checkbox_checked_true", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("checkbox_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
-      testStates("checkbox_checked_empty", 0 , 0, STATE_CHECKABLE | STATE_CHECKED);
-      testStates("checkbox_checked_undefined", 0, 0, STATE_CHECKABLE | STATE_CHECKED);
+      testStates("checkbox_checked_empty", STATE_CHECKABLE , 0, STATE_CHECKED);
+      testStates("checkbox_checked_undefined", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("checkbox_checked_absent", STATE_CHECKABLE, 0, STATE_CHECKED);
 
       // test native checkbox checked state and aria-checked state (if conflict, native wins)
       testStates("native_checkbox_nativechecked_ariatrue", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("native_checkbox_nativechecked_ariafalse", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("native_checkbox_nativechecked_ariaempty", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("native_checkbox_nativechecked_ariaundefined", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("native_checkbox_nativechecked_ariaabsent", (STATE_CHECKABLE | STATE_CHECKED));
@@ -101,39 +101,39 @@ https://bugzilla.mozilla.org/show_bug.cg
       testStates("menuitem_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("menuitem_checked_empty", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
       testStates("menuitem_checked_undefined", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
       testStates("menuitem_checked_absent", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
 
       // test (menuitemradio) checkable and checked states
       testStates("menuitemradio_checked_true", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("menuitemradio_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
-      testStates("menuitemradio_checked_empty", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
-      testStates("menuitemradio_checked_undefined", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
+      testStates("menuitemradio_checked_empty", STATE_CHECKABLE, 0, STATE_CHECKED);
+      testStates("menuitemradio_checked_undefined", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("menuitemradio_checked_absent", STATE_CHECKABLE, 0, STATE_CHECKED);
 
       // test (radio) checkable and checked states
       testStates("radio_checked_true", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("radio_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
-      testStates("radio_checked_empty", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
-      testStates("radio_checked_undefined", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
+      testStates("radio_checked_empty", STATE_CHECKABLE, 0, STATE_CHECKED);
+      testStates("radio_checked_undefined", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("radio_checked_absent", STATE_CHECKABLE, 0, STATE_CHECKED);
 
       // test (textbox) multiline states
       testStates("textbox_multiline_true", 0, EXT_STATE_MULTI_LINE);
       testStates("textbox_multiline_false", 0, EXT_STATE_SINGLE_LINE);
-      testStates("textbox_multiline_empty", 0, 0, 0, EXT_STATE_SINGLE_LINE | EXT_STATE_MULTI_LINE);
-      testStates("textbox_multiline_undefined", 0, 0, 0, EXT_STATE_SINGLE_LINE | EXT_STATE_MULTI_LINE);
+      testStates("textbox_multiline_empty", 0, EXT_STATE_SINGLE_LINE);
+      testStates("textbox_multiline_undefined", 0, EXT_STATE_SINGLE_LINE);
       testStates("textbox_multiline_absent", 0, EXT_STATE_SINGLE_LINE);
 
       // test (textbox) readonly states
       testStates("textbox_readonly_true", STATE_READONLY);
       testStates("textbox_readonly_false", 0, EXT_STATE_EDITABLE, STATE_READONLY);
-      testStates("textbox_readonly_empty", 0, 0, STATE_READONLY, EXT_STATE_EDITABLE);
-      testStates("textbox_readonly_undefined", 0, 0, STATE_READONLY, EXT_STATE_EDITABLE);
+      testStates("textbox_readonly_empty", 0, EXT_STATE_EDITABLE, STATE_READONLY);
+      testStates("textbox_readonly_undefined", 0, EXT_STATE_EDITABLE, STATE_READONLY);
       testStates("textbox_readonly_absent", 0, EXT_STATE_EDITABLE, STATE_READONLY);
 
       // test native textbox readonly state and aria-readonly state (if conflict, native wins)
       testStates("native_textbox_nativereadonly_ariatrue", STATE_READONLY);
       testStates("native_textbox_nativereadonly_ariafalse", STATE_READONLY);
       testStates("native_textbox_nativereadonly_ariaempty", STATE_READONLY);
       testStates("native_textbox_nativereadonly_ariaundefined", STATE_READONLY);
       testStates("native_textbox_nativereadonly_ariaabsent", STATE_READONLY);
@@ -142,18 +142,18 @@ https://bugzilla.mozilla.org/show_bug.cg
       testStates("native_textbox_nativeeditable_ariafalse", 0, 0, STATE_READONLY);
       testStates("native_textbox_nativeeditable_ariaempty", 0, 0, STATE_READONLY);
       testStates("native_textbox_nativeeditable_ariaundefined", 0, 0, STATE_READONLY);
       testStates("native_textbox_nativeeditable_ariaabsent", 0, 0, STATE_READONLY);
 
       // test (treeitem) selectable and selected states
       testStates("treeitem_selected_true", (STATE_SELECTABLE | STATE_SELECTED));
       testStates("treeitem_selected_false", STATE_SELECTABLE, 0, STATE_SELECTED);
-      testStates("treeitem_selected_empty", 0, 0, (STATE_SELECTABLE | STATE_SELECTED));
-      testStates("treeitem_selected_undefined", 0, 0, (STATE_SELECTABLE | STATE_SELECTED));
+      testStates("treeitem_selected_empty", STATE_SELECTABLE, 0, STATE_SELECTED);
+      testStates("treeitem_selected_undefined", STATE_SELECTABLE, 0, STATE_SELECTED);
       testStates("treeitem_selected_absent", STATE_SELECTABLE, 0, STATE_SELECTED);
 
       // test (treeitem) haspopup states
       testStates("treeitem_haspopup_true", STATE_HASPOPUP);
       testStates("treeitem_haspopup_false", 0, 0, STATE_HASPOPUP);
       testStates("treeitem_haspopup_empty", 0, 0, STATE_HASPOPUP);
       testStates("treeitem_haspopup_undefined", 0, 0, STATE_HASPOPUP);
       testStates("treeitem_haspopup_absent", 0, 0, STATE_HASPOPUP);

--- a/addon-sdk/source/app-extension/bootstrap.js
+++ b/addon-sdk/source/app-extension/bootstrap.js
@@ -215,18 +215,16 @@ function startup(data, reasonCode) {
       loadReason: reason,
 
       prefixURI: prefixURI,
       // Add-on URI.
       rootURI: rootURI,
       // options used by system module.
       // File to write 'OK' or 'FAIL' (exit code emulation).
       resultFile: options.resultFile,
-      // File to write stdout.
-      logFile: options.logFile,
       // Arguments passed as --static-args
       staticArgs: options.staticArgs,
 
       // Arguments related to test runner.
       modules: {
         '@test/options': {
           allTestModules: options.allTestModules,
           iterations: options.iterations,

--- a/addon-sdk/source/app-extension/install.rdf
+++ b/addon-sdk/source/app-extension/install.rdf
@@ -12,18 +12,18 @@
     <em:type>2</em:type>
     <em:bootstrap>true</em:bootstrap>
     <em:unpack>false</em:unpack>
 
     <!-- Firefox -->
     <em:targetApplication>
       <Description>
         <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
-        <em:minVersion>19.0</em:minVersion>
-        <em:maxVersion>22.0a1</em:maxVersion>
+        <em:minVersion>21.0</em:minVersion>
+        <em:maxVersion>25.0a1</em:maxVersion>
       </Description>
     </em:targetApplication>
 
     <!-- Front End MetaData -->
     <em:name>Test App</em:name>
     <em:description>Harness for tests.</em:description>
     <em:creator>Mozilla Corporation</em:creator>
     <em:homepageURL></em:homepageURL>

--- a/addon-sdk/source/doc/dev-guide-source/cfx-tool.md
+++ b/addon-sdk/source/doc/dev-guide-source/cfx-tool.md
@@ -635,25 +635,24 @@ of `updateURL`.
 
 Note that as the [add-on documentation](https://developer.mozilla.org/en/extension_versioning,_update_and_compatibility#Securing_Updates)
 explains, you should make sure the update procedure for your add-on is secure,
 and this usually involves using HTTPS for the links.
 
 So if we run the following command:
 
 <pre>
-  cfx xpi --update-link https://example.com/addon/latest
-          --update-url https://example.com/addon/update_rdf
+  cfx xpi --update-link https://example.com/addon/latest/pluginName.xpi --update-url https://example.com/addon/update_rdf/pluginName.update.rdf
 </pre>
 
 `cfx` will create two files:
 
 * an XPI file which embeds
-`https://example.com/addon/update_rdf` as the value of `updateURL`
-* an RDF file which embeds `https://example.com/addon/latest` as the value of
+`https://example.com/addon/update_rdf/pluginName.update.rdf` as the value of `updateURL`
+* an RDF file which embeds `https://example.com/addon/latest/pluginName.xpi` as the value of
 `updateLink`.
 
 ### Supported Options ###
 
 As with `cfx run` you can point `cfx` at a different `package.json` file using
 the `--pkgdir` option. You can also embed arguments in the XPI using the
 `--static-args` option: if you do this the arguments will be passed to your
 add-on whenever it is run.

--- a/addon-sdk/source/doc/module-source/sdk/self.md
+++ b/addon-sdk/source/doc/module-source/sdk/self.md
@@ -8,16 +8,23 @@ The `self` module provides access to dat
 as a whole. It also provides access to the
 [Program ID](dev-guide/guides/program-id.html), a value which is
 unique for each add-on.
 
 Note that the `self` module is completely different from the global `self`
 object accessible to content scripts, which is used by a content script to
 [communicate with the add-on code](dev-guide/guides/content-scripts/using-port.html).
 
+<api name="uri">
+@property {string}
+This property represents an add-on associated unique URI string.
+This URI can be used for APIs which require a valid URI string, such as the
+[passwords](modules/sdk/passwords.html) module.
+</api>
+
 <api name="id">
 @property {string}
 This property is a printable string that is unique for each add-on. It comes
 from the `id` property set in the `package.json` file in the main package
 (i.e. the package in which you run `cfx xpi`). While not generally of use to
 add-on code directly, it can be used by internal API code to index local
 storage and other resources that are associated with a particular add-on.
 Eventually, this ID will be unspoofable (see

new file mode 100644
--- /dev/null
+++ b/addon-sdk/source/doc/module-source/sdk/test/utils.md
@@ -0,0 +1,90 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - 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 `test/utils` module provides additional helper methods to be used in
+the CommonJS Unit Testing test suite.
+
+## Before and After
+
+Helper functions `before()` and `after()` are available for running a function
+before or after each test in a suite. They're useful when you need to
+guarantee a particular state before running a test, and to clean up
+after your test.
+
+    let { before, after } = require('sdk/test/utils');
+    let { search } = require('sdk/places/bookmarks');
+
+    exports.testCountBookmarks = function (assert, done) {
+      search().on('end', function (results) {
+        assert.equal(results, 0, 'should be no bookmarks');
+        done();
+      });
+    };
+
+    before(exports, function (name, assert) {
+      removeAllBookmarks();
+    });
+
+    require('sdk/test').run(exports);
+
+Both `before` and `after` may be asynchronous. To make them asynchronous,
+pass a third argument `done`, which is a function to call when you have
+finished:
+
+    let { before, after } = require('sdk/test/utils');
+    let { search } = require('sdk/places/bookmarks');
+
+    exports.testCountBookmarks = function (assert, done) {
+      search().on('end', function (results) {
+        assert.equal(results, 0, 'should be no bookmarks');
+        done();
+      });
+    };
+
+    before(exports, function (name, assert, done) {
+      removeAllBookmarksAsync(function () {
+        done();
+      });
+    });
+
+    require('sdk/test').run(exports);
+
+<api name="before">
+@function
+  Runs `beforeFn` before each test in the file. May be asynchronous
+  if `beforeFn` accepts a third argument, which is a callback.
+
+ @param exports {Object}
+    A test file's `exports` object
+ @param beforeFn {Function}
+    The function to be called before each test. It has two arguments,
+    or three if it is asynchronous:
+
+   * the first argument is the test's name as a `String`.
+   * the second argument is the `assert` object for the test.
+   * the third, optional, argument is a callback. If the callback is
+    defined, then the `beforeFn` is considered asynchronous, and the
+    callback must be invoked before the test runs.
+
+</api>
+
+<api name="after">
+@function
+  Runs `afterFn` after each test in the file. May be asynchronous
+  if `afterFn` accepts a third argument, which is a callback.
+
+ @param exports {Object}
+    A test file's `exports` object
+ @param afterFn {Function}
+    The function to be called after each test. It has two arguments,
+    or three if it is asynchronous:
+
+   * the first argument is the test's name as a `String`.
+   * the second argument is the `assert` object for the test.
+   * the third, optional, argument is a callback. If the callback is
+    defined, then the `afterFn` is considered asynchronous, and the
+    callback must be invoked before the next test runs.
+
+</api>
+

--- a/addon-sdk/source/doc/module-source/sdk/util/array.md
+++ b/addon-sdk/source/doc/module-source/sdk/util/array.md
@@ -1,13 +1,13 @@
 <!-- This Source Code Form is subject to the terms of the Mozilla Public
    - 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 `util/array` module provides simple helper functions for working with 
+The `util/array` module provides simple helper functions for working with
 arrays.
 
 <api name="has">
 @function
 Returns `true` if the given [`Array`](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array) contains the element or `false` otherwise.
 A simplified version of `array.indexOf(element) >= 0`.
 
     let { has } = require('sdk/util/array');
@@ -24,17 +24,17 @@ A simplified version of `array.indexOf(e
   The element to search for in the array.
 
 @returns {boolean}
   A boolean indicating whether or not the element was found in the array.
 </api>
 
 <api name="hasAny">
 @function
-Returns `true` if the given [`Array`](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array) contains any of the elements in the 
+Returns `true` if the given [`Array`](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array) contains any of the elements in the
 `elements` array, or `false` otherwise.
 
     let { hasAny } = require('sdk/util/array');
     let a = ['rock', 'roll', 100];
 
     hasAny(a, ['rock', 'bright', 'light']); // true
     hasAny(a, ['rush', 'coil', 'jet']); // false
 
@@ -79,17 +79,17 @@ does not add the element and returns `fa
 If the given [array](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array) contains the given element, this function
 removes the element from the array and returns `true`. Otherwise, this function
 does not alter the array and returns `false`.
 
     let { remove } = require('sdk/util/array');
     let a = ['alice', 'bob', 'carol'];
 
     remove(a, 'dave'); // false
-    remove(a, 'bob'); // true 
+    remove(a, 'bob'); // true
     remove(a, 'bob'); // false
 
     console.log(a); // ['alice', 'carol']
 
 @param array {array}
   The array to remove the element from.
 
 @param element {*}
@@ -149,8 +149,29 @@ Iterates over an [iterator](https://deve
 
 @param iterator {iterator}
   The [`Iterator`](https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Iterators_and_Generators#Iterators) object over which to iterate and place results into an array.
 
 @returns {array}
   The iterator's results in an array.
 </api>
 
+<api name="find">
+@function
+Iterates over given `array` and applies given `predicate` function until
+`predicate(element)` is `true`. If such element is found it's retured back
+otherwise third optional `fallback` argument is returned back. If fallback
+is not provided returns `undefined`.
+
+    let { find } = require('sdk/util/array');
+    let isOdd = (x) => x % 2;
+    find([2, 4, 5, 7, 8, 9], isOdd);   // => 5
+    find([2, 4, 6, 8], isOdd);         // => undefiend
+    find([2, 4, 6, 8], isOdd, null);   // => null
+
+    fromIterator(i) // ['otoro', 'unagi', 'keon']
+
+@param iterator {iterator}
+  The [`Iterator`](https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Iterators_and_Generators#Iterators) object over which to iterate and place results into an array.
+
+@returns {array}
+  The iterator's results in an array.
+</api>

--- a/addon-sdk/source/lib/sdk/addon/installer.js
+++ b/addon-sdk/source/lib/sdk/addon/installer.js
@@ -1,14 +1,18 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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/. */
 
 module.metadata = {
-  "stability": "experimental"
+  "stability": "experimental",
+  "engines": {
+    // TODO Fennec Support in bug 894515
+    "Firefox": "*"
+  }
 };
 
 const { Cc, Ci, Cu } = require("chrome");
 const { AddonManager } = Cu.import("resource://gre/modules/AddonManager.jsm");
 const { defer } = require("../core/promise");
 const { setTimeout } = require("../timers");
 
 /**

--- a/addon-sdk/source/lib/sdk/clipboard.js
+++ b/addon-sdk/source/lib/sdk/clipboard.js
@@ -2,17 +2,21 @@
 /* vim:set ts=2 sw=2 sts=2 et: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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/. */
 
 "use strict";
 
 module.metadata = {
-  "stability": "stable"
+  "stability": "stable",
+  "engines": {
+    // TODO Fennec Support 789757
+    "Firefox": "*"
+  }
 };
 
 const { Cc, Ci } = require("chrome");
 const { DataURL } = require("./url");
 const errors = require("./deprecated/errors");
 const apiUtils = require("./deprecated/api-utils");
 /*
 While these data flavors resemble Internet media types, they do

--- a/addon-sdk/source/lib/sdk/console/plain-text.js
+++ b/addon-sdk/source/lib/sdk/console/plain-text.js
@@ -3,134 +3,77 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
 module.metadata = {
   "stability": "unstable"
 };
 
-const { Cc, Ci } = require("chrome");
+const { Cc, Ci, Cu, Cr } = require("chrome");
 const self = require("../self");
-const traceback = require("./traceback")
 const prefs = require("../preferences/service");
 const { merge } = require("../util/object");
-const { partial } = require("../lang/functional");
+const { ConsoleAPI } = Cu.import("resource://gre/modules/devtools/Console.jsm");
 
-const LEVELS = {
-  "all": Number.MIN_VALUE,
-  "debug": 20000,
-  "info": 30000,
-  "warn": 40000,
-  "error": 50000,
-  "off": Number.MAX_VALUE,
-};
 const DEFAULT_LOG_LEVEL = "error";
 const ADDON_LOG_LEVEL_PREF = "extensions." + self.id + ".sdk.console.logLevel";
 const SDK_LOG_LEVEL_PREF = "extensions.sdk.console.logLevel";
 
-let logLevel;
-
+let logLevel = DEFAULT_LOG_LEVEL;
 function setLogLevel() {
-  logLevel = prefs.get(ADDON_LOG_LEVEL_PREF, prefs.get(SDK_LOG_LEVEL_PREF,
-                                                       DEFAULT_LOG_LEVEL));
+  logLevel = prefs.get(ADDON_LOG_LEVEL_PREF, 
+                           prefs.get(SDK_LOG_LEVEL_PREF,
+                                     DEFAULT_LOG_LEVEL));
 }
 setLogLevel();
 
 let logLevelObserver = {
+  QueryInterface: function(iid) {
+    if (!iid.equals(Ci.nsIObserver) &&
+        !iid.equals(Ci.nsISupportsWeakReference) &&
+        !iid.equals(Ci.nsISupports))
+      throw Cr.NS_ERROR_NO_INTERFACE;
+    return this;
+  },
   observe: function(subject, topic, data) {
     setLogLevel();
   }
 };
 let branch = Cc["@mozilla.org/preferences-service;1"].
              getService(Ci.nsIPrefService).
              getBranch(null);
-branch.addObserver(ADDON_LOG_LEVEL_PREF, logLevelObserver, false);
-branch.addObserver(SDK_LOG_LEVEL_PREF, logLevelObserver, false);
-
-function stringify(arg) {
-  try {
-    return String(arg);
-  }
-  catch(ex) {
-    return "<toString() error>";
-  }
-}
-
-function stringifyArgs(args) {
-  return Array.map(args, stringify).join(" ");
-}
-
-function message(print, level) {
-  if (LEVELS[level] < LEVELS[logLevel])
-    return;
-
-  let args = Array.slice(arguments, 2);
-
-  print(level + ": " + self.name + ": " + stringifyArgs(args) + "\n", level);
-}
-
-function errorMessage(print, e) {
-  // Some platform exception doesn't have name nor message but
-  // can be stringified to a meaningfull message
-  var fullString = ("An exception occurred.\n" +
-                   (e.name ? e.name + ": " : "") +
-                   (e.message ? e.message : e.toString()) + "\n" +
-                   (e.fileName ? traceback.sourceURI(e.fileName) + " " +
-                                 e.lineNumber + "\n"
-                               : "") +
-                   traceback.format(e));
-
-  message(print, "error", fullString);
-}
-
-function traceMessage(print) {
-  var stack = traceback.get();
-  stack.splice(-1, 1);
-
-  message(print, "info", traceback.format(stack));
-}
+branch.addObserver(ADDON_LOG_LEVEL_PREF, logLevelObserver, true);
+branch.addObserver(SDK_LOG_LEVEL_PREF, logLevelObserver, true);
 
 function PlainTextConsole(print) {
-  if (!print)
-    print = dump;
-
-  if (print === dump) {
-    // If we're just using dump(), auto-enable preferences so
-    // that the developer actually sees the console output.
-    var prefs = Cc["@mozilla.org/preferences-service;1"]
-                .getService(Ci.nsIPrefBranch);
-    prefs.setBoolPref("browser.dom.window.dump.enabled", true);
-  }
 
-  merge(this, {
-    log: partial(message, print, "info"),
-    info: partial(message, print, "info"),
-    warn: partial(message, print, "warn"),
-    error: partial(message, print, "error"),
-    debug: partial(message, print, "debug"),
-    exception: partial(errorMessage, print),
-    trace: partial(traceMessage, print),
+  let consoleOptions = {
+    prefix: self.name + ": ",
+    maxLogLevel: logLevel,
+    dump: print
+  };
+  let console = new ConsoleAPI(consoleOptions);
 
-    dir: function dir() {},
-    group: function group() {},
-    groupCollapsed: function groupCollapsed() {},
-    groupEnd: function groupEnd() {},
-    time: function time() {},
-    timeEnd: function timeEnd() {}
+  // As we freeze the console object, we can't modify this property afterward
+  Object.defineProperty(console, "maxLogLevel", {
+    get: function() {
+      return logLevel;
+    }
   });
 
   // We defined the `__exposedProps__` in our console chrome object.
   // Although it seems redundant, because we use `createObjectIn` too, in
   // worker.js, we are following what `ConsoleAPI` does. See:
   // http://mxr.mozilla.org/mozilla-central/source/dom/base/ConsoleAPI.js#132
   //
   // Meanwhile we're investigating with the platform team if `__exposedProps__`
   // are needed, or are just a left-over.
 
-  this.__exposedProps__ = Object.keys(this).reduce(function(exposed, prop) {
+  console.__exposedProps__ = Object.keys(ConsoleAPI.prototype).reduce(function(exposed, prop) {
     exposed[prop] = "r";
     return exposed;
   }, {});
 
-  Object.freeze(this);
+  Object.freeze(console);
+  return console;
 };
 exports.PlainTextConsole = PlainTextConsole;

--- a/addon-sdk/source/lib/sdk/context-menu.js
+++ b/addon-sdk/source/lib/sdk/context-menu.js
@@ -1,15 +1,19 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * 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/. */
 "use strict";
 
 module.metadata = {
-  "stability": "stable"
+  "stability": "stable",
+  "engines": {
+    // TODO Fennec support Bug 788334
+    "Firefox": "*"
+  }
 };
 
 const { Class, mix } = require("./core/heritage");
 const { addCollectionProperty } = require("./util/collection");
 const { ns } = require("./core/namespace");
 const { validateOptions, getTypeOf } = require("./deprecated/api-utils");
 const { URL, isValidURI } = require("./url");
 const { WindowTracker, browserWindowIterator } = require("./deprecated/window-utils");

--- a/addon-sdk/source/lib/sdk/indexed-db.js
+++ b/addon-sdk/source/lib/sdk/indexed-db.js
@@ -48,15 +48,8 @@ let principal = Cc["@mozilla.org/scripts
 exports.indexedDB = Object.freeze({
   open: indexedDB.openForPrincipal.bind(indexedDB, principal),
   deleteDatabase: indexedDB.deleteForPrincipal.bind(indexedDB, principal),
   cmp: indexedDB.cmp
 });
 
 exports.IDBKeyRange = IDBKeyRange;
 exports.DOMException = Ci.nsIDOMDOMException;
-exports.IDBCursor = Ci.nsIIDBCursor;
-exports.IDBTransaction = Ci.nsIIDBTransaction;
-exports.IDBOpenDBRequest = Ci.nsIIDBOpenDBRequest;
-exports.IDBDatabase = Ci.nsIIDBDatabase;
-exports.IDBIndex = Ci.nsIIDBIndex;
-exports.IDBObjectStore = Ci.nsIIDBObjectStore;
-exports.IDBRequest = Ci.nsIIDBRequest;

--- a/addon-sdk/source/lib/sdk/io/buffer.js
+++ b/addon-sdk/source/lib/sdk/io/buffer.js
@@ -4,79 +4,257 @@
  */
 "use strict";
 
 module.metadata = {
   "stability": "experimental"
 };
 
 
-const { Cc, Ci, CC } = require("chrome");
-const { Class } = require("../core/heritage");
+const { Cu } = require("chrome");
+const { TextEncoder, TextDecoder } = Cu.import("resource://gre/modules/commonjs/toolkit/loader.js", {});
 
-const Transcoder = CC("@mozilla.org/intl/scriptableunicodeconverter",
-                      "nsIScriptableUnicodeConverter");
+exports.TextEncoder = TextEncoder;
+exports.TextDecoder = TextDecoder;
+
 
-var Buffer = Class({
-  initialize: function initialize(subject, encoding) {
-    subject = subject ? subject.valueOf() : 0;
-    let length = typeof subject === "number" ? subject : 0;
-    this.encoding = encoding || "utf-8";
-    this.valueOf(Array.isArray(subject) ? subject : new Array(length));
+function Buffer(subject, encoding) {
+    var type = typeof(subject);
+    switch (type) {
+      case "number":
+        // Create typed array of the given size if number.
+        return Uint8Array(subject > 0 ? Math.floor(subject) : 0);
+      case "string":
+        // If string encode it and use buffer for the returned Uint8Array
+        // to create a local patched version that acts like node buffer.
+        encoding = encoding || "utf8";
+        return Uint8Array(TextEncoder(encoding).encode(subject).buffer);
+      case "object":
+        // If array or alike just make a copy with a local patched prototype.
+        return Uint8Array(subject);
+     default:
+        throw new TypeError("must start with number, buffer, array or string");
+    }
+}
+exports.Buffer = Buffer;
+
+// Tests if `value` is a Buffer.
+Buffer.isBuffer = value => value instanceof Buffer
+
+// Returns true if the encoding is a valid encoding argument & false otherwise
+Buffer.isEncoding = encoding => !!ENCODINGS[String(encoding).toLowerCase()]
+
+// Gives the actual byte length of a string. encoding defaults to 'utf8'.
+// This is not the same as String.prototype.length since that returns the
+// number of characters in a string.
+Buffer.byteLength = (value, encoding = "utf8") =>
+  TextEncoder(encoding).encode(value).byteLength
 
-    if (typeof subject === "string") this.write(subject);
-  },
-  get length() {
-    return this.valueOf().length;
-  },
-  get: function get(index) {
-    return this.valueOf()[index];
-  },
-  set: function set(index, value) {
-    return this.valueOf()[index] = value;
-  },
-  valueOf: function valueOf(value) {
-    Object.defineProperty(this, "valueOf", {
-      value: Array.prototype.valueOf.bind(value),
-      configurable: false,
-      writable: false,
-      enumerable: false
-    });
+// Direct copy of the nodejs's buffer implementation:
+// https://github.com/joyent/node/blob/b255f4c10a80343f9ce1cee56d0288361429e214/lib/buffer.js#L146-L177
+Buffer.concat = function(list, length) {
+  if (!Array.isArray(list))
+    throw new TypeError('Usage: Buffer.concat(list[, length])');
+
+  if (typeof length === 'undefined') {
+    length = 0;
+    for (var i = 0; i < list.length; i++)
+      length += list[i].length;
+  } else {
+    length = ~~length;
+  }
+
+  if (length < 0)
+    length = 0;
+
+  if (list.length === 0)
+    return new Buffer(0);
+  else if (list.length === 1)
+    return list[0];
+
+  if (length < 0)
+    throw new RangeError('length is not a positive number');
+
+  var buffer = new Buffer(length);
+  var pos = 0;
+  for (var i = 0; i < list.length; i++) {
+    var buf = list[i];
+    buf.copy(buffer, pos);
+    pos += buf.length;
+  }
+
+  return buffer;
+};
+
+// Node buffer is very much like Uint8Array although it has bunch of methods
+// that typically can be used in combination with `DataView` while preserving
+// access by index. Since in SDK echo module has it's own set of bult-ins it
+// ok to patch ours to make it nodejs Buffer compatible.
+Buffer.prototype = Uint8Array.prototype;
+Object.defineProperties(Buffer.prototype, {
+  view: {
+    get: function() this._view || (this._view = DataView(this.buffer))
   },
-  toString: function toString(encoding, start, end) {
-    let bytes = this.valueOf().slice(start || 0, end || this.length);
-    let transcoder = Transcoder();
-    transcoder.charset = String(encoding || this.encoding).toUpperCase();
-    return transcoder.convertFromByteArray(bytes, this.length);
+  toString: {
+    value: function(encoding, start, end) {
+      encoding = !!encoding ? (encoding + '').toLowerCase() : "utf8";
+      start = Math.max(0, ~~start);
+      end = Math.min(this.length, end === void(0) ? this.length : ~~end);
+      return TextDecoder(encoding).decode(this.subarray(start, end));
+    }
+  },
+  toJSON: {
+    value: function() ({ type: "Buffer", data: Array.slice(this, 0) })
   },
-  toJSON: function toJSON() {
-    return this.toString()
+  get: {
+    value: function(offset) this[offset]
+  },
+  set: {
+    value: function(offset, value) this[offset] = value
+  },
+  copy: {
+    value: function(target, offset, start, end)
+      Uint8Array.set(target, this.subarray(start, end), offset)
+  },
+  slice: {
+    value: Buffer.prototype.subarray
   },
-  write: function write(string, offset, encoding) {
-    offset = Math.max(offset || 0, 0);
-    let value = this.valueOf();
-    let transcoder = Transcoder();
-    transcoder.charset = String(encoding || this.encoding).toUpperCase();
-    let bytes = transcoder.convertToByteArray(string, {});
-    value.splice.apply(value, [
-      offset,
-      Math.min(value.length - offset, bytes.length, bytes)
-    ].concat(bytes));
-    return bytes;
+  write: {
+    value: function(string, offset, length, encoding = "utf8") {
+      if (typeof(offset) === "string")
+        ([offset, length, encoding]) = [0, null, offset];
+      else if (typeof(length) === "string")
+        ([length, encoding]) = [null, length];
+
+      offset = ~~offset;
+      length = length || this.length - offset;
+      let buffer = TextEncoder(encoding).encode(string);
+      let result = Math.min(buffer.length, length);
+      if (buffer.length !== length)
+        buffer = buffer.subarray(0, length);
+      Uint8Array.set(this, buffer, offset);
+      return result;
+    }
   },
-  slice: function slice(start, end) {
-    return new Buffer(this.valueOf().slice(start, end));
-  },
-  copy: function copy(target, offset, start, end) {
-    offset = Math.max(offset || 0, 0);
-    target = target.valueOf();
-    let bytes = this.valueOf();
-    bytes.slice(Math.max(start || 0, 0), end);
-    target.splice.apply(target, [
-      offset,
-      Math.min(target.length - offset, bytes.length),
-    ].concat(bytes));
+  fill: {
+    value: function fill(value, start, end) {
+      value = value || 0;
+      start = start || 0;
+      end = end || this.length;
+
+      if (typeof(value) === "string")
+        value = value.charCodeAt(0);
+      if (typeof(value) !== "number" || isNaN(value))
+        throw TypeError("value is not a number");
+      if (end < start)
+        throw new RangeError("end < start");
+
+      // Fill 0 bytes; we're done
+      if (end === start)
+        return 0;
+      if (this.length == 0)
+        return 0;
+
+      if (start < 0 || start >= this.length)
+        throw RangeError("start out of bounds");
+
+      if (end < 0 || end > this.length)
+        throw RangeError("end out of bounds");
+
+      let index = start;
+      while (index < end) this[index++] = value;
+    }
   }
 });
-Buffer.isBuffer = function isBuffer(buffer) {
-  return buffer instanceof Buffer
-};
-exports.Buffer = Buffer;
+
+// Define nodejs Buffer's getter and setter functions that just proxy
+// to internal DataView's equivalent methods.
+[["readUInt16LE", "getUint16", true],
+ ["readUInt16BE", "getUint16", false],
+ ["readInt16LE", "getInt16", true],
+ ["readInt16BE", "getInt16", false],
+ ["readUInt32LE", "getInt32", true],
+ ["readUInt32BE", "getInt32", false],
+ ["readInt32LE", "getInt32", true],
+ ["readInt32BE", "getInt32", false],
+ ["readFloatLE", "getFloat32", true],
+ ["readFloatBE", "getFloat32", false],
+ ["readDoubleLE", "getFloat64", true],
+ ["readDoubleBE", "getFloat64", false],
+ ["readUInt8", "getUint8"],
+ ["readInt8", "getInt8"]].forEach(([alias, name, littleEndian]) => {
+  Object.defineProperty(Buffer.prototype, alias, {
+    value: function(offset) this.view[name](offset, littleEndian)
+  });
+});
+
+[["writeUInt16LE", "setUint16", true],
+ ["writeUInt16BE", "setUint16", false],
+ ["writeInt16LE", "setInt16", true],
+ ["writeInt16BE", "setInt16", false],
+ ["writeUInt32LE", "setUint32", true],
+ ["writeUInt32BE", "setUint32", false],
+ ["writeInt32LE", "setInt32", true],
+ ["writeInt32BE", "setInt32", false],
+ ["writeFloatLE", "setFloat32", true],
+ ["writeFloatBE", "setFloat32", false],
+ ["writeDoubleLE", "setFloat64", true],
+ ["writeDoubleBE", "setFloat64", false],
+ ["writeUInt8", "setUint8"],
+ ["writeInt8", "setInt8"]].forEach(([alias, name, littleEndian]) => {
+  Object.defineProperty(Buffer.prototype, alias, {
+    value: function(value, offset) this.view[name](offset, value, littleEndian)
+  });
+});
+
+
+// List of supported encodings taken from:
+// http://mxr.mozilla.org/mozilla-central/source/dom/encoding/labelsencodings.properties
+const ENCODINGS = { "unicode-1-1-utf-8": 1, "utf-8": 1, "utf8": 1,
+  "866": 1, "cp866": 1, "csibm866": 1, "ibm866": 1, "csisolatin2": 1,
+  "iso-8859-2": 1, "iso-ir-101": 1, "iso8859-2": 1, "iso88592": 1,
+  "iso_8859-2": 1, "iso_8859-2:1987": 1, "l2": 1, "latin2": 1, "csisolatin3": 1,
+  "iso-8859-3": 1, "iso-ir-109": 1, "iso8859-3": 1, "iso88593": 1,
+  "iso_8859-3": 1, "iso_8859-3:1988": 1, "l3": 1, "latin3": 1, "csisolatin4": 1,
+  "iso-8859-4": 1, "iso-ir-110": 1, "iso8859-4": 1, "iso88594": 1,
+  "iso_8859-4": 1, "iso_8859-4:1988": 1, "l4": 1, "latin4": 1,
+  "csisolatincyrillic": 1, "cyrillic": 1, "iso-8859-5": 1, "iso-ir-144": 1,
+  "iso8859-5": 1, "iso88595": 1, "iso_8859-5": 1, "iso_8859-5:1988": 1,
+  "arabic": 1, "asmo-708": 1, "csiso88596e": 1, "csiso88596i": 1,
+  "csisolatinarabic": 1, "ecma-114": 1, "iso-8859-6": 1, "iso-8859-6-e": 1,
+  "iso-8859-6-i": 1, "iso-ir-127": 1, "iso8859-6": 1, "iso88596": 1,
+  "iso_8859-6": 1, "iso_8859-6:1987": 1, "csisolatingreek": 1, "ecma-118": 1,
+  "elot_928": 1, "greek": 1, "greek8": 1, "iso-8859-7": 1, "iso-ir-126": 1,
+  "iso8859-7": 1, "iso88597": 1, "iso_8859-7": 1, "iso_8859-7:1987": 1,
+  "sun_eu_greek": 1, "csiso88598e": 1, "csisolatinhebrew": 1, "hebrew": 1,
+  "iso-8859-8": 1, "iso-8859-8-e": 1, "iso-ir-138": 1, "iso8859-8": 1,
+  "iso88598": 1, "iso_8859-8": 1, "iso_8859-8:1988": 1, "visual": 1,
+  "csiso88598i": 1, "iso-8859-8-i": 1, "logical": 1, "csisolatin6": 1,
+  "iso-8859-10": 1, "iso-ir-157": 1, "iso8859-10": 1, "iso885910": 1,
+  "l6": 1, "latin6": 1, "iso-8859-13": 1, "iso8859-13": 1, "iso885913": 1,
+  "iso-8859-14": 1, "iso8859-14": 1, "iso885914": 1, "csisolatin9": 1,
+  "iso-8859-15": 1, "iso8859-15": 1, "iso885915": 1, "iso_8859-15": 1,
+  "l9": 1, "iso-8859-16": 1, "cskoi8r": 1, "koi": 1, "koi8": 1, "koi8-r": 1,
+  "koi8_r": 1, "koi8-u": 1, "csmacintosh": 1, "mac": 1, "macintosh": 1,
+  "x-mac-roman": 1, "dos-874": 1, "iso-8859-11": 1, "iso8859-11": 1,
+  "iso885911": 1, "tis-620": 1, "windows-874": 1, "cp1250": 1,
+  "windows-1250": 1, "x-cp1250": 1, "cp1251": 1, "windows-1251": 1,
+  "x-cp1251": 1, "ansi_x3.4-1968": 1, "ascii": 1, "cp1252": 1, "cp819": 1,
+  "csisolatin1": 1, "ibm819": 1, "iso-8859-1": 1, "iso-ir-100": 1,
+  "iso8859-1": 1, "iso88591": 1, "iso_8859-1": 1, "iso_8859-1:1987": 1,
+  "l1": 1, "latin1": 1, "us-ascii": 1, "windows-1252": 1, "x-cp1252": 1,
+  "cp1253": 1, "windows-1253": 1, "x-cp1253": 1, "cp1254": 1, "csisolatin5": 1,
+  "iso-8859-9": 1, "iso-ir-148": 1, "iso8859-9": 1, "iso88599": 1,
+  "iso_8859-9": 1, "iso_8859-9:1989": 1, "l5": 1, "latin5": 1,
+  "windows-1254": 1, "x-cp1254": 1, "cp1255": 1, "windows-1255": 1,
+  "x-cp1255": 1, "cp1256": 1, "windows-1256": 1, "x-cp1256": 1, "cp1257": 1,
+  "windows-1257": 1, "x-cp1257": 1, "cp1258": 1, "windows-1258": 1,
+  "x-cp1258": 1, "x-mac-cyrillic": 1, "x-mac-ukrainian": 1, "chinese": 1,
+  "csgb2312": 1, "csiso58gb231280": 1, "gb2312": 1, "gb_2312": 1,
+  "gb_2312-80": 1, "gbk": 1, "iso-ir-58": 1, "x-gbk": 1, "gb18030": 1,
+  "hz-gb-2312": 1, "big5": 1, "big5-hkscs": 1, "cn-big5": 1, "csbig5": 1,
+  "x-x-big5": 1, "cseucpkdfmtjapanese": 1, "euc-jp": 1, "x-euc-jp": 1,
+  "csiso2022jp": 1, "iso-2022-jp": 1, "csshiftjis": 1, "ms_kanji": 1,
+  "shift-jis": 1, "shift_jis": 1, "sjis": 1, "windows-31j": 1, "x-sjis": 1,
+  "cseuckr": 1, "csksc56011987": 1, "euc-kr": 1, "iso-ir-149": 1, "korean": 1,
+  "ks_c_5601-1987": 1, "ks_c_5601-1989": 1, "ksc5601": 1, "ksc_5601": 1,
+  "windows-949": 1, "csiso2022kr": 1, "iso-2022-kr": 1, "utf-16": 1,
+  "utf-16le": 1, "utf-16be": 1, "x-user-defined": 1 };

--- a/addon-sdk/source/lib/sdk/io/fs.js
+++ b/addon-sdk/source/lib/sdk/io/fs.js
@@ -7,20 +7,22 @@
 module.metadata = {
   "stability": "experimental"
 };
 
 const { Cc, Ci, CC } = require("chrome");
 
 const { setTimeout } = require("../timers");
 const { Stream, InputStream, OutputStream } = require("./stream");
+const { emit, on } = require("../event/core");
 const { Buffer } = require("./buffer");
 const { ns } = require("../core/namespace");
 const { Class } = require("../core/heritage");
 
+
 const nsILocalFile = CC("@mozilla.org/file/local;1", "nsILocalFile",
                         "initWithPath");
 const FileOutputStream = CC("@mozilla.org/network/file-output-stream;1",
                             "nsIFileOutputStream", "init");
 const FileInputStream = CC("@mozilla.org/network/file-input-stream;1",
                            "nsIFileInputStream", "init");
 const BinaryInputStream = CC("@mozilla.org/binaryinputstream;1",
                              "nsIBinaryInputStream", "setInputStream");
@@ -28,16 +30,18 @@ const BinaryOutputStream = CC("@mozilla.
                               "nsIBinaryOutputStream", "setOutputStream");
 const StreamPump = CC("@mozilla.org/network/input-stream-pump;1",
                       "nsIInputStreamPump", "init");
 
 const { createOutputTransport, createInputTransport } =
   Cc["@mozilla.org/network/stream-transport-service;1"].
   getService(Ci.nsIStreamTransportService);
 
+const { OPEN_UNBUFFERED } = Ci.nsITransport;
+
 
 const { REOPEN_ON_REWIND, DEFER_OPEN } = Ci.nsIFileInputStream;
 const { DIRECTORY_TYPE, NORMAL_FILE_TYPE } = Ci.nsIFile;
 const { NS_SEEK_SET, NS_SEEK_CUR, NS_SEEK_END } = Ci.nsISeekableStream;
 
 const FILE_PERMISSION = parseInt("0666", 8);
 const PR_UINT32_MAX = 0xfffffff;
 // Values taken from:
@@ -152,24 +156,26 @@ const ReadStream = Class({
       input.QueryInterface(Ci.nsISeekableStream).seek(NS_SEEK_SET, position);
     // We use `nsIStreamTransportService` service to transform blocking
     // file input stream into a fully asynchronous stream that can be written
     // without blocking the main thread.
     let transport = createInputTransport(input, position, length, false);
     // Open an input stream on a transport. We don"t pass flags to guarantee
     // non-blocking stream semantics. Also we use defaults for segment size &
     // count.
-    let asyncInputStream = transport.openInputStream(null, 0, 0);
-    let binaryInputStream = BinaryInputStream(asyncInputStream);
-    nsIBinaryInputStream(fd, binaryInputStream);
-    let pump = StreamPump(asyncInputStream, position, length, 0, 0, false);
+    InputStream.prototype.initialize.call(this, {
+      asyncInputStream: transport.openInputStream(null, 0, 0)
+    });
 
-    InputStream.prototype.initialize.call(this, {
-      input: binaryInputStream, pump: pump
+    // Close file descriptor on end and destroy the stream.
+    on(this, "end", _ => {
+      this.destroy();
+      emit(this, "close");
     });
+
     this.read();
   },
   destroy: function() {
     closeSync(this.fd);
     InputStream.prototype.destroy.call(this);
   }
 });
 exports.ReadStream = ReadStream;
@@ -206,31 +212,30 @@ const WriteStream = Class({
       output.QueryInterface(Ci.nsISeekableStream).seek(NS_SEEK_SET, position);
     // We use `nsIStreamTransportService` service to transform blocking
     // file output stream into a fully asynchronous stream that can be written
     // without blocking the main thread.
     let transport = createOutputTransport(output, position, -1, false);
     // Open an output stream on a transport. We don"t pass flags to guarantee
     // non-blocking stream semantics. Also we use defaults for segment size &
     // count.
-    let asyncOutputStream = transport.openOutputStream(null, 0, 0);
-    // Finally we create a non-blocking binary output stream. This will allows
-    // us to write buffers as byte arrays without any further transcoding.
-    let binaryOutputStream = BinaryOutputStream(asyncOutputStream);
-    nsIBinaryOutputStream(fd, binaryOutputStream);
+    OutputStream.prototype.initialize.call(this, {
+      asyncOutputStream: transport.openOutputStream(OPEN_UNBUFFERED, 0, 0),
+      output: output
+    });
 
-    // Storing output stream so that it can beaccessed later.
-    OutputStream.prototype.initialize.call(this, {
-      output: binaryOutputStream,
-      asyncOutputStream: asyncOutputStream
+    // For write streams "finish" basically means close.
+    on(this, "finish", _ => {
+       this.destroy();
+       emit(this, "close");
     });
   },
   destroy: function() {
+    OutputStream.prototype.destroy.call(this);
     closeSync(this.fd);
-    OutputStream.prototype.destroy.call(this);
   }
 });
 exports.WriteStream = WriteStream;
 exports.createWriteStream = function createWriteStream(path, options) {
   return new WriteStream(path, options);
 };
 
 const Stats = Class({
@@ -360,17 +365,17 @@ exports.truncate = truncate;
 
 function ftruncate(fd, length, callback) {
   write(fd, new Buffer(length), 0, length, 0, function(error) {
     callback(error);
   });
 }
 exports.ftruncate = ftruncate;
 
-function ftruncateSync(fd, length) {
+function ftruncateSync(fd, length = 0) {
   writeSync(fd, new Buffer(length), 0, length, 0);
 }
 exports.ftruncateSync = ftruncateSync;
 
 function chownSync(path, uid, gid) {
   throw Error("Not implemented yet!!");
 }
 exports.chownSync = chownSync;
@@ -629,16 +634,18 @@ exports.close = close;
 
 /**
  * Synchronous open(2).
  */
 function openSync(path, flags, mode) {
   let [ fd, flags, mode, file ] =
       [ { path: path }, Flags(flags), Mode(mode), nsILocalFile(path) ];
 
+  nsIFile(fd, file);
+
   // If trying to open file for just read that does not exists
   // need to throw exception as node does.
   if (!file.exists() && !isWritable(flags))
     throw FSError("open", "ENOENT", 34, path);
 
   // If we want to open file in read mode we initialize input stream.
   if (isReadable(flags)) {
     let input = FileInputStream(file, flags, mode, DEFER_OPEN);
@@ -670,17 +677,19 @@ function writeSync(fd, buffer, offset, l
   if (length + offset > buffer.length) {
     throw Error("Length is extends beyond buffer");
   }
   else if (length + offset !== buffer.length) {
     buffer = buffer.slice(offset, offset + length);
   }
   let writeStream = new WriteStream(fd, { position: position,
                                           length: length });
-  let output = nsIBinaryOutputStream(fd);
+
+  let output = BinaryOutputStream(nsIFileOutputStream(fd));
+  nsIBinaryOutputStream(fd, output);
   // We write content as a byte array as this will avoid any transcoding
   // if content was a buffer.
   output.writeByteArray(buffer.valueOf(), buffer.length);
   output.flush();
 };
 exports.writeSync = writeSync;
 
 /**
@@ -731,20 +740,24 @@ function readSync(fd, buffer, offset, le
   // Setting a stream position, unless it"s `-1` which means current position.
   if (position >= 0)
     input.QueryInterface(Ci.nsISeekableStream).seek(NS_SEEK_SET, position);
   // We use `nsIStreamTransportService` service to transform blocking
   // file input stream into a fully asynchronous stream that can be written
   // without blocking the main thread.
   let binaryInputStream = BinaryInputStream(input);
   let count = length === ALL ? binaryInputStream.available() : length;
-  var bytes = binaryInputStream.readByteArray(count);
-  buffer.copy.call(bytes, buffer, offset);
+  if (offset === 0) binaryInputStream.readArrayBuffer(count, buffer.buffer);
+  else {
+    let chunk = new Buffer(count);
+    binaryInputStream.readArrayBuffer(count, chunk.buffer);
+    chunk.copy(buffer, offset);
+  }
 
-  return bytes;
+  return buffer.slice(offset, offset + count);
 };
 exports.readSync = readSync;
 
 /**
  * Read data from the file specified by `fd`.
  *
  * `buffer` is the buffer that the data will be written to.
  * `offset` is offset within the buffer where writing will start.
@@ -754,19 +767,19 @@ exports.readSync = readSync;
  * `position` is an integer specifying where to begin reading from in the file.
  * If `position` is `null`, data will be read from the current file position.
  *
  * The callback is given the three arguments, `(error, bytesRead, buffer)`.
  */
 function read(fd, buffer, offset, length, position, callback) {
   let bytesRead = 0;
   let readStream = new ReadStream(fd, { position: position, length: length });
-  readStream.on("data", function onData(chunck) {
-      chunck.copy(buffer, offset + bytesRead);
-      bytesRead += chunck.length;
+  readStream.on("data", function onData(data) {
+      data.copy(buffer, offset + bytesRead);
+      bytesRead += data.length;
   });
   readStream.on("end", function onEnd() {
     callback(null, bytesRead, buffer);
     readStream.destroy();
   });
 };
 exports.read = read;
 
@@ -776,44 +789,52 @@ exports.read = read;
  * contents of the file.
  */
 function readFile(path, encoding, callback) {
   if (isFunction(encoding)) {
     callback = encoding
     encoding = null
   }
 
-  let buffer = new Buffer();
+  let buffer = null;
   try {
     let readStream = new ReadStream(path);
-    readStream.on("data", function(chunck) {
-      chunck.copy(buffer, buffer.length);
+    readStream.on("data", function(data) {
+      if (!buffer) buffer = data;
+      else {
+        let bufferred = buffer
+        buffer = new Buffer(buffer.length + data.length);
+        bufferred.copy(buffer, 0);
+        data.copy(buffer, bufferred.length);
+      }
     });
     readStream.on("error", function onError(error) {
       callback(error);
-      readStream.destroy();
     });
     readStream.on("end", function onEnd() {
+      // Note: Need to destroy before invoking a callback
+      // so that file descriptor is released.
+      readStream.destroy();
       callback(null, buffer);
-      readStream.destroy();
     });
   } catch (error) {
     setTimeout(callback, 0, error);
   }
 };
 exports.readFile = readFile;
 
 /**
  * Synchronous version of `fs.readFile`. Returns the contents of the path.
  * If encoding is specified then this function returns a string.
  * Otherwise it returns a buffer.
  */
 function readFileSync(path, encoding) {
-  let buffer = new Buffer();
   let fd = openSync(path, "r");
+  let size = fstatSync(fd).size;
+  let buffer = new Buffer(size);
   try {
     readSync(fd, buffer, 0, ALL, 0);
   }
   finally {
     closeSync(fd);
   }
   return buffer;
 };
@@ -828,23 +849,26 @@ function writeFile(path, content, encodi
     if (isFunction(encoding)) {
       callback = encoding
       encoding = null
     }
     if (isString(content))
       content = new Buffer(content, encoding);
 
     let writeStream = new WriteStream(path);
-    writeStream.on("error", function onError(error) {
+    let error = null;
+
+    writeStream.end(content, function() {
+      writeStream.destroy();
       callback(error);
-      writeStream.destroy();
     });
-    writeStream.write(content, function onDrain() {
+
+    writeStream.on("error", function onError(reason) {
+      error = reason;
       writeStream.destroy();
-      callback(null);
     });
   } catch (error) {
     callback(error);
   }
 };
 exports.writeFile = writeFile;
 
 /**

--- a/addon-sdk/source/lib/sdk/io/stream.js
+++ b/addon-sdk/source/lib/sdk/io/stream.js
@@ -3,109 +3,55 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 "use strict";
 
 module.metadata = {
   "stability": "experimental"
 };
 
+const { CC, Cc, Ci, Cu, Cr, components } = require("chrome");
 const { EventTarget } = require("../event/target");
 const { emit } = require("../event/core");
 const { Buffer } = require("./buffer");
 const { Class } = require("../core/heritage");
 const { setTimeout } = require("../timers");
-const { ns } = require("../core/namespace");
+
+
+const MultiplexInputStream = CC("@mozilla.org/io/multiplex-input-stream;1",
+                                "nsIMultiplexInputStream");
+const AsyncStreamCopier = CC("@mozilla.org/network/async-stream-copier;1",
+                             "nsIAsyncStreamCopier", "init");
+const StringInputStream = CC("@mozilla.org/io/string-input-stream;1",
+                             "nsIStringInputStream");
+const ArrayBufferInputStream = CC("@mozilla.org/io/arraybuffer-input-stream;1",
+                                  "nsIArrayBufferInputStream");
 
-function isFunction(value) typeof value === "function"
+const BinaryInputStream = CC("@mozilla.org/binaryinputstream;1",
+                             "nsIBinaryInputStream", "setInputStream");
+const InputStreamPump = CC("@mozilla.org/network/input-stream-pump;1",
+                           "nsIInputStreamPump", "init");
+
+const threadManager = Cc["@mozilla.org/thread-manager;1"].
+                      getService(Ci.nsIThreadManager);
+
+const eventTarget = Cc["@mozilla.org/network/socket-transport-service;1"].
+                    getService(Ci.nsIEventTarget);
+
+let isFunction = value => typeof(value) === "function"
 
 function accessor() {
   let map = new WeakMap();
-  return function(fd, value) {
-    if (value === null) map.delete(fd);
-    if (value !== undefined) map.set(fd, value);
-    return map.get(fd);
+  return function(target, value) {
+    if (value)
+      map.set(target, value);
+    return map.get(target);
   }
 }
 
-let nsIInputStreamPump = accessor();
-let nsIAsyncOutputStream = accessor();
-let nsIInputStream = accessor();
-let nsIOutputStream = accessor();
-
-
-/**
- * Utility function / hack that we use to figure if output stream is closed.
- */
-function isClosed(stream) {
-  // We assume that stream is not closed.
-  let isClosed = false;
-  stream.asyncWait({
-    // If `onClose` callback is called before outer function returns
-    // (synchronously) `isClosed` will be set to `true` identifying
-    // that stream is closed.
-    onOutputStreamReady: function onClose() isClosed = true
-
-  // `WAIT_CLOSURE_ONLY` flag overrides the default behavior, causing the
-  // `onOutputStreamReady` notification to be suppressed until the stream
-  // becomes closed.
-  }, stream.WAIT_CLOSURE_ONLY, 0, null);
-  return isClosed;
-}
-/**
- * Utility function takes output `stream`, `onDrain`, `onClose` callbacks and
- * calls one of this callbacks depending on stream state. It is guaranteed
- * that only one called will be called and it will be called asynchronously.
- * @param {nsIAsyncOutputStream} stream
- * @param {Function} onDrain
- *    callback that is called when stream becomes writable.
- * @param {Function} onClose
- *    callback that is called when stream becomes closed.
- */
-function onStateChange(stream, target) {
-  let isAsync = false;
-  stream.asyncWait({
-    onOutputStreamReady: function onOutputStreamReady() {
-      // If `isAsync` was not yet set to `true` by the last line we know that
-      // `onOutputStreamReady` was called synchronously. In such case we just
-      // defer execution until next turn of event loop.
-      if (!isAsync)
-        return setTimeout(onOutputStreamReady, 0);
-
-      // As it"s not clear what is a state of the stream (TODO: Is there really
-      // no better way ?) we employ hack (see details in `isClosed`) to verify
-      // if stream is closed.
-      emit(target, isClosed(stream) ? "close" : "drain");
-    }
-  }, 0, 0, null);
-  isAsync = true;
-}
-
-function pump(stream) {
-  let input = nsIInputStream(stream);
-  nsIInputStreamPump(stream).asyncRead({
-    onStartRequest: function onStartRequest() {
-      emit(stream, "start");
-    },
-    onDataAvailable: function onDataAvailable(req, c, is, offset, count) {
-      try {
-        let bytes = input.readByteArray(count);
-        emit(stream, "data", new Buffer(bytes, stream.encoding));
-      } catch (error) {
-        emit(stream, "error", error);
-        stream.readable = false;
-      }
-    },
-    onStopRequest: function onStopRequest() {
-      stream.readable = false;
-      emit(stream, "end");
-    }
-  }, null);
-}
-
 const Stream = Class({
   extends: EventTarget,
   initialize: function() {
     this.readable = false;
     this.writable = false;
     this.encoding = null;
   },
   setEncoding: function setEncoding(encoding) {
@@ -115,17 +61,18 @@ const Stream = Class({
     let source = this;
     function onData(chunk) {
       if (target.writable) {
         if (false === target.write(chunk))
           source.pause();
       }
     }
     function onDrain() {
-      if (source.readable) source.resume();
+      if (source.readable)
+        source.resume();
     }
     function onEnd() {
       target.end();
     }
     function onPause() {
       source.pause();
     }
     function onResume() {
@@ -171,154 +118,320 @@ const Stream = Class({
     emit(this, "resume");
   },
   destroySoon: function destroySoon() {
     this.destroy();
   }
 });
 exports.Stream = Stream;
 
+
+let nsIStreamListener = accessor();
+let nsIInputStreamPump = accessor();
+let nsIAsyncInputStream = accessor();
+let nsIBinaryInputStream = accessor();
+
+const StreamListener = Class({
+  initialize: function(stream) {
+    this.stream = stream;
+  },
+
+  // Next three methods are part of `nsIStreamListener` interface and are
+  // invoked by `nsIInputStreamPump.asyncRead`.
+  onDataAvailable: function(request, context, input, offset, count) {
+    let stream = this.stream;
+    let buffer = new ArrayBuffer(count);
+    nsIBinaryInputStream(stream).readArrayBuffer(count, buffer);
+    emit(stream, "data", new Buffer(buffer, stream.encoding));
+  },
+
+  // Next two methods implement `nsIRequestObserver` interface and are invoked
+  // by `nsIInputStreamPump.asyncRead`.
+  onStartRequest: function() {},
+  // Called to signify the end of an asynchronous request. We only care to
+  // discover errors.
+  onStopRequest: function(request, context, status) {
+    let stream = this.stream;
+    stream.readable = false;
+    if (!components.isSuccessCode(status))
+      emit(stream, "error", status);
+    else
+      emit(stream, "end");
+  }
+});
+
+
 const InputStream = Class({
   extends: Stream,
+  readable: false,
+  paused: false,
   initialize: function initialize(options) {
-    let { input, pump } = options;
+    let { asyncInputStream } = options;
 
     this.readable = true;
-    this.paused = false;
-    nsIInputStream(this, input);
-    nsIInputStreamPump(this, pump);
+
+    let binaryInputStream = new BinaryInputStream(asyncInputStream);
+    let inputStreamPump = new InputStreamPump(asyncInputStream,
+                                              -1, -1, 0, 0, false);
+    let streamListener = new StreamListener(this);
+
+    nsIAsyncInputStream(this, asyncInputStream);
+    nsIInputStreamPump(this, inputStreamPump);
+    nsIBinaryInputStream(this, binaryInputStream);
+    nsIStreamListener(this, streamListener);
+
+    this.asyncInputStream = asyncInputStream;
+    this.inputStreamPump = inputStreamPump;
+    this.binaryInputStream = binaryInputStream;
   },
   get status() nsIInputStreamPump(this).status,
-  read: function() pump(this),
+  read: function() {
+    nsIInputStreamPump(this).asyncRead(nsIStreamListener(this), null);
+  },
   pause: function pause() {
     this.paused = true;
     nsIInputStreamPump(this).suspend();
     emit(this, "paused");
   },
   resume: function resume() {
     this.paused = false;
     nsIInputStreamPump(this).resume();
     emit(this, "resume");
   },
-  destroy: function destroy() {
+  close: function close() {
     this.readable = false;
-    try {
-      emit(this, "close", null);
-      nsIInputStreamPump(this).cancel(null);
-      nsIInputStreamPump(this, null);
+    nsIInputStreamPump(this).cancel(Cr.NS_OK);
+    nsIBinaryInputStream(this).close();
+    nsIAsyncInputStream(this).close();
+  },
+  destroy: function destroy() {
+    this.close();
 
-      nsIInputStream(this).close();
-      nsIInputStream(this, null);
-    } catch (error) {
-      emit(this, "error", error);
-    }
+    nsIInputStreamPump(this);
+    nsIAsyncInputStream(this);
+    nsIBinaryInputStream(this);
+    nsIStreamListener(this);
   }
 });
 exports.InputStream = InputStream;
 
+
+
+let nsIRequestObserver = accessor();
+let nsIAsyncOutputStream = accessor();
+let nsIAsyncStreamCopier = accessor();
+let nsIMultiplexInputStream = accessor();
+
+const RequestObserver = Class({
+  initialize: function(stream) {
+    this.stream = stream;
+  },
+  // Method is part of `nsIRequestObserver` interface that is
+  // invoked by `nsIAsyncStreamCopier.asyncCopy`.
+  onStartRequest: function() {},
+  // Method is part of `nsIRequestObserver` interface that is
+  // invoked by `nsIAsyncStreamCopier.asyncCopy`.
+  onStopRequest: function(request, context, status) {
+    let stream = this.stream;
+    stream.drained = true;
+
+    // Remove copied chunk.
+    let multiplexInputStream = nsIMultiplexInputStream(stream);
+    multiplexInputStream.removeStream(0);
+
+    // If there was an error report.
+    if (!components.isSuccessCode(status))
+      emit(stream, "error", status);
+
+    // If there more chunks in queue then flush them.
+    else if (multiplexInputStream.count)
+      stream.flush();
+
+    // If stream is still writable notify that queue has drained.
+    else if (stream.writable)
+      emit(stream, "drain");
+
+    // If stream is no longer writable close it.
+    else {
+      nsIAsyncStreamCopier(stream).cancel(Cr.NS_OK);
+      nsIMultiplexInputStream(stream).close();
+      nsIAsyncOutputStream(stream).close();
+      nsIAsyncOutputStream(stream).flush();
+    }
+  }
+});
+
+const OutputStreamCallback = Class({
+  initialize: function(stream) {
+    this.stream = stream;
+  },
+  // Method is part of `nsIOutputStreamCallback` interface that
+  // is invoked by `nsIAsyncOutputStream.asyncWait`. It is registered
+  // with `WAIT_CLOSURE_ONLY` flag that overrides the default behavior,
+  // causing the `onOutputStreamReady` notification to be suppressed until
+  // the stream becomes closed.
+  onOutputStreamReady: function(nsIAsyncOutputStream) {
+    emit(this.stream, "finish");
+  }
+});
+
 const OutputStream = Class({
   extends: Stream,
+  writable: false,
+  drained: true,
+  get bufferSize() {
+    let multiplexInputStream = nsIMultiplexInputStream(this);
+    return multiplexInputStream && multiplexInputStream.available();
+  },
   initialize: function initialize(options) {
-    let { output, asyncOutputStream } = options;
+    let { asyncOutputStream, output } = options;
+    this.writable = true;
+
+    // Ensure that `nsIAsyncOutputStream` was provided.
+    asyncOutputStream.QueryInterface(Ci.nsIAsyncOutputStream);
 
-    this.writable = true;
-    nsIOutputStream(this, output);
+    // Create a `nsIMultiplexInputStream` and `nsIAsyncStreamCopier`. Former
+    // is used to queue written data chunks that `asyncStreamCopier` will
+    // asynchronously drain into `asyncOutputStream`.
+    let multiplexInputStream = MultiplexInputStream();
+    let asyncStreamCopier = AsyncStreamCopier(multiplexInputStream,
+                                              output || asyncOutputStream,
+                                              eventTarget,
+                                              // nsIMultiplexInputStream
+                                              // implemnts .readSegments()
+                                              true,
+                                              // nsIOutputStream may or
+                                              // may not implemnet
+                                              // .writeSegments().
+                                              false,
+                                              // Use default buffer size.
+                                              null,
+                                              // Should not close an input.
+                                              false,
+                                              // Should not close an output.
+                                              false);
+
+    // Create `requestObserver` implementing `nsIRequestObserver` interface
+    // in the constructor that's gonna be reused across several flushes.
+    let requestObserver = RequestObserver(this);
+
+
+    // Create observer that implements `nsIOutputStreamCallback` and register
+    // using `WAIT_CLOSURE_ONLY` flag. That way it will be notfied once
+    // `nsIAsyncOutputStream` is closed.
+    asyncOutputStream.asyncWait(OutputStreamCallback(this),
+                                asyncOutputStream.WAIT_CLOSURE_ONLY,
+                                0,
+                                threadManager.currentThread);
+
+    nsIRequestObserver(this, requestObserver);
     nsIAsyncOutputStream(this, asyncOutputStream);
+    nsIMultiplexInputStream(this, multiplexInputStream);
+    nsIAsyncStreamCopier(this, asyncStreamCopier);
+
+    this.asyncOutputStream = asyncOutputStream;
+    this.multiplexInputStream = multiplexInputStream;
+    this.asyncStreamCopier = asyncStreamCopier;
   },
   write: function write(content, encoding, callback) {
-    let output = nsIOutputStream(this);
-    let asyncOutputStream = nsIAsyncOutputStream(this);
-
     if (isFunction(encoding)) {
       callback = encoding;
       encoding = callback;
     }
 
-    // Flag indicating whether or not content has been flushed to the kernel
-    // buffer.
-    let isWritten = false;
     // If stream is not writable we throw an error.
-    if (!this.writable)
-      throw Error("stream not writable");
+    if (!this.writable) throw Error("stream is not writable");
+
+    let chunk = null;
 
-    try {
-      // If content is not a buffer then we create one out of it.
-      if (!Buffer.isBuffer(content))
-        content = new Buffer(content, encoding);
+    // If content is not a buffer then we create one out of it.
+    if (Buffer.isBuffer(content)) {
+      chunk = new ArrayBufferInputStream();
+      chunk.setData(content.buffer, 0, content.length);
+    }
+    else {
+      chunk = new StringInputStream();
+      chunk.setData(content, content.length);
+    }
 
-      // We write content as a byte array as this will avoid any transcoding
-      // if content was a buffer.
-      output.writeByteArray(content.valueOf(), content.length);
-      output.flush();
+    if (callback)
+      this.once("drain", callback);
+
+    // Queue up chunk to be copied to output sync.
+    nsIMultiplexInputStream(this).appendStream(chunk);
+    this.flush();
 
-      if (callback) this.once("drain", callback);
-      onStateChange(asyncOutputStream, this);
-      return true;
-    } catch (error) {
-      // If errors occur we emit appropriate event.
-      emit(this, "error", error);
+    return this.drained;
+  },
+  flush: function() {
+    if (this.drained) {
+      this.drained = false;
+      nsIAsyncStreamCopier(this).asyncCopy(nsIRequestObserver(this), null);
     }
   },
-  flush: function flush() {
-    nsIOutputStream(this).flush();
-  },
   end: function end(content, encoding, callback) {
     if (isFunction(content)) {
       callback = content
       content = callback
     }
     if (isFunction(encoding)) {
       callback = encoding
       encoding = callback
     }
 
-    // Setting a listener to "close" event if passed.
+    // Setting a listener to "finish" event if passed.
     if (isFunction(callback))
-      this.once("close", callback);
+      this.once("finish", callback);
 
-    // If content is passed then we defer closing until we finish with writing.
+
     if (content)
-      this.write(content, encoding, end.bind(this));
-    // If we don"t write anything, then we close an outputStream.
-    else
-      nsIOutputStream(this).close();
+      this.write(content, encoding);
+    this.writable = false;
+
+    // Close `asyncOutputStream` only if output has drained. If it's
+    // not drained than `asyncStreamCopier` is busy writing, so let
+    // it finish. Note that since `this.writable` is false copier will
+    // close `asyncOutputStream` once output drains.
+    if (this.drained)
+      nsIAsyncOutputStream(this).close();
   },
-  destroy: function destroy(callback) {
-    try {
-      this.end(callback);
-      nsIOutputStream(this, null);
-      nsIAsyncOutputStream(this, null);
-    } catch (error) {
-      emit(this, "error", error);
-    }
+  destroy: function destroy() {
+    nsIAsyncOutputStream(this).close();
+    nsIAsyncOutputStream(this);
+    nsIMultiplexInputStream(this);
+    nsIAsyncStreamCopier(this);
+    nsIRequestObserver(this);
   }
 });
 exports.OutputStream = OutputStream;
 
 const DuplexStream = Class({
   extends: Stream,
+  implements: [InputStream, OutputStream],
+  allowHalfOpen: true,
   initialize: function initialize(options) {
-    let { input, output, pump } = options;
+    options = options || {};
+    let { readable, writable, allowHalfOpen } = options;
+
+    InputStream.prototype.initialize.call(this, options);
+    OutputStream.prototype.initialize.call(this, options);
+
+    if (readable === false)
+      this.readable = false;
 
-    this.writable = true;
-    this.readable = true;
-    this.encoding = null;
+    if (writable === false)
+      this.writable = false;
+
+    if (allowHalfOpen === false)
+      this.allowHalfOpen = false;
 
-    nsIInputStream(this, input);
-    nsIOutputStream(this, output);
-    nsIInputStreamPump(this, pump);
+    // If in a half open state and it's disabled enforce end.
+    this.once("end", () => {
+      if (!this.allowHalfOpen && (!this.readable || !this.writable))
+        this.end();
+    });
   },
-  read: InputStream.prototype.read,
-  pause: InputStream.prototype.pause,
-  resume: InputStream.prototype.resume,
-
-  write: OutputStream.prototype.write,
-  flush: OutputStream.prototype.flush,
-  end: OutputStream.prototype.end,
-
   destroy: function destroy(error) {
-    if (error)
-      emit(this, "error", error);
     InputStream.prototype.destroy.call(this);
     OutputStream.prototype.destroy.call(this);
   }
 });
 exports.DuplexStream = DuplexStream;

--- a/addon-sdk/source/lib/sdk/lang/functional.js
+++ b/addon-sdk/source/lib/sdk/lang/functional.js
@@ -7,17 +7,17 @@
 // those goes to him.
 
 "use strict";
 
 module.metadata = {
   "stability": "unstable"
 };
 
-const { setTimeout } = require("../timers");
+const { setImmediate, setTimeout } = require("../timers");
 const { deprecateFunction } = require("../util/deprecate");
 
 /**
  * Takes `lambda` function and returns a method. When returned method is
  * invoked it calls wrapped `lambda` and passes `this` as a first argument
  * and given argument as rest.
  */
 function method(lambda) {
@@ -25,23 +25,22 @@ function method(lambda) {
     return lambda.apply(null, [this].concat(Array.slice(arguments)));
   }
 }
 exports.method = method;
 
 /**
  * Takes a function and returns a wrapped one instead, calling which will call
  * original function in the next turn of event loop. This is basically utility
- * to do `setTimeout(function() { ... }, 0)`, with a difference that returned
+ * to do `setImmediate(function() { ... })`, with a difference that returned
  * function is reused, instead of creating a new one each time. This also allows
  * to use this functions as event listeners.
  */
 function defer(f) {
-  return function deferred()
-    setTimeout(invoke, 0, f, arguments, this);
+  return function deferred() setImmediate(invoke, f, arguments, this);
 }
 exports.defer = defer;
 // Exporting `remit` alias as `defer` may conflict with promises.
 exports.remit = defer;
 
 /*
  * Takes a funtion and returns a wrapped function that returns `this`
  */