Add m-esr52 at 52.6.0

327 files changed, 17433 insertions, 0 deletions

diff --git a/dom/browser-element/BrowserElementAudioChannel.cpp b/dom/browser-element/BrowserElementAudioChannel.cpp
new file mode 100644
index 000000000..c9c29e2ea
--- /dev/null
+++ b/dom/browser-element/BrowserElementAudioChannel.cpp
@@ -0,0 +1,591 @@
+/* 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/. */
+
+#include "BrowserElementAudioChannel.h"
+
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "mozilla/dom/BrowserElementAudioChannelBinding.h"
+#include "mozilla/dom/DOMRequest.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "AudioChannelService.h"
+#include "nsContentUtils.h"
+#include "nsIBrowserElementAPI.h"
+#include "nsIDocShell.h"
+#include "nsIDOMDOMRequest.h"
+#include "nsIObserverService.h"
+#include "nsISupportsPrimitives.h"
+#include "nsITabParent.h"
+#include "nsPIDOMWindow.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ADDREF_INHERITED(BrowserElementAudioChannel, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(BrowserElementAudioChannel, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(BrowserElementAudioChannel)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(BrowserElementAudioChannel,
+                                   DOMEventTargetHelper,
+                                   mFrameLoader,
+                                   mFrameWindow,
+                                   mTabParent,
+                                   mBrowserElementAPI)
+
+/* static */ already_AddRefed<BrowserElementAudioChannel>
+BrowserElementAudioChannel::Create(nsPIDOMWindowInner* aWindow,
+                                   nsIFrameLoader* aFrameLoader,
+                                   nsIBrowserElementAPI* aAPI,
+                                   AudioChannel aAudioChannel,
+                                   ErrorResult& aRv)
+{
+  RefPtr<BrowserElementAudioChannel> ac =
+    new BrowserElementAudioChannel(aWindow, aFrameLoader, aAPI, aAudioChannel);
+
+  aRv = ac->Initialize();
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
+         ("BrowserElementAudioChannel, Create, channel = %p, type = %d\n",
+          ac.get(), aAudioChannel));
+
+  return ac.forget();
+}
+
+BrowserElementAudioChannel::BrowserElementAudioChannel(
+						nsPIDOMWindowInner* aWindow,
+						nsIFrameLoader* aFrameLoader,
+                                                nsIBrowserElementAPI* aAPI,
+                                                AudioChannel aAudioChannel)
+  : DOMEventTargetHelper(aWindow)
+  , mFrameLoader(aFrameLoader)
+  , mBrowserElementAPI(aAPI)
+  , mAudioChannel(aAudioChannel)
+  , mState(eStateUnknown)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    nsAutoString name;
+    AudioChannelService::GetAudioChannelString(aAudioChannel, name);
+
+    nsAutoCString topic;
+    topic.Assign("audiochannel-activity-");
+    topic.Append(NS_ConvertUTF16toUTF8(name));
+
+    obs->AddObserver(this, topic.get(), true);
+  }
+}
+
+BrowserElementAudioChannel::~BrowserElementAudioChannel()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    nsAutoString name;
+    AudioChannelService::GetAudioChannelString(mAudioChannel, name);
+
+    nsAutoCString topic;
+    topic.Assign("audiochannel-activity-");
+    topic.Append(NS_ConvertUTF16toUTF8(name));
+
+    obs->RemoveObserver(this, topic.get());
+  }
+}
+
+nsresult
+BrowserElementAudioChannel::Initialize()
+{
+  if (!mFrameLoader) {
+    nsCOMPtr<nsPIDOMWindowInner> window = GetOwner();
+    if (!window) {
+      return NS_ERROR_FAILURE;
+    }
+
+    mFrameWindow = window->GetScriptableTop();
+    mFrameWindow = mFrameWindow->GetOuterWindow();
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell;
+  nsresult rv = mFrameLoader->GetDocShell(getter_AddRefs(docShell));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (docShell) {
+    nsCOMPtr<nsPIDOMWindowOuter> window = docShell->GetWindow();
+    if (!window) {
+      return NS_ERROR_FAILURE;
+    }
+
+    mFrameWindow = window->GetScriptableTop();
+    mFrameWindow = mFrameWindow->GetOuterWindow();
+    return NS_OK;
+  }
+
+  rv = mFrameLoader->GetTabParent(getter_AddRefs(mTabParent));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  MOZ_ASSERT(mTabParent);
+  return NS_OK;
+}
+
+JSObject*
+BrowserElementAudioChannel::WrapObject(JSContext *aCx,
+                                       JS::Handle<JSObject*> aGivenProto)
+{
+  return BrowserElementAudioChannelBinding::Wrap(aCx, this, aGivenProto);
+}
+
+AudioChannel
+BrowserElementAudioChannel::Name() const
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  return mAudioChannel;
+}
+
+namespace {
+
+class BaseRunnable : public Runnable
+{
+protected:
+  nsCOMPtr<nsPIDOMWindowInner> mParentWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> mFrameWindow;
+  RefPtr<DOMRequest> mRequest;
+  AudioChannel mAudioChannel;
+
+  virtual void DoWork(AudioChannelService* aService,
+                      JSContext* aCx) = 0;
+
+public:
+  BaseRunnable(nsPIDOMWindowInner* aParentWindow,
+	       nsPIDOMWindowOuter* aFrameWindow,
+               DOMRequest* aRequest, AudioChannel aAudioChannel)
+    : mParentWindow(aParentWindow)
+    , mFrameWindow(aFrameWindow)
+    , mRequest(aRequest)
+    , mAudioChannel(aAudioChannel)
+  {}
+
+  NS_IMETHOD Run() override
+  {
+    RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+    if (!service) {
+      return NS_OK;
+    }
+
+    AutoJSAPI jsapi;
+    if (!jsapi.Init(mParentWindow)) {
+      mRequest->FireError(NS_ERROR_FAILURE);
+      return NS_OK;
+    }
+
+    DoWork(service, jsapi.cx());
+    return NS_OK;
+  }
+};
+
+class GetVolumeRunnable final : public BaseRunnable
+{
+public:
+  GetVolumeRunnable(nsPIDOMWindowInner* aParentWindow,
+		    nsPIDOMWindowOuter* aFrameWindow,
+                    DOMRequest* aRequest, AudioChannel aAudioChannel)
+    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
+  {}
+
+protected:
+  virtual void DoWork(AudioChannelService* aService, JSContext* aCx) override
+  {
+    float volume = aService->GetAudioChannelVolume(mFrameWindow, mAudioChannel);
+
+    JS::Rooted<JS::Value> value(aCx);
+    if (!ToJSValue(aCx, volume, &value)) {
+      mRequest->FireError(NS_ERROR_FAILURE);
+      return;
+    }
+
+    mRequest->FireSuccess(value);
+  }
+};
+
+class GetMutedRunnable final : public BaseRunnable
+{
+public:
+  GetMutedRunnable(nsPIDOMWindowInner* aParentWindow,
+		   nsPIDOMWindowOuter* aFrameWindow,
+                   DOMRequest* aRequest, AudioChannel aAudioChannel)
+    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
+  {}
+
+protected:
+  virtual void DoWork(AudioChannelService* aService, JSContext* aCx) override
+  {
+    bool muted = aService->GetAudioChannelMuted(mFrameWindow, mAudioChannel);
+
+    JS::Rooted<JS::Value> value(aCx);
+    if (!ToJSValue(aCx, muted, &value)) {
+      mRequest->FireError(NS_ERROR_FAILURE);
+      return;
+    }
+
+    mRequest->FireSuccess(value);
+  }
+};
+
+class IsActiveRunnable final : public BaseRunnable
+{
+  bool mActive;
+  bool mValueKnown;
+
+public:
+  IsActiveRunnable(nsPIDOMWindowInner* aParentWindow,
+		   nsPIDOMWindowOuter* aFrameWindow,
+                   DOMRequest* aRequest, AudioChannel aAudioChannel,
+                   bool aActive)
+    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
+    , mActive(aActive)
+    , mValueKnown(true)
+  {}
+
+  IsActiveRunnable(nsPIDOMWindowInner* aParentWindow,
+		   nsPIDOMWindowOuter* aFrameWindow,
+                   DOMRequest* aRequest, AudioChannel aAudioChannel)
+    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
+    , mActive(true)
+    , mValueKnown(false)
+  {}
+
+protected:
+  virtual void DoWork(AudioChannelService* aService, JSContext* aCx) override
+  {
+    if (!mValueKnown) {
+      mActive = aService->IsAudioChannelActive(mFrameWindow, mAudioChannel);
+    }
+
+    JS::Rooted<JS::Value> value(aCx);
+    if (!ToJSValue(aCx, mActive, &value)) {
+      mRequest->FireError(NS_ERROR_FAILURE);
+      return;
+    }
+
+    mRequest->FireSuccess(value);
+  }
+};
+
+class FireSuccessRunnable final : public BaseRunnable
+{
+public:
+  FireSuccessRunnable(nsPIDOMWindowInner* aParentWindow,
+		      nsPIDOMWindowOuter* aFrameWindow,
+                      DOMRequest* aRequest, AudioChannel aAudioChannel)
+    : BaseRunnable(aParentWindow, aFrameWindow, aRequest, aAudioChannel)
+  {}
+
+protected:
+  virtual void DoWork(AudioChannelService* aService, JSContext* aCx) override
+  {
+    JS::Rooted<JS::Value> value(aCx);
+    mRequest->FireSuccess(value);
+  }
+};
+
+} // anonymous namespace
+
+already_AddRefed<dom::DOMRequest>
+BrowserElementAudioChannel::GetVolume(ErrorResult& aRv)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mFrameWindow) {
+    nsCOMPtr<nsIDOMDOMRequest> request;
+    aRv = mBrowserElementAPI->GetAudioChannelVolume((uint32_t)mAudioChannel,
+                                                    getter_AddRefs(request));
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    return request.forget().downcast<DOMRequest>();
+  }
+
+  RefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
+
+  nsCOMPtr<nsIRunnable> runnable =
+    new GetVolumeRunnable(GetOwner(), mFrameWindow, domRequest, mAudioChannel);
+  NS_DispatchToMainThread(runnable);
+
+  return domRequest.forget();
+}
+
+already_AddRefed<dom::DOMRequest>
+BrowserElementAudioChannel::SetVolume(float aVolume, ErrorResult& aRv)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mFrameWindow) {
+    nsCOMPtr<nsIDOMDOMRequest> request;
+    aRv = mBrowserElementAPI->SetAudioChannelVolume((uint32_t)mAudioChannel,
+                                                    aVolume,
+                                                    getter_AddRefs(request));
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    return request.forget().downcast<DOMRequest>();
+  }
+
+  RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+  if (service) {
+    service->SetAudioChannelVolume(mFrameWindow, mAudioChannel, aVolume);
+  }
+
+  RefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
+  nsCOMPtr<nsIRunnable> runnable = new FireSuccessRunnable(GetOwner(),
+                                                           mFrameWindow,
+                                                           domRequest,
+                                                           mAudioChannel);
+  NS_DispatchToMainThread(runnable);
+
+  return domRequest.forget();
+}
+
+already_AddRefed<dom::DOMRequest>
+BrowserElementAudioChannel::GetMuted(ErrorResult& aRv)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mFrameWindow) {
+    nsCOMPtr<nsIDOMDOMRequest> request;
+    aRv = mBrowserElementAPI->GetAudioChannelMuted((uint32_t)mAudioChannel,
+                                                   getter_AddRefs(request));
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    return request.forget().downcast<DOMRequest>();
+  }
+
+  RefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
+
+  nsCOMPtr<nsIRunnable> runnable =
+    new GetMutedRunnable(GetOwner(), mFrameWindow, domRequest, mAudioChannel);
+  NS_DispatchToMainThread(runnable);
+
+  return domRequest.forget();
+}
+
+already_AddRefed<dom::DOMRequest>
+BrowserElementAudioChannel::SetMuted(bool aMuted, ErrorResult& aRv)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mFrameWindow) {
+    nsCOMPtr<nsIDOMDOMRequest> request;
+    aRv = mBrowserElementAPI->SetAudioChannelMuted((uint32_t)mAudioChannel,
+                                                   aMuted,
+                                                   getter_AddRefs(request));
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    return request.forget().downcast<DOMRequest>();
+  }
+
+  RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
+  if (service) {
+    service->SetAudioChannelMuted(mFrameWindow, mAudioChannel, aMuted);
+  }
+
+  RefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
+  nsCOMPtr<nsIRunnable> runnable = new FireSuccessRunnable(GetOwner(),
+                                                           mFrameWindow,
+                                                           domRequest,
+                                                           mAudioChannel);
+  NS_DispatchToMainThread(runnable);
+
+  return domRequest.forget();
+}
+
+already_AddRefed<dom::DOMRequest>
+BrowserElementAudioChannel::IsActive(ErrorResult& aRv)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mState != eStateUnknown) {
+    RefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
+
+    nsCOMPtr<nsIRunnable> runnable =
+      new IsActiveRunnable(GetOwner(), mFrameWindow, domRequest, mAudioChannel,
+                           mState == eStateActive);
+    NS_DispatchToMainThread(runnable);
+
+    return domRequest.forget();
+  }
+
+  if (!mFrameWindow) {
+    nsCOMPtr<nsIDOMDOMRequest> request;
+    aRv = mBrowserElementAPI->IsAudioChannelActive((uint32_t)mAudioChannel,
+                                                   getter_AddRefs(request));
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    return request.forget().downcast<DOMRequest>();
+  }
+
+  RefPtr<DOMRequest> domRequest = new DOMRequest(GetOwner());
+
+  nsCOMPtr<nsIRunnable> runnable =
+    new IsActiveRunnable(GetOwner(), mFrameWindow, domRequest, mAudioChannel);
+  NS_DispatchToMainThread(runnable);
+
+  return domRequest.forget();
+}
+
+NS_IMETHODIMP
+BrowserElementAudioChannel::Observe(nsISupports* aSubject, const char* aTopic,
+                                    const char16_t* aData)
+{
+  nsAutoString name;
+  AudioChannelService::GetAudioChannelString(mAudioChannel, name);
+
+  nsAutoCString topic;
+  topic.Assign("audiochannel-activity-");
+  topic.Append(NS_ConvertUTF16toUTF8(name));
+
+  if (strcmp(topic.get(), aTopic)) {
+    return NS_OK;
+  }
+
+  // Message received from the child.
+  if (!mFrameWindow) {
+    if (mTabParent == aSubject) {
+      ProcessStateChanged(aData);
+    }
+
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsISupportsPRUint64> wrapper = do_QueryInterface(aSubject);
+  if (!wrapper) {
+    bool isNested = false;
+    nsresult rv = IsFromNestedFrame(aSubject, isNested);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    if (isNested) {
+      ProcessStateChanged(aData);
+    }
+
+    return NS_OK;
+  }
+
+  uint64_t windowID;
+  nsresult rv = wrapper->GetData(&windowID);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (windowID != mFrameWindow->WindowID()) {
+    return NS_OK;
+  }
+
+  ProcessStateChanged(aData);
+  return NS_OK;
+}
+
+void
+BrowserElementAudioChannel::ProcessStateChanged(const char16_t* aData)
+{
+  MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
+         ("BrowserElementAudioChannel, ProcessStateChanged, this = %p, "
+          "type = %d\n", this, mAudioChannel));
+
+  nsAutoString value(aData);
+  mState = value.EqualsASCII("active") ? eStateActive : eStateInactive;
+  DispatchTrustedEvent(NS_LITERAL_STRING("activestatechanged"));
+}
+
+bool
+BrowserElementAudioChannel::IsSystemAppWindow(nsPIDOMWindowOuter* aWindow) const
+{
+  nsCOMPtr<nsIDocument> doc = aWindow->GetExtantDoc();
+  if (!doc) {
+    return false;
+  }
+
+  if (nsContentUtils::IsChromeDoc(doc)) {
+    return true;
+  }
+
+  nsAdoptingCString systemAppUrl =
+    mozilla::Preferences::GetCString("b2g.system_startup_url");
+  if (!systemAppUrl) {
+    return false;
+  }
+
+  nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal();
+  nsCOMPtr<nsIURI> uri;
+  principal->GetURI(getter_AddRefs(uri));
+
+  if (uri) {
+    nsAutoCString spec;
+    uri->GetSpec(spec);
+
+    if (spec.Equals(systemAppUrl)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+nsresult
+BrowserElementAudioChannel::IsFromNestedFrame(nsISupports* aSubject,
+                                              bool& aIsNested) const
+{
+  aIsNested = false;
+  nsCOMPtr<nsITabParent> iTabParent = do_QueryInterface(aSubject);
+  if (!iTabParent) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<TabParent> tabParent = TabParent::GetFrom(iTabParent);
+  if (!tabParent) {
+    return NS_ERROR_FAILURE;
+  }
+
+  Element* element = tabParent->GetOwnerElement();
+  if (!element) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Since the normal OOP processes are opened out from b2g process, the owner
+  // of their tabParent are the same - system app window. Therefore, in order
+  // to find the case of nested MozFrame, we need to exclude this situation.
+  nsCOMPtr<nsPIDOMWindowOuter> window = element->OwnerDoc()->GetWindow();
+  if (window == mFrameWindow && !IsSystemAppWindow(window)) {
+    aIsNested = true;
+    return NS_OK;
+  }
+
+  return NS_OK;
+}
+
+} // dom namespace
+} // mozilla namespace
diff --git a/dom/browser-element/BrowserElementAudioChannel.h b/dom/browser-element/BrowserElementAudioChannel.h
new file mode 100644
index 000000000..237e5edc8
--- /dev/null
+++ b/dom/browser-element/BrowserElementAudioChannel.h
@@ -0,0 +1,97 @@
+/* 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_dom_BrowserElementAudioChannels_h
+#define mozilla_dom_BrowserElementAudioChannels_h
+
+#include "mozilla/dom/AudioChannelBinding.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/ErrorResult.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIObserver.h"
+#include "nsIFrameLoader.h"
+#include "nsWeakReference.h"
+#include "nsWrapperCache.h"
+
+class nsIBrowserElementAPI;
+class nsITabParent;
+class nsPIDOMWindowOuter;
+
+namespace mozilla {
+namespace dom {
+
+class DOMRequest;
+
+class BrowserElementAudioChannel final : public DOMEventTargetHelper
+                                       , public nsSupportsWeakReference
+                                       , public nsIObserver
+{
+public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIOBSERVER
+
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(BrowserElementAudioChannel,
+                                           DOMEventTargetHelper)
+
+  static already_AddRefed<BrowserElementAudioChannel>
+  Create(nsPIDOMWindowInner* aWindow,
+         nsIFrameLoader* aFrameLoader,
+         nsIBrowserElementAPI* aAPI,
+         AudioChannel aAudioChannel,
+         ErrorResult& aRv);
+
+  // WebIDL methods
+
+  virtual JSObject* WrapObject(JSContext *aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  AudioChannel Name() const;
+
+  already_AddRefed<dom::DOMRequest> GetVolume(ErrorResult& aRv);
+  already_AddRefed<dom::DOMRequest> SetVolume(float aVolume, ErrorResult& aRv);
+
+  already_AddRefed<dom::DOMRequest> GetMuted(ErrorResult& aRv);
+  already_AddRefed<dom::DOMRequest> SetMuted(bool aMuted, ErrorResult& aRv);
+
+  already_AddRefed<dom::DOMRequest> IsActive(ErrorResult& aRv);
+
+  IMPL_EVENT_HANDLER(activestatechanged);
+
+private:
+  BrowserElementAudioChannel(nsPIDOMWindowInner* aWindow,
+                             nsIFrameLoader* aFrameLoader,
+                             nsIBrowserElementAPI* aAPI,
+                             AudioChannel aAudioChannel);
+
+  bool IsSystemAppWindow(nsPIDOMWindowOuter* aWindow) const;
+
+  // This method is used to check whether we're in the nested-mozbrower-frame
+  // situation, see bug1214148.
+  nsresult IsFromNestedFrame(nsISupports* aSubject,
+                             bool& aIsNested) const;
+
+  ~BrowserElementAudioChannel();
+
+  nsresult Initialize();
+
+  void ProcessStateChanged(const char16_t* aData);
+
+  nsCOMPtr<nsIFrameLoader> mFrameLoader;
+  nsCOMPtr<nsIBrowserElementAPI> mBrowserElementAPI;
+  nsCOMPtr<nsITabParent> mTabParent;
+  nsCOMPtr<nsPIDOMWindowOuter> mFrameWindow;
+  AudioChannel mAudioChannel;
+
+  enum {
+    eStateActive,
+    eStateInactive,
+    eStateUnknown
+  } mState;
+};
+
+} // dom namespace
+} // mozilla namespace
+
+#endif // mozilla_dom_BrowserElementAudioChannels_h
diff --git a/dom/browser-element/BrowserElementChild.js b/dom/browser-element/BrowserElementChild.js
new file mode 100644
index 000000000..066be66d2
--- /dev/null
+++ b/dom/browser-element/BrowserElementChild.js
@@ -0,0 +1,83 @@
+/* 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";
+
+var { classes: Cc, interfaces: Ci, results: Cr, utils: Cu }  = Components;
+Cu.import("resource://gre/modules/Services.jsm");
+
+function debug(msg) {
+  //dump("BrowserElementChild - " + msg + "\n");
+}
+
+// NB: this must happen before we process any messages from
+// mozbrowser API clients.
+docShell.isActive = true;
+
+function parentDocShell(docshell) {
+  if (!docshell) {
+    return null;
+  }
+  let treeitem = docshell.QueryInterface(Ci.nsIDocShellTreeItem);
+  return treeitem.parent ? treeitem.parent.QueryInterface(Ci.nsIDocShell) : null;
+}
+
+function isTopBrowserElement(docShell) {
+  while (docShell) {
+    docShell = parentDocShell(docShell);
+    if (docShell && docShell.isMozBrowserOrApp) {
+      return false;
+    }
+  }
+  return true;
+}
+
+var BrowserElementIsReady;
+
+debug(`Might load BE scripts: BEIR: ${BrowserElementIsReady}`);
+if (!BrowserElementIsReady) {
+  debug("Loading BE scripts")
+  if (!("BrowserElementIsPreloaded" in this)) {
+    if (isTopBrowserElement(docShell)) {
+      if (Services.prefs.getBoolPref("dom.mozInputMethod.enabled")) {
+        try {
+          Services.scriptloader.loadSubScript("chrome://global/content/forms.js");
+        } catch (e) {
+        }
+      }
+    }
+
+    if(Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT) {
+      // general content apps
+      if (isTopBrowserElement(docShell)) {
+        Services.scriptloader.loadSubScript("chrome://global/content/BrowserElementCopyPaste.js");
+      }
+    } else {
+      // rocketbar in system app and other in-process case (ex. B2G desktop client)
+      Services.scriptloader.loadSubScript("chrome://global/content/BrowserElementCopyPaste.js");
+    }
+
+    Services.scriptloader.loadSubScript("chrome://global/content/BrowserElementChildPreload.js");
+  }
+
+  function onDestroy() {
+    removeMessageListener("browser-element-api:destroy", onDestroy);
+
+    if (api) {
+      api.destroy();
+    }
+    if ("CopyPasteAssistent" in this) {
+      CopyPasteAssistent.destroy();
+    }
+
+    BrowserElementIsReady = false;
+  }
+  addMessageListener("browser-element-api:destroy", onDestroy);
+
+  BrowserElementIsReady = true;
+} else {
+  debug("BE already loaded, abort");
+}
+
+sendAsyncMessage('browser-element-api:call', { 'msg_name': 'hello' });
diff --git a/dom/browser-element/BrowserElementChildPreload.js b/dom/browser-element/BrowserElementChildPreload.js
new file mode 100644
index 000000000..780dfa80e
--- /dev/null
+++ b/dom/browser-element/BrowserElementChildPreload.js
@@ -0,0 +1,1823 @@
+/* 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";
+
+function debug(msg) {
+  // dump("BrowserElementChildPreload - " + msg + "\n");
+}
+
+debug("loaded");
+
+var BrowserElementIsReady;
+
+var { classes: Cc, interfaces: Ci, results: Cr, utils: Cu }  = Components;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/BrowserElementPromptService.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/ExtensionContent.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "acs",
+                                   "@mozilla.org/audiochannel/service;1",
+                                   "nsIAudioChannelService");
+XPCOMUtils.defineLazyModuleGetter(this, "ManifestFinder",
+                                  "resource://gre/modules/ManifestFinder.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ManifestObtainer",
+                                  "resource://gre/modules/ManifestObtainer.jsm");
+
+
+var kLongestReturnedString = 128;
+
+var Timer = Components.Constructor("@mozilla.org/timer;1",
+                                   "nsITimer",
+                                   "initWithCallback");
+
+function sendAsyncMsg(msg, data) {
+  // Ensure that we don't send any messages before BrowserElementChild.js
+  // finishes loading.
+  if (!BrowserElementIsReady) {
+    return;
+  }
+
+  if (!data) {
+    data = { };
+  }
+
+  data.msg_name = msg;
+  sendAsyncMessage('browser-element-api:call', data);
+}
+
+function sendSyncMsg(msg, data) {
+  // Ensure that we don't send any messages before BrowserElementChild.js
+  // finishes loading.
+  if (!BrowserElementIsReady) {
+    return;
+  }
+
+  if (!data) {
+    data = { };
+  }
+
+  data.msg_name = msg;
+  return sendSyncMessage('browser-element-api:call', data);
+}
+
+var CERTIFICATE_ERROR_PAGE_PREF = 'security.alternate_certificate_error_page';
+
+var OBSERVED_EVENTS = [
+  'xpcom-shutdown',
+  'audio-playback',
+  'activity-done',
+  'will-launch-app'
+];
+
+var LISTENED_EVENTS = [
+  { type: "DOMTitleChanged", useCapture: true, wantsUntrusted: false },
+  { type: "DOMLinkAdded", useCapture: true, wantsUntrusted: false },
+  { type: "MozScrolledAreaChanged", useCapture: true, wantsUntrusted: false },
+  { type: "MozDOMFullscreen:Request", useCapture: true, wantsUntrusted: false },
+  { type: "MozDOMFullscreen:NewOrigin", useCapture: true, wantsUntrusted: false },
+  { type: "MozDOMFullscreen:Exit", useCapture: true, wantsUntrusted: false },
+  { type: "DOMMetaAdded", useCapture: true, wantsUntrusted: false },
+  { type: "DOMMetaChanged", useCapture: true, wantsUntrusted: false },
+  { type: "DOMMetaRemoved", useCapture: true, wantsUntrusted: false },
+  { type: "scrollviewchange", useCapture: true, wantsUntrusted: false },
+  { type: "click", useCapture: false, wantsUntrusted: false },
+  // This listens to unload events from our message manager, but /not/ from
+  // the |content| window.  That's because the window's unload event doesn't
+  // bubble, and we're not using a capturing listener.  If we'd used
+  // useCapture == true, we /would/ hear unload events from the window, which
+  // is not what we want!
+  { type: "unload", useCapture: false, wantsUntrusted: false },
+];
+
+// We are using the system group for those events so if something in the
+// content called .stopPropagation() this will still be called.
+var LISTENED_SYSTEM_EVENTS = [
+  { type: "DOMWindowClose", useCapture: false },
+  { type: "DOMWindowCreated", useCapture: false },
+  { type: "DOMWindowResize", useCapture: false },
+  { type: "contextmenu", useCapture: false },
+  { type: "scroll", useCapture: false },
+];
+
+/**
+ * The BrowserElementChild implements one half of <iframe mozbrowser>.
+ * (The other half is, unsurprisingly, BrowserElementParent.)
+ *
+ * This script is injected into an <iframe mozbrowser> via
+ * nsIMessageManager::LoadFrameScript().
+ *
+ * Our job here is to listen for events within this frame and bubble them up to
+ * the parent process.
+ */
+
+var global = this;
+
+function BrowserElementProxyForwarder() {
+}
+
+BrowserElementProxyForwarder.prototype = {
+  init: function() {
+    Services.obs.addObserver(this, "browser-element-api:proxy-call", false);
+    addMessageListener("browser-element-api:proxy", this);
+  },
+
+  uninit: function() {
+    Services.obs.removeObserver(this, "browser-element-api:proxy-call", false);
+    removeMessageListener("browser-element-api:proxy", this);
+  },
+
+  // Observer callback receives messages from BrowserElementProxy.js
+  observe: function(subject, topic, stringifedData) {
+    if (subject !== content) {
+      return;
+    }
+
+    // Forward it to BrowserElementParent.js
+    sendAsyncMessage(topic, JSON.parse(stringifedData));
+  },
+
+  // Message manager callback receives messages from BrowserElementParent.js
+  receiveMessage: function(mmMsg) {
+    // Forward it to BrowserElementProxy.js
+    Services.obs.notifyObservers(
+      content, mmMsg.name, JSON.stringify(mmMsg.json));
+  }
+};
+
+function BrowserElementChild() {
+  // Maps outer window id --> weak ref to window.  Used by modal dialog code.
+  this._windowIDDict = {};
+
+  // _forcedVisible corresponds to the visibility state our owner has set on us
+  // (via iframe.setVisible).  ownerVisible corresponds to whether the docShell
+  // whose window owns this element is visible.
+  //
+  // Our docShell is visible iff _forcedVisible and _ownerVisible are both
+  // true.
+  this._forcedVisible = true;
+  this._ownerVisible = true;
+
+  this._nextPaintHandler = null;
+
+  this._isContentWindowCreated = false;
+  this._pendingSetInputMethodActive = [];
+
+  this.forwarder = new BrowserElementProxyForwarder();
+
+  this._init();
+};
+
+BrowserElementChild.prototype = {
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver,
+                                         Ci.nsISupportsWeakReference]),
+
+  _init: function() {
+    debug("Starting up.");
+
+    BrowserElementPromptService.mapWindowToBrowserElementChild(content, this);
+
+    docShell.QueryInterface(Ci.nsIWebProgress)
+            .addProgressListener(this._progressListener,
+                                 Ci.nsIWebProgress.NOTIFY_LOCATION |
+                                 Ci.nsIWebProgress.NOTIFY_SECURITY |
+                                 Ci.nsIWebProgress.NOTIFY_STATE_WINDOW);
+
+    let webNavigation = docShell.QueryInterface(Ci.nsIWebNavigation);
+    if (!webNavigation.sessionHistory) {
+      webNavigation.sessionHistory = Cc["@mozilla.org/browser/shistory;1"]
+                                       .createInstance(Ci.nsISHistory);
+    }
+
+    // This is necessary to get security web progress notifications.
+    var securityUI = Cc['@mozilla.org/secure_browser_ui;1']
+                       .createInstance(Ci.nsISecureBrowserUI);
+    securityUI.init(content);
+
+    // A cache of the menuitem dom objects keyed by the id we generate
+    // and pass to the embedder
+    this._ctxHandlers = {};
+    // Counter of contextmenu events fired
+    this._ctxCounter = 0;
+
+    this._shuttingDown = false;
+
+    LISTENED_EVENTS.forEach(event => {
+      addEventListener(event.type, this, event.useCapture, event.wantsUntrusted);
+    });
+
+    // Registers a MozAfterPaint handler for the very first paint.
+    this._addMozAfterPaintHandler(function () {
+      sendAsyncMsg('firstpaint');
+    });
+
+    addMessageListener("browser-element-api:call", this);
+
+    let els = Cc["@mozilla.org/eventlistenerservice;1"]
+                .getService(Ci.nsIEventListenerService);
+    LISTENED_SYSTEM_EVENTS.forEach(event => {
+      els.addSystemEventListener(global, event.type, this, event.useCapture);
+    });
+
+    OBSERVED_EVENTS.forEach((aTopic) => {
+      Services.obs.addObserver(this, aTopic, false);
+    });
+
+    this.forwarder.init();
+  },
+
+  /**
+   * Shut down the frame's side of the browser API.  This is called when:
+   *   - our TabChildGlobal starts to die
+   *   - the content is moved to frame without the browser API
+   * This is not called when the page inside |content| unloads.
+   */
+  destroy: function() {
+    debug("Destroying");
+    this._shuttingDown = true;
+
+    BrowserElementPromptService.unmapWindowToBrowserElementChild(content);
+
+    docShell.QueryInterface(Ci.nsIWebProgress)
+            .removeProgressListener(this._progressListener);
+
+    LISTENED_EVENTS.forEach(event => {
+      removeEventListener(event.type, this, event.useCapture, event.wantsUntrusted);
+    });
+
+    this._deactivateNextPaintListener();
+
+    removeMessageListener("browser-element-api:call", this);
+
+    let els = Cc["@mozilla.org/eventlistenerservice;1"]
+                .getService(Ci.nsIEventListenerService);
+    LISTENED_SYSTEM_EVENTS.forEach(event => {
+      els.removeSystemEventListener(global, event.type, this, event.useCapture);
+    });
+
+    OBSERVED_EVENTS.forEach((aTopic) => {
+      Services.obs.removeObserver(this, aTopic);
+    });
+
+    this.forwarder.uninit();
+    this.forwarder = null;
+  },
+
+  handleEvent: function(event) {
+    switch (event.type) {
+      case "DOMTitleChanged":
+        this._titleChangedHandler(event);
+        break;
+      case "DOMLinkAdded":
+        this._linkAddedHandler(event);
+        break;
+      case "MozScrolledAreaChanged":
+        this._mozScrollAreaChanged(event);
+        break;
+      case "MozDOMFullscreen:Request":
+        this._mozRequestedDOMFullscreen(event);
+        break;
+      case "MozDOMFullscreen:NewOrigin":
+        this._mozFullscreenOriginChange(event);
+        break;
+      case "MozDOMFullscreen:Exit":
+        this._mozExitDomFullscreen(event);
+        break;
+      case "DOMMetaAdded":
+        this._metaChangedHandler(event);
+        break;
+      case "DOMMetaChanged":
+        this._metaChangedHandler(event);
+        break;
+      case "DOMMetaRemoved":
+        this._metaChangedHandler(event);
+        break;
+      case "scrollviewchange":
+        this._ScrollViewChangeHandler(event);
+        break;
+      case "click":
+        this._ClickHandler(event);
+        break;
+      case "unload":
+        this.destroy(event);
+        break;
+      case "DOMWindowClose":
+        this._windowCloseHandler(event);
+        break;
+      case "DOMWindowCreated":
+        this._windowCreatedHandler(event);
+        break;
+      case "DOMWindowResize":
+        this._windowResizeHandler(event);
+        break;
+      case "contextmenu":
+        this._contextmenuHandler(event);
+        break;
+      case "scroll":
+        this._scrollEventHandler(event);
+        break;
+    }
+  },
+
+  receiveMessage: function(message) {
+    let self = this;
+
+    let mmCalls = {
+      "purge-history": this._recvPurgeHistory,
+      "get-screenshot": this._recvGetScreenshot,
+      "get-contentdimensions": this._recvGetContentDimensions,
+      "set-visible": this._recvSetVisible,
+      "get-visible": this._recvVisible,
+      "send-mouse-event": this._recvSendMouseEvent,
+      "send-touch-event": this._recvSendTouchEvent,
+      "get-can-go-back": this._recvCanGoBack,
+      "get-can-go-forward": this._recvCanGoForward,
+      "mute": this._recvMute,
+      "unmute": this._recvUnmute,
+      "get-muted": this._recvGetMuted,
+      "set-volume": this._recvSetVolume,
+      "get-volume": this._recvGetVolume,
+      "go-back": this._recvGoBack,
+      "go-forward": this._recvGoForward,
+      "reload": this._recvReload,
+      "stop": this._recvStop,
+      "zoom": this._recvZoom,
+      "unblock-modal-prompt": this._recvStopWaiting,
+      "fire-ctx-callback": this._recvFireCtxCallback,
+      "owner-visibility-change": this._recvOwnerVisibilityChange,
+      "entered-fullscreen": this._recvEnteredFullscreen,
+      "exit-fullscreen": this._recvExitFullscreen,
+      "activate-next-paint-listener": this._activateNextPaintListener,
+      "set-input-method-active": this._recvSetInputMethodActive,
+      "deactivate-next-paint-listener": this._deactivateNextPaintListener,
+      "find-all": this._recvFindAll,
+      "find-next": this._recvFindNext,
+      "clear-match": this._recvClearMatch,
+      "execute-script": this._recvExecuteScript,
+      "get-audio-channel-volume": this._recvGetAudioChannelVolume,
+      "set-audio-channel-volume": this._recvSetAudioChannelVolume,
+      "get-audio-channel-muted": this._recvGetAudioChannelMuted,
+      "set-audio-channel-muted": this._recvSetAudioChannelMuted,
+      "get-is-audio-channel-active": this._recvIsAudioChannelActive,
+      "get-web-manifest": this._recvGetWebManifest,
+    }
+
+    if (message.data.msg_name in mmCalls) {
+      return mmCalls[message.data.msg_name].apply(self, arguments);
+    }
+  },
+
+  _paintFrozenTimer: null,
+  observe: function(subject, topic, data) {
+    // Ignore notifications not about our document.  (Note that |content| /can/
+    // be null; see bug 874900.)
+
+    if (topic !== 'activity-done' &&
+        topic !== 'audio-playback' &&
+        topic !== 'will-launch-app' &&
+        (!content || subject !== content.document)) {
+      return;
+    }
+    if (topic == 'activity-done' && docShell !== subject)
+      return;
+    switch (topic) {
+      case 'activity-done':
+        sendAsyncMsg('activitydone', { success: (data == 'activity-success') });
+        break;
+      case 'audio-playback':
+        if (subject === content) {
+          sendAsyncMsg('audioplaybackchange', { _payload_: data });
+        }
+        break;
+      case 'xpcom-shutdown':
+        this._shuttingDown = true;
+        break;
+      case 'will-launch-app':
+        // If the launcher is not visible, let's ignore the message.
+        if (!docShell.isActive) {
+          return;
+        }
+
+        // If this is not a content process, let's not freeze painting.
+        if (Services.appinfo.processType != Services.appinfo.PROCESS_TYPE_CONTENT) {
+          return;
+        }
+
+        docShell.contentViewer.pausePainting();
+
+        this._paintFrozenTimer && this._paintFrozenTimer.cancel();
+        this._paintFrozenTimer = new Timer(this, 3000, Ci.nsITimer.TYPE_ONE_SHOT);
+        break;
+    }
+  },
+
+  notify: function(timer) {
+    docShell.contentViewer.resumePainting();
+    this._paintFrozenTimer.cancel();
+    this._paintFrozenTimer = null;
+  },
+
+  get _windowUtils() {
+    return content.document.defaultView
+                  .QueryInterface(Ci.nsIInterfaceRequestor)
+                  .getInterface(Ci.nsIDOMWindowUtils);
+  },
+
+  _tryGetInnerWindowID: function(win) {
+    let utils = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                   .getInterface(Ci.nsIDOMWindowUtils);
+    try {
+      return utils.currentInnerWindowID;
+    }
+    catch(e) {
+      return null;
+    }
+  },
+
+  /**
+   * Show a modal prompt.  Called by BrowserElementPromptService.
+   */
+  showModalPrompt: function(win, args) {
+    let utils = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                   .getInterface(Ci.nsIDOMWindowUtils);
+
+    args.windowID = { outer: utils.outerWindowID,
+                      inner: this._tryGetInnerWindowID(win) };
+    sendAsyncMsg('showmodalprompt', args);
+
+    let returnValue = this._waitForResult(win);
+
+    if (args.promptType == 'prompt' ||
+        args.promptType == 'confirm' ||
+        args.promptType == 'custom-prompt') {
+      return returnValue;
+    }
+  },
+
+  /**
+   * Spin in a nested event loop until we receive a unblock-modal-prompt message for
+   * this window.
+   */
+  _waitForResult: function(win) {
+    debug("_waitForResult(" + win + ")");
+    let utils = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                   .getInterface(Ci.nsIDOMWindowUtils);
+
+    let outerWindowID = utils.outerWindowID;
+    let innerWindowID = this._tryGetInnerWindowID(win);
+    if (innerWindowID === null) {
+      // I have no idea what waiting for a result means when there's no inner
+      // window, so let's just bail.
+      debug("_waitForResult: No inner window. Bailing.");
+      return;
+    }
+
+    this._windowIDDict[outerWindowID] = Cu.getWeakReference(win);
+
+    debug("Entering modal state (outerWindowID=" + outerWindowID + ", " +
+                                "innerWindowID=" + innerWindowID + ")");
+
+    utils.enterModalState();
+
+    // We'll decrement win.modalDepth when we receive a unblock-modal-prompt message
+    // for the window.
+    if (!win.modalDepth) {
+      win.modalDepth = 0;
+    }
+    win.modalDepth++;
+    let origModalDepth = win.modalDepth;
+
+    let thread = Services.tm.currentThread;
+    debug("Nested event loop - begin");
+    while (win.modalDepth == origModalDepth && !this._shuttingDown) {
+      // Bail out of the loop if the inner window changed; that means the
+      // window navigated.  Bail out when we're shutting down because otherwise
+      // we'll leak our window.
+      if (this._tryGetInnerWindowID(win) !== innerWindowID) {
+        debug("_waitForResult: Inner window ID changed " +
+              "while in nested event loop.");
+        break;
+      }
+
+      thread.processNextEvent(/* mayWait = */ true);
+    }
+    debug("Nested event loop - finish");
+
+    if (win.modalDepth == 0) {
+      delete this._windowIDDict[outerWindowID];
+    }
+
+    // If we exited the loop because the inner window changed, then bail on the
+    // modal prompt.
+    if (innerWindowID !== this._tryGetInnerWindowID(win)) {
+      throw Components.Exception("Modal state aborted by navigation",
+                                 Cr.NS_ERROR_NOT_AVAILABLE);
+    }
+
+    let returnValue = win.modalReturnValue;
+    delete win.modalReturnValue;
+
+    if (!this._shuttingDown) {
+      utils.leaveModalState();
+    }
+
+    debug("Leaving modal state (outerID=" + outerWindowID + ", " +
+                               "innerID=" + innerWindowID + ")");
+    return returnValue;
+  },
+
+  _recvStopWaiting: function(msg) {
+    let outerID = msg.json.windowID.outer;
+    let innerID = msg.json.windowID.inner;
+    let returnValue = msg.json.returnValue;
+    debug("recvStopWaiting(outer=" + outerID + ", inner=" + innerID +
+          ", returnValue=" + returnValue + ")");
+
+    if (!this._windowIDDict[outerID]) {
+      debug("recvStopWaiting: No record of outer window ID " + outerID);
+      return;
+    }
+
+    let win = this._windowIDDict[outerID].get();
+
+    if (!win) {
+      debug("recvStopWaiting, but window is gone\n");
+      return;
+    }
+
+    if (innerID !== this._tryGetInnerWindowID(win)) {
+      debug("recvStopWaiting, but inner ID has changed\n");
+      return;
+    }
+
+    debug("recvStopWaiting " + win);
+    win.modalReturnValue = returnValue;
+    win.modalDepth--;
+  },
+
+  _recvEnteredFullscreen: function() {
+    if (!this._windowUtils.handleFullscreenRequests() &&
+        !content.document.fullscreenElement) {
+      // If we don't actually have any pending fullscreen request
+      // to handle, neither we have been in fullscreen, tell the
+      // parent to just exit.
+      sendAsyncMsg("exit-dom-fullscreen");
+    }
+  },
+
+  _recvExitFullscreen: function() {
+    this._windowUtils.exitFullscreen();
+  },
+
+  _titleChangedHandler: function(e) {
+    debug("Got titlechanged: (" + e.target.title + ")");
+    var win = e.target.defaultView;
+
+    // Ignore titlechanges which don't come from the top-level
+    // <iframe mozbrowser> window.
+    if (win == content) {
+      sendAsyncMsg('titlechange', { _payload_: e.target.title });
+    }
+    else {
+      debug("Not top level!");
+    }
+  },
+
+  _maybeCopyAttribute: function(src, target, attribute) {
+    if (src.getAttribute(attribute)) {
+      target[attribute] = src.getAttribute(attribute);
+    }
+  },
+
+  _iconChangedHandler: function(e) {
+    debug('Got iconchanged: (' + e.target.href + ')');
+    let icon = { href: e.target.href };
+    this._maybeCopyAttribute(e.target, icon, 'sizes');
+    this._maybeCopyAttribute(e.target, icon, 'rel');
+    sendAsyncMsg('iconchange', icon);
+  },
+
+  _openSearchHandler: function(e) {
+    debug('Got opensearch: (' + e.target.href + ')');
+
+    if (e.target.type !== "application/opensearchdescription+xml") {
+      return;
+    }
+
+    sendAsyncMsg('opensearch', { title: e.target.title,
+                                 href: e.target.href });
+
+  },
+
+  _manifestChangedHandler: function(e) {
+    debug('Got manifestchanged: (' + e.target.href + ')');
+    let manifest = { href: e.target.href };
+    sendAsyncMsg('manifestchange', manifest);
+
+  },
+
+  // Processes the "rel" field in <link> tags and forward to specific handlers.
+  _linkAddedHandler: function(e) {
+    let win = e.target.ownerDocument.defaultView;
+    // Ignore links which don't come from the top-level
+    // <iframe mozbrowser> window.
+    if (win != content) {
+      debug('Not top level!');
+      return;
+    }
+
+    let handlers = {
+      'icon': this._iconChangedHandler.bind(this),
+      'apple-touch-icon': this._iconChangedHandler.bind(this),
+      'apple-touch-icon-precomposed': this._iconChangedHandler.bind(this),
+      'search': this._openSearchHandler,
+      'manifest': this._manifestChangedHandler
+    };
+
+    debug('Got linkAdded: (' + e.target.href + ') ' + e.target.rel);
+    e.target.rel.split(' ').forEach(function(x) {
+      let token = x.toLowerCase();
+      if (handlers[token]) {
+        handlers[token](e);
+      }
+    }, this);
+  },
+
+  _metaChangedHandler: function(e) {
+    let win = e.target.ownerDocument.defaultView;
+    // Ignore metas which don't come from the top-level
+    // <iframe mozbrowser> window.
+    if (win != content) {
+      debug('Not top level!');
+      return;
+    }
+
+    var name = e.target.name;
+    var property = e.target.getAttributeNS(null, "property");
+
+    if (!name && !property) {
+      return;
+    }
+
+    debug('Got metaChanged: (' + (name || property) + ') ' +
+          e.target.content);
+
+    let handlers = {
+      'viewmode': this._genericMetaHandler,
+      'theme-color': this._genericMetaHandler,
+      'theme-group': this._genericMetaHandler,
+      'application-name': this._applicationNameChangedHandler
+    };
+    let handler = handlers[name];
+
+    if ((property || name).match(/^og:/)) {
+      name = property || name;
+      handler = this._genericMetaHandler;
+    }
+
+    if (handler) {
+      handler(name, e.type, e.target);
+    }
+  },
+
+  _applicationNameChangedHandler: function(name, eventType, target) {
+    if (eventType !== 'DOMMetaAdded') {
+      // Bug 1037448 - Decide what to do when <meta name="application-name">
+      // changes
+      return;
+    }
+
+    let meta = { name: name,
+                 content: target.content };
+
+    let lang;
+    let elm;
+
+    for (elm = target;
+         !lang && elm && elm.nodeType == target.ELEMENT_NODE;
+         elm = elm.parentNode) {
+      if (elm.hasAttribute('lang')) {
+        lang = elm.getAttribute('lang');
+        continue;
+      }
+
+      if (elm.hasAttributeNS('http://www.w3.org/XML/1998/namespace', 'lang')) {
+        lang = elm.getAttributeNS('http://www.w3.org/XML/1998/namespace', 'lang');
+        continue;
+      }
+    }
+
+    // No lang has been detected.
+    if (!lang && elm.nodeType == target.DOCUMENT_NODE) {
+      lang = elm.contentLanguage;
+    }
+
+    if (lang) {
+      meta.lang = lang;
+    }
+
+    sendAsyncMsg('metachange', meta);
+  },
+
+  _ScrollViewChangeHandler: function(e) {
+    e.stopPropagation();
+    let detail = {
+      state: e.state,
+    };
+    sendAsyncMsg('scrollviewchange', detail);
+  },
+
+  _ClickHandler: function(e) {
+
+    let isHTMLLink = node =>
+      ((node instanceof Ci.nsIDOMHTMLAnchorElement && node.href) ||
+       (node instanceof Ci.nsIDOMHTMLAreaElement && node.href) ||
+        node instanceof Ci.nsIDOMHTMLLinkElement);
+
+    // Open in a new tab if middle click or ctrl/cmd-click,
+    // and e.target is a link or inside a link.
+    if ((Services.appinfo.OS == 'Darwin' && e.metaKey) ||
+        (Services.appinfo.OS != 'Darwin' && e.ctrlKey) ||
+         e.button == 1) {
+
+      let node = e.target;
+      while (node && !isHTMLLink(node)) {
+        node = node.parentNode;
+      }
+
+      if (node) {
+        sendAsyncMsg('opentab', {url: node.href});
+      }
+    }
+  },
+
+  _genericMetaHandler: function(name, eventType, target) {
+    let meta = {
+      name: name,
+      content: target.content,
+      type: eventType.replace('DOMMeta', '').toLowerCase()
+    };
+    sendAsyncMsg('metachange', meta);
+  },
+
+  _addMozAfterPaintHandler: function(callback) {
+    function onMozAfterPaint() {
+      let uri = docShell.QueryInterface(Ci.nsIWebNavigation).currentURI;
+      if (uri.spec != "about:blank") {
+        debug("Got afterpaint event: " + uri.spec);
+        removeEventListener('MozAfterPaint', onMozAfterPaint,
+                            /* useCapture = */ true);
+        callback();
+      }
+    }
+
+    addEventListener('MozAfterPaint', onMozAfterPaint, /* useCapture = */ true);
+    return onMozAfterPaint;
+  },
+
+  _removeMozAfterPaintHandler: function(listener) {
+    removeEventListener('MozAfterPaint', listener,
+                        /* useCapture = */ true);
+  },
+
+  _activateNextPaintListener: function(e) {
+    if (!this._nextPaintHandler) {
+      this._nextPaintHandler = this._addMozAfterPaintHandler(function () {
+        this._nextPaintHandler = null;
+        sendAsyncMsg('nextpaint');
+      }.bind(this));
+    }
+  },
+
+  _deactivateNextPaintListener: function(e) {
+    if (this._nextPaintHandler) {
+      this._removeMozAfterPaintHandler(this._nextPaintHandler);
+      this._nextPaintHandler = null;
+    }
+  },
+
+  _windowCloseHandler: function(e) {
+    let win = e.target;
+    if (win != content || e.defaultPrevented) {
+      return;
+    }
+
+    debug("Closing window " + win);
+    sendAsyncMsg('close');
+
+    // Inform the window implementation that we handled this close ourselves.
+    e.preventDefault();
+  },
+
+  _windowCreatedHandler: function(e) {
+    let targetDocShell = e.target.defaultView
+          .QueryInterface(Ci.nsIInterfaceRequestor)
+          .getInterface(Ci.nsIWebNavigation);
+    if (targetDocShell != docShell) {
+      return;
+    }
+
+    let uri = docShell.QueryInterface(Ci.nsIWebNavigation).currentURI;
+    debug("Window created: " + uri.spec);
+    if (uri.spec != "about:blank") {
+      this._addMozAfterPaintHandler(function () {
+        sendAsyncMsg('documentfirstpaint');
+      });
+      this._isContentWindowCreated = true;
+      // Handle pending SetInputMethodActive request.
+      while (this._pendingSetInputMethodActive.length > 0) {
+        this._recvSetInputMethodActive(this._pendingSetInputMethodActive.shift());
+      }
+    }
+  },
+
+  _windowResizeHandler: function(e) {
+    let win = e.target;
+    if (win != content || e.defaultPrevented) {
+      return;
+    }
+
+    debug("resizing window " + win);
+    sendAsyncMsg('resize', { width: e.detail.width, height: e.detail.height });
+
+    // Inform the window implementation that we handled this resize ourselves.
+    e.preventDefault();
+  },
+
+  _contextmenuHandler: function(e) {
+    debug("Got contextmenu");
+
+    if (e.defaultPrevented) {
+      return;
+    }
+
+    this._ctxCounter++;
+    this._ctxHandlers = {};
+
+    var elem = e.target;
+    var menuData = {systemTargets: [], contextmenu: null};
+    var ctxMenuId = null;
+    var clipboardPlainTextOnly = Services.prefs.getBoolPref('clipboard.plainTextOnly');
+    var copyableElements = {
+      image: false,
+      link: false,
+      hasElements: function() {
+        return this.image || this.link;
+      }
+    };
+
+    // Set the event target as the copy image command needs it to
+    // determine what was context-clicked on.
+    docShell.contentViewer.QueryInterface(Ci.nsIContentViewerEdit).setCommandNode(elem);
+
+    while (elem && elem.parentNode) {
+      var ctxData = this._getSystemCtxMenuData(elem);
+      if (ctxData) {
+        menuData.systemTargets.push({
+          nodeName: elem.nodeName,
+          data: ctxData
+        });
+      }
+
+      if (!ctxMenuId && 'hasAttribute' in elem && elem.hasAttribute('contextmenu')) {
+        ctxMenuId = elem.getAttribute('contextmenu');
+      }
+
+      // Enable copy image/link option
+      if (elem.nodeName == 'IMG') {
+        copyableElements.image = !clipboardPlainTextOnly;
+      } else if (elem.nodeName == 'A') {
+        copyableElements.link = true;
+      }
+
+      elem = elem.parentNode;
+    }
+
+    if (ctxMenuId || copyableElements.hasElements()) {
+      var menu = null;
+      if (ctxMenuId) {
+        menu = e.target.ownerDocument.getElementById(ctxMenuId);
+      }
+      menuData.contextmenu = this._buildMenuObj(menu, '', copyableElements);
+    }
+
+    // Pass along the position where the context menu should be located
+    menuData.clientX = e.clientX;
+    menuData.clientY = e.clientY;
+    menuData.screenX = e.screenX;
+    menuData.screenY = e.screenY;
+
+    // The value returned by the contextmenu sync call is true if the embedder
+    // called preventDefault() on its contextmenu event.
+    //
+    // We call preventDefault() on our contextmenu event if the embedder called
+    // preventDefault() on /its/ contextmenu event.  This way, if the embedder
+    // ignored the contextmenu event, TabChild will fire a click.
+    if (sendSyncMsg('contextmenu', menuData)[0]) {
+      e.preventDefault();
+    } else {
+      this._ctxHandlers = {};
+    }
+  },
+
+  _getSystemCtxMenuData: function(elem) {
+    let documentURI =
+      docShell.QueryInterface(Ci.nsIWebNavigation).currentURI.spec;
+    if ((elem instanceof Ci.nsIDOMHTMLAnchorElement && elem.href) ||
+        (elem instanceof Ci.nsIDOMHTMLAreaElement && elem.href)) {
+      return {uri: elem.href,
+              documentURI: documentURI,
+              text: elem.textContent.substring(0, kLongestReturnedString)};
+    }
+    if (elem instanceof Ci.nsIImageLoadingContent && elem.currentURI) {
+      return {uri: elem.currentURI.spec, documentURI: documentURI};
+    }
+    if (elem instanceof Ci.nsIDOMHTMLImageElement) {
+      return {uri: elem.src, documentURI: documentURI};
+    }
+    if (elem instanceof Ci.nsIDOMHTMLMediaElement) {
+      let hasVideo = !(elem.readyState >= elem.HAVE_METADATA &&
+                       (elem.videoWidth == 0 || elem.videoHeight == 0));
+      return {uri: elem.currentSrc || elem.src,
+              hasVideo: hasVideo,
+              documentURI: documentURI};
+    }
+    if (elem instanceof Ci.nsIDOMHTMLInputElement &&
+        elem.hasAttribute("name")) {
+      // For input elements, we look for a parent <form> and if there is
+      // one we return the form's method and action uri.
+      let parent = elem.parentNode;
+      while (parent) {
+        if (parent instanceof Ci.nsIDOMHTMLFormElement &&
+            parent.hasAttribute("action")) {
+          let actionHref = docShell.QueryInterface(Ci.nsIWebNavigation)
+                                   .currentURI
+                                   .resolve(parent.getAttribute("action"));
+          let method = parent.hasAttribute("method")
+            ? parent.getAttribute("method").toLowerCase()
+            : "get";
+          return {
+            documentURI: documentURI,
+            action: actionHref,
+            method: method,
+            name: elem.getAttribute("name"),
+          }
+        }
+        parent = parent.parentNode;
+      }
+    }
+    return false;
+  },
+
+  _scrollEventHandler: function(e) {
+    let win = e.target.defaultView;
+    if (win != content) {
+      return;
+    }
+
+    debug("scroll event " + win);
+    sendAsyncMsg("scroll", { top: win.scrollY, left: win.scrollX });
+  },
+
+  _recvPurgeHistory: function(data) {
+    debug("Received purgeHistory message: (" + data.json.id + ")");
+
+    let history = docShell.QueryInterface(Ci.nsIWebNavigation).sessionHistory;
+
+    try {
+      if (history && history.count) {
+        history.PurgeHistory(history.count);
+      }
+    } catch(e) {}
+
+    sendAsyncMsg('got-purge-history', { id: data.json.id, successRv: true });
+  },
+
+  _recvGetScreenshot: function(data) {
+    debug("Received getScreenshot message: (" + data.json.id + ")");
+
+    let self = this;
+    let maxWidth = data.json.args.width;
+    let maxHeight = data.json.args.height;
+    let mimeType = data.json.args.mimeType;
+    let domRequestID = data.json.id;
+
+    let takeScreenshotClosure = function() {
+      self._takeScreenshot(maxWidth, maxHeight, mimeType, domRequestID);
+    };
+
+    let maxDelayMS = 2000;
+    try {
+      maxDelayMS = Services.prefs.getIntPref('dom.browserElement.maxScreenshotDelayMS');
+    }
+    catch(e) {}
+
+    // Try to wait for the event loop to go idle before we take the screenshot,
+    // but once we've waited maxDelayMS milliseconds, go ahead and take it
+    // anyway.
+    Cc['@mozilla.org/message-loop;1'].getService(Ci.nsIMessageLoop).postIdleTask(
+      takeScreenshotClosure, maxDelayMS);
+  },
+
+  _recvExecuteScript: function(data) {
+    debug("Received executeScript message: (" + data.json.id + ")");
+
+    let domRequestID = data.json.id;
+
+    let sendError = errorMsg => sendAsyncMsg("execute-script-done", {
+      errorMsg,
+      id: domRequestID
+    });
+
+    let sendSuccess = successRv => sendAsyncMsg("execute-script-done", {
+      successRv,
+      id: domRequestID
+    });
+
+    let isJSON = obj => {
+      try {
+        JSON.stringify(obj);
+      } catch(e) {
+        return false;
+      }
+      return true;
+    }
+
+    let expectedOrigin = data.json.args.options.origin;
+    let expectedUrl = data.json.args.options.url;
+
+    if (expectedOrigin) {
+      if (expectedOrigin != content.location.origin) {
+        sendError("Origin mismatches");
+        return;
+      }
+    }
+
+    if (expectedUrl) {
+      let expectedURI
+      try {
+       expectedURI = Services.io.newURI(expectedUrl, null, null);
+      } catch(e) {
+        sendError("Malformed URL");
+        return;
+      }
+      let currentURI = docShell.QueryInterface(Ci.nsIWebNavigation).currentURI;
+      if (!currentURI.equalsExceptRef(expectedURI)) {
+        sendError("URL mismatches");
+        return;
+      }
+    }
+
+    let sandbox = new Cu.Sandbox([content], {
+      sandboxPrototype: content,
+      sandboxName: "browser-api-execute-script",
+      allowWaivers: false,
+      sameZoneAs: content
+    });
+
+    try {
+      let sandboxRv = Cu.evalInSandbox(data.json.args.script, sandbox, "1.8");
+      if (sandboxRv instanceof sandbox.Promise) {
+        sandboxRv.then(rv => {
+          if (isJSON(rv)) {
+            sendSuccess(rv);
+          } else {
+            sendError("Value returned (resolve) by promise is not a valid JSON object");
+          }
+        }, error => {
+          if (isJSON(error)) {
+            sendError(error);
+          } else {
+            sendError("Value returned (reject) by promise is not a valid JSON object");
+          }
+        });
+      } else {
+        if (isJSON(sandboxRv)) {
+          sendSuccess(sandboxRv);
+        } else {
+          sendError("Script last expression must be a promise or a JSON object");
+        }
+      }
+    } catch(e) {
+      sendError(e.toString());
+    }
+  },
+
+  _recvGetContentDimensions: function(data) {
+    debug("Received getContentDimensions message: (" + data.json.id + ")");
+    sendAsyncMsg('got-contentdimensions', {
+      id: data.json.id,
+      successRv: this._getContentDimensions()
+    });
+  },
+
+  _mozScrollAreaChanged: function(e) {
+    sendAsyncMsg('scrollareachanged', {
+      width: e.width,
+      height: e.height
+    });
+  },
+
+  _mozRequestedDOMFullscreen: function(e) {
+    sendAsyncMsg("requested-dom-fullscreen");
+  },
+
+  _mozFullscreenOriginChange: function(e) {
+    sendAsyncMsg("fullscreen-origin-change", {
+      originNoSuffix: e.target.nodePrincipal.originNoSuffix
+    });
+  },
+
+  _mozExitDomFullscreen: function(e) {
+    sendAsyncMsg("exit-dom-fullscreen");
+  },
+
+  _getContentDimensions: function() {
+    return {
+      width: content.document.body.scrollWidth,
+      height: content.document.body.scrollHeight
+    }
+  },
+
+  /**
+   * Actually take a screenshot and foward the result up to our parent, given
+   * the desired maxWidth and maxHeight (in CSS pixels), and given the
+   * DOMRequest ID associated with the request from the parent.
+   */
+  _takeScreenshot: function(maxWidth, maxHeight, mimeType, domRequestID) {
+    // You can think of the screenshotting algorithm as carrying out the
+    // following steps:
+    //
+    // - Calculate maxWidth, maxHeight, and viewport's width and height in the
+    //   dimension of device pixels by multiply the numbers with
+    //   window.devicePixelRatio.
+    //
+    // - Let scaleWidth be the factor by which we'd need to downscale the
+    //   viewport pixel width so it would fit within maxPixelWidth.
+    //   (If the viewport's pixel width is less than maxPixelWidth, let
+    //   scaleWidth be 1.) Compute scaleHeight the same way.
+    //
+    // - Scale the viewport by max(scaleWidth, scaleHeight).  Now either the
+    //   viewport's width is no larger than maxWidth, the viewport's height is
+    //   no larger than maxHeight, or both.
+    //
+    // - Crop the viewport so its width is no larger than maxWidth and its
+    //   height is no larger than maxHeight.
+    //
+    // - Set mozOpaque to true and background color to solid white
+    //   if we are taking a JPEG screenshot, keep transparent if otherwise.
+    //
+    // - Return a screenshot of the page's viewport scaled and cropped per
+    //   above.
+    debug("Taking a screenshot: maxWidth=" + maxWidth +
+          ", maxHeight=" + maxHeight +
+          ", mimeType=" + mimeType +
+          ", domRequestID=" + domRequestID + ".");
+
+    if (!content) {
+      // If content is not loaded yet, bail out since even sendAsyncMessage
+      // fails...
+      debug("No content yet!");
+      return;
+    }
+
+    let devicePixelRatio = content.devicePixelRatio;
+
+    let maxPixelWidth = Math.round(maxWidth * devicePixelRatio);
+    let maxPixelHeight = Math.round(maxHeight * devicePixelRatio);
+
+    let contentPixelWidth = content.innerWidth * devicePixelRatio;
+    let contentPixelHeight = content.innerHeight * devicePixelRatio;
+
+    let scaleWidth = Math.min(1, maxPixelWidth / contentPixelWidth);
+    let scaleHeight = Math.min(1, maxPixelHeight / contentPixelHeight);
+
+    let scale = Math.max(scaleWidth, scaleHeight);
+
+    let canvasWidth =
+      Math.min(maxPixelWidth, Math.round(contentPixelWidth * scale));
+    let canvasHeight =
+      Math.min(maxPixelHeight, Math.round(contentPixelHeight * scale));
+
+    let transparent = (mimeType !== 'image/jpeg');
+
+    var canvas = content.document
+      .createElementNS("http://www.w3.org/1999/xhtml", "canvas");
+    if (!transparent)
+      canvas.mozOpaque = true;
+    canvas.width = canvasWidth;
+    canvas.height = canvasHeight;
+
+    let ctx = canvas.getContext("2d", { willReadFrequently: true });
+    ctx.scale(scale * devicePixelRatio, scale * devicePixelRatio);
+
+    let flags = ctx.DRAWWINDOW_DRAW_VIEW |
+                ctx.DRAWWINDOW_USE_WIDGET_LAYERS |
+                ctx.DRAWWINDOW_DO_NOT_FLUSH |
+                ctx.DRAWWINDOW_ASYNC_DECODE_IMAGES;
+    ctx.drawWindow(content, 0, 0, content.innerWidth, content.innerHeight,
+                   transparent ? "rgba(255,255,255,0)" : "rgb(255,255,255)",
+                   flags);
+
+    // Take a JPEG screenshot by default instead of PNG with alpha channel.
+    // This requires us to unpremultiply the alpha channel, which
+    // is expensive on ARM processors because they lack a hardware integer
+    // division instruction.
+    canvas.toBlob(function(blob) {
+      sendAsyncMsg('got-screenshot', {
+        id: domRequestID,
+        successRv: blob
+      });
+    }, mimeType);
+  },
+
+  _recvFireCtxCallback: function(data) {
+    debug("Received fireCtxCallback message: (" + data.json.menuitem + ")");
+
+    let doCommandIfEnabled = (command) => {
+      if (docShell.isCommandEnabled(command)) {
+        docShell.doCommand(command);
+      }
+    };
+
+    if (data.json.menuitem == 'copy-image') {
+      doCommandIfEnabled('cmd_copyImage');
+    } else if (data.json.menuitem == 'copy-link') {
+      doCommandIfEnabled('cmd_copyLink');
+    } else if (data.json.menuitem in this._ctxHandlers) {
+      this._ctxHandlers[data.json.menuitem].click();
+      this._ctxHandlers = {};
+    } else {
+      // We silently ignore if the embedder uses an incorrect id in the callback
+      debug("Ignored invalid contextmenu invocation");
+    }
+  },
+
+  _buildMenuObj: function(menu, idPrefix, copyableElements) {
+    var menuObj = {type: 'menu', customized: false, items: []};
+    // Customized context menu
+    if (menu) {
+      this._maybeCopyAttribute(menu, menuObj, 'label');
+
+      for (var i = 0, child; child = menu.children[i++];) {
+        if (child.nodeName === 'MENU') {
+          menuObj.items.push(this._buildMenuObj(child, idPrefix + i + '_', false));
+        } else if (child.nodeName === 'MENUITEM') {
+          var id = this._ctxCounter + '_' + idPrefix + i;
+          var menuitem = {id: id, type: 'menuitem'};
+          this._maybeCopyAttribute(child, menuitem, 'label');
+          this._maybeCopyAttribute(child, menuitem, 'icon');
+          this._ctxHandlers[id] = child;
+          menuObj.items.push(menuitem);
+        }
+      }
+
+      if (menuObj.items.length > 0) {
+        menuObj.customized = true;
+      }
+    }
+    // Note: Display "Copy Link" first in order to make sure "Copy Image" is
+    //       put together with other image options if elem is an image link.
+    // "Copy Link" menu item
+    if (copyableElements.link) {
+      menuObj.items.push({id: 'copy-link'});
+    }
+    // "Copy Image" menu item
+    if (copyableElements.image) {
+      menuObj.items.push({id: 'copy-image'});
+    }
+
+    return menuObj;
+  },
+
+  _recvSetVisible: function(data) {
+    debug("Received setVisible message: (" + data.json.visible + ")");
+    if (this._forcedVisible == data.json.visible) {
+      return;
+    }
+
+    this._forcedVisible = data.json.visible;
+    this._updateVisibility();
+  },
+
+  _recvVisible: function(data) {
+    sendAsyncMsg('got-visible', {
+      id: data.json.id,
+      successRv: docShell.isActive
+    });
+  },
+
+  /**
+   * Called when the window which contains this iframe becomes hidden or
+   * visible.
+   */
+  _recvOwnerVisibilityChange: function(data) {
+    debug("Received ownerVisibilityChange: (" + data.json.visible + ")");
+    this._ownerVisible = data.json.visible;
+    this._updateVisibility();
+  },
+
+  _updateVisibility: function() {
+    var visible = this._forcedVisible && this._ownerVisible;
+    if (docShell && docShell.isActive !== visible) {
+      docShell.isActive = visible;
+      sendAsyncMsg('visibilitychange', {visible: visible});
+
+      // Ensure painting is not frozen if the app goes visible.
+      if (visible && this._paintFrozenTimer) {
+        this.notify();
+      }
+    }
+  },
+
+  _recvSendMouseEvent: function(data) {
+    let json = data.json;
+    let utils = content.QueryInterface(Ci.nsIInterfaceRequestor)
+                       .getInterface(Ci.nsIDOMWindowUtils);
+    utils.sendMouseEventToWindow(json.type, json.x, json.y, json.button,
+                                 json.clickCount, json.modifiers);
+  },
+
+  _recvSendTouchEvent: function(data) {
+    let json = data.json;
+    let utils = content.QueryInterface(Ci.nsIInterfaceRequestor)
+                       .getInterface(Ci.nsIDOMWindowUtils);
+    utils.sendTouchEventToWindow(json.type, json.identifiers, json.touchesX,
+                                 json.touchesY, json.radiisX, json.radiisY,
+                                 json.rotationAngles, json.forces, json.count,
+                                 json.modifiers);
+  },
+
+  _recvCanGoBack: function(data) {
+    var webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
+    sendAsyncMsg('got-can-go-back', {
+      id: data.json.id,
+      successRv: webNav.canGoBack
+    });
+  },
+
+  _recvCanGoForward: function(data) {
+    var webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
+    sendAsyncMsg('got-can-go-forward', {
+      id: data.json.id,
+      successRv: webNav.canGoForward
+    });
+  },
+
+  _recvMute: function(data) {
+    this._windowUtils.audioMuted = true;
+  },
+
+  _recvUnmute: function(data) {
+    this._windowUtils.audioMuted = false;
+  },
+
+  _recvGetMuted: function(data) {
+    sendAsyncMsg('got-muted', {
+      id: data.json.id,
+      successRv: this._windowUtils.audioMuted
+    });
+  },
+
+  _recvSetVolume: function(data) {
+    this._windowUtils.audioVolume = data.json.volume;
+  },
+
+  _recvGetVolume: function(data) {
+    sendAsyncMsg('got-volume', {
+      id: data.json.id,
+      successRv: this._windowUtils.audioVolume
+    });
+  },
+
+  _recvGoBack: function(data) {
+    try {
+      docShell.QueryInterface(Ci.nsIWebNavigation).goBack();
+    } catch(e) {
+      // Silently swallow errors; these happen when we can't go back.
+    }
+  },
+
+  _recvGoForward: function(data) {
+    try {
+      docShell.QueryInterface(Ci.nsIWebNavigation).goForward();
+    } catch(e) {
+      // Silently swallow errors; these happen when we can't go forward.
+    }
+  },
+
+  _recvReload: function(data) {
+    let webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
+    let reloadFlags = data.json.hardReload ?
+      webNav.LOAD_FLAGS_BYPASS_PROXY | webNav.LOAD_FLAGS_BYPASS_CACHE :
+      webNav.LOAD_FLAGS_NONE;
+    try {
+      webNav.reload(reloadFlags);
+    } catch(e) {
+      // Silently swallow errors; these can happen if a used cancels reload
+    }
+  },
+
+  _recvStop: function(data) {
+    let webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
+    webNav.stop(webNav.STOP_NETWORK);
+  },
+
+  _recvZoom: function(data) {
+    docShell.contentViewer.fullZoom = data.json.zoom;
+  },
+
+  _recvGetAudioChannelVolume: function(data) {
+    debug("Received getAudioChannelVolume message: (" + data.json.id + ")");
+
+    let volume = acs.getAudioChannelVolume(content,
+                                           data.json.args.audioChannel);
+    sendAsyncMsg('got-audio-channel-volume', {
+      id: data.json.id, successRv: volume
+    });
+  },
+
+  _recvSetAudioChannelVolume: function(data) {
+    debug("Received setAudioChannelVolume message: (" + data.json.id + ")");
+
+    acs.setAudioChannelVolume(content,
+                              data.json.args.audioChannel,
+                              data.json.args.volume);
+    sendAsyncMsg('got-set-audio-channel-volume', {
+      id: data.json.id, successRv: true
+    });
+  },
+
+  _recvGetAudioChannelMuted: function(data) {
+    debug("Received getAudioChannelMuted message: (" + data.json.id + ")");
+
+    let muted = acs.getAudioChannelMuted(content, data.json.args.audioChannel);
+    sendAsyncMsg('got-audio-channel-muted', {
+      id: data.json.id, successRv: muted
+    });
+  },
+
+  _recvSetAudioChannelMuted: function(data) {
+    debug("Received setAudioChannelMuted message: (" + data.json.id + ")");
+
+    acs.setAudioChannelMuted(content, data.json.args.audioChannel,
+                             data.json.args.muted);
+    sendAsyncMsg('got-set-audio-channel-muted', {
+      id: data.json.id, successRv: true
+    });
+  },
+
+  _recvIsAudioChannelActive: function(data) {
+    debug("Received isAudioChannelActive message: (" + data.json.id + ")");
+
+    let active = acs.isAudioChannelActive(content, data.json.args.audioChannel);
+    sendAsyncMsg('got-is-audio-channel-active', {
+      id: data.json.id, successRv: active
+    });
+  },
+  _recvGetWebManifest: Task.async(function* (data) {
+    debug(`Received GetWebManifest message: (${data.json.id})`);
+    let manifest = null;
+    let hasManifest = ManifestFinder.contentHasManifestLink(content);
+    if (hasManifest) {
+      try {
+        manifest = yield ManifestObtainer.contentObtainManifest(content);
+      } catch (e) {
+        sendAsyncMsg('got-web-manifest', {
+          id: data.json.id,
+          errorMsg: `Error fetching web manifest: ${e}.`,
+        });
+        return;
+      }
+    }
+    sendAsyncMsg('got-web-manifest', {
+      id: data.json.id,
+      successRv: manifest
+    });
+  }),
+
+  _initFinder: function() {
+    if (!this._finder) {
+      let {Finder} = Components.utils.import("resource://gre/modules/Finder.jsm", {});
+      this._finder = new Finder(docShell);
+    }
+    let listener = {
+      onMatchesCountResult: (data) => {
+        sendAsyncMsg("findchange", {
+          active: true,
+          searchString: this._finder.searchString,
+          searchLimit: this._finder.matchesCountLimit,
+          activeMatchOrdinal: data.current,
+          numberOfMatches: data.total
+        });
+        this._finder.removeResultListener(listener);
+      }
+    };
+    this._finder.addResultListener(listener);
+  },
+
+  _recvFindAll: function(data) {
+    this._initFinder();
+    let searchString = data.json.searchString;
+    this._finder.caseSensitive = data.json.caseSensitive;
+    this._finder.fastFind(searchString, false, false);
+    this._finder.requestMatchesCount(searchString, this._finder.matchesCountLimit, false);
+  },
+
+  _recvFindNext: function(data) {
+    if (!this._finder) {
+      debug("findNext() called before findAll()");
+      return;
+    }
+    this._initFinder();
+    this._finder.findAgain(data.json.backward, false, false);
+    this._finder.requestMatchesCount(this._finder.searchString, this._finder.matchesCountLimit, false);
+  },
+
+  _recvClearMatch: function(data) {
+    if (!this._finder) {
+      debug("clearMach() called before findAll()");
+      return;
+    }
+    this._finder.removeSelection();
+    sendAsyncMsg("findchange", {active: false});
+  },
+
+  _recvSetInputMethodActive: function(data) {
+    let msgData = { id: data.json.id };
+    if (!this._isContentWindowCreated) {
+      if (data.json.args.isActive) {
+        // To activate the input method, we should wait before the content
+        // window is ready.
+        this._pendingSetInputMethodActive.push(data);
+        return;
+      }
+      msgData.successRv = null;
+      sendAsyncMsg('got-set-input-method-active', msgData);
+      return;
+    }
+    // Unwrap to access webpage content.
+    let nav = XPCNativeWrapper.unwrap(content.document.defaultView.navigator);
+    if (nav.mozInputMethod) {
+      // Wrap to access the chrome-only attribute setActive.
+      new XPCNativeWrapper(nav.mozInputMethod).setActive(data.json.args.isActive);
+      msgData.successRv = null;
+    } else {
+      msgData.errorMsg = 'Cannot access mozInputMethod.';
+    }
+    sendAsyncMsg('got-set-input-method-active', msgData);
+  },
+
+  // The docShell keeps a weak reference to the progress listener, so we need
+  // to keep a strong ref to it ourselves.
+  _progressListener: {
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIWebProgressListener,
+                                           Ci.nsISupportsWeakReference]),
+    _seenLoadStart: false,
+
+    onLocationChange: function(webProgress, request, location, flags) {
+      // We get progress events from subshells here, which is kind of weird.
+      if (webProgress != docShell) {
+        return;
+      }
+
+      // Ignore locationchange events which occur before the first loadstart.
+      // These are usually about:blank loads we don't care about.
+      if (!this._seenLoadStart) {
+        return;
+      }
+
+      // Remove password and wyciwyg from uri.
+      location = Cc["@mozilla.org/docshell/urifixup;1"]
+        .getService(Ci.nsIURIFixup).createExposableURI(location);
+
+      var webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
+
+      sendAsyncMsg('locationchange', { url: location.spec,
+                                       canGoBack: webNav.canGoBack,
+                                       canGoForward: webNav.canGoForward });
+    },
+
+    onStateChange: function(webProgress, request, stateFlags, status) {
+      if (webProgress != docShell) {
+        return;
+      }
+
+      if (stateFlags & Ci.nsIWebProgressListener.STATE_START) {
+        this._seenLoadStart = true;
+        sendAsyncMsg('loadstart');
+      }
+
+      if (stateFlags & Ci.nsIWebProgressListener.STATE_STOP) {
+        let bgColor = 'transparent';
+        try {
+          bgColor = content.getComputedStyle(content.document.body)
+                           .getPropertyValue('background-color');
+        } catch (e) {}
+        sendAsyncMsg('loadend', {backgroundColor: bgColor});
+
+        switch (status) {
+          case Cr.NS_OK :
+          case Cr.NS_BINDING_ABORTED :
+            // Ignoring NS_BINDING_ABORTED, which is set when loading page is
+            // stopped.
+          case Cr.NS_ERROR_PARSED_DATA_CACHED:
+            return;
+
+          // TODO See nsDocShell::DisplayLoadError to see what extra
+          // information we should be annotating this first block of errors
+          // with. Bug 1107091.
+          case Cr.NS_ERROR_UNKNOWN_PROTOCOL :
+            sendAsyncMsg('error', { type: 'unknownProtocolFound' });
+            return;
+          case Cr.NS_ERROR_FILE_NOT_FOUND :
+            sendAsyncMsg('error', { type: 'fileNotFound' });
+            return;
+          case Cr.NS_ERROR_UNKNOWN_HOST :
+            sendAsyncMsg('error', { type: 'dnsNotFound' });
+            return;
+          case Cr.NS_ERROR_CONNECTION_REFUSED :
+            sendAsyncMsg('error', { type: 'connectionFailure' });
+            return;
+          case Cr.NS_ERROR_NET_INTERRUPT :
+            sendAsyncMsg('error', { type: 'netInterrupt' });
+            return;
+          case Cr.NS_ERROR_NET_TIMEOUT :
+            sendAsyncMsg('error', { type: 'netTimeout' });
+            return;
+          case Cr.NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION :
+            sendAsyncMsg('error', { type: 'cspBlocked' });
+            return;
+          case Cr.NS_ERROR_PHISHING_URI :
+            sendAsyncMsg('error', { type: 'deceptiveBlocked' });
+            return;
+          case Cr.NS_ERROR_MALWARE_URI :
+            sendAsyncMsg('error', { type: 'malwareBlocked' });
+            return;
+          case Cr.NS_ERROR_UNWANTED_URI :
+            sendAsyncMsg('error', { type: 'unwantedBlocked' });
+            return;
+          case Cr.NS_ERROR_FORBIDDEN_URI :
+            sendAsyncMsg('error', { type: 'forbiddenBlocked' });
+            return;
+
+          case Cr.NS_ERROR_OFFLINE :
+            sendAsyncMsg('error', { type: 'offline' });
+            return;
+          case Cr.NS_ERROR_MALFORMED_URI :
+            sendAsyncMsg('error', { type: 'malformedURI' });
+            return;
+          case Cr.NS_ERROR_REDIRECT_LOOP :
+            sendAsyncMsg('error', { type: 'redirectLoop' });
+            return;
+          case Cr.NS_ERROR_UNKNOWN_SOCKET_TYPE :
+            sendAsyncMsg('error', { type: 'unknownSocketType' });
+            return;
+          case Cr.NS_ERROR_NET_RESET :
+            sendAsyncMsg('error', { type: 'netReset' });
+            return;
+          case Cr.NS_ERROR_DOCUMENT_NOT_CACHED :
+            sendAsyncMsg('error', { type: 'notCached' });
+            return;
+          case Cr.NS_ERROR_DOCUMENT_IS_PRINTMODE :
+            sendAsyncMsg('error', { type: 'isprinting' });
+            return;
+          case Cr.NS_ERROR_PORT_ACCESS_NOT_ALLOWED :
+            sendAsyncMsg('error', { type: 'deniedPortAccess' });
+            return;
+          case Cr.NS_ERROR_UNKNOWN_PROXY_HOST :
+            sendAsyncMsg('error', { type: 'proxyResolveFailure' });
+            return;
+          case Cr.NS_ERROR_PROXY_CONNECTION_REFUSED :
+            sendAsyncMsg('error', { type: 'proxyConnectFailure' });
+            return;
+          case Cr.NS_ERROR_INVALID_CONTENT_ENCODING :
+            sendAsyncMsg('error', { type: 'contentEncodingFailure' });
+            return;
+          case Cr.NS_ERROR_REMOTE_XUL :
+            sendAsyncMsg('error', { type: 'remoteXUL' });
+            return;
+          case Cr.NS_ERROR_UNSAFE_CONTENT_TYPE :
+            sendAsyncMsg('error', { type: 'unsafeContentType' });
+            return;
+          case Cr.NS_ERROR_CORRUPTED_CONTENT :
+            sendAsyncMsg('error', { type: 'corruptedContentErrorv2' });
+            return;
+
+          default:
+            // getErrorClass() will throw if the error code passed in is not a NSS
+            // error code.
+            try {
+              let nssErrorsService = Cc['@mozilla.org/nss_errors_service;1']
+                                       .getService(Ci.nsINSSErrorsService);
+              if (nssErrorsService.getErrorClass(status)
+                    == Ci.nsINSSErrorsService.ERROR_CLASS_BAD_CERT) {
+                // XXX Is there a point firing the event if the error page is not
+                // certerror? If yes, maybe we should add a property to the
+                // event to to indicate whether there is a custom page. That would
+                // let the embedder have more control over the desired behavior.
+                let errorPage = null;
+                try {
+                  errorPage = Services.prefs.getCharPref(CERTIFICATE_ERROR_PAGE_PREF);
+                } catch (e) {}
+
+                if (errorPage == 'certerror') {
+                  sendAsyncMsg('error', { type: 'certerror' });
+                  return;
+                }
+              }
+            } catch (e) {}
+
+            sendAsyncMsg('error', { type: 'other' });
+            return;
+        }
+      }
+    },
+
+    onSecurityChange: function(webProgress, request, state) {
+      if (webProgress != docShell) {
+        return;
+      }
+
+      var securityStateDesc;
+      if (state & Ci.nsIWebProgressListener.STATE_IS_SECURE) {
+        securityStateDesc = 'secure';
+      }
+      else if (state & Ci.nsIWebProgressListener.STATE_IS_BROKEN) {
+        securityStateDesc = 'broken';
+      }
+      else if (state & Ci.nsIWebProgressListener.STATE_IS_INSECURE) {
+        securityStateDesc = 'insecure';
+      }
+      else {
+        debug("Unexpected securitychange state!");
+        securityStateDesc = '???';
+      }
+
+      var trackingStateDesc;
+      if (state & Ci.nsIWebProgressListener.STATE_LOADED_TRACKING_CONTENT) {
+        trackingStateDesc = 'loaded_tracking_content';
+      }
+      else if (state & Ci.nsIWebProgressListener.STATE_BLOCKED_TRACKING_CONTENT) {
+        trackingStateDesc = 'blocked_tracking_content';
+      }
+
+      var mixedStateDesc;
+      if (state & Ci.nsIWebProgressListener.STATE_BLOCKED_MIXED_ACTIVE_CONTENT) {
+        mixedStateDesc = 'blocked_mixed_active_content';
+      }
+      else if (state & Ci.nsIWebProgressListener.STATE_LOADED_MIXED_ACTIVE_CONTENT) {
+        // Note that STATE_LOADED_MIXED_ACTIVE_CONTENT implies STATE_IS_BROKEN
+        mixedStateDesc = 'loaded_mixed_active_content';
+      }
+
+      var isEV = !!(state & Ci.nsIWebProgressListener.STATE_IDENTITY_EV_TOPLEVEL);
+      var isTrackingContent = !!(state &
+        (Ci.nsIWebProgressListener.STATE_BLOCKED_TRACKING_CONTENT |
+        Ci.nsIWebProgressListener.STATE_LOADED_TRACKING_CONTENT));
+      var isMixedContent = !!(state &
+        (Ci.nsIWebProgressListener.STATE_BLOCKED_MIXED_ACTIVE_CONTENT |
+        Ci.nsIWebProgressListener.STATE_LOADED_MIXED_ACTIVE_CONTENT));
+
+      sendAsyncMsg('securitychange', {
+        state: securityStateDesc,
+        trackingState: trackingStateDesc,
+        mixedState: mixedStateDesc,
+        extendedValidation: isEV,
+        trackingContent: isTrackingContent,
+        mixedContent: isMixedContent,
+      });
+    },
+
+    onStatusChange: function(webProgress, request, status, message) {},
+    onProgressChange: function(webProgress, request, curSelfProgress,
+                               maxSelfProgress, curTotalProgress, maxTotalProgress) {},
+  },
+
+  // Expose the message manager for WebApps and others.
+  _messageManagerPublic: {
+    sendAsyncMessage: global.sendAsyncMessage.bind(global),
+    sendSyncMessage: global.sendSyncMessage.bind(global),
+    addMessageListener: global.addMessageListener.bind(global),
+    removeMessageListener: global.removeMessageListener.bind(global)
+  },
+
+  get messageManager() {
+    return this._messageManagerPublic;
+  }
+};
+
+var api = null;
+if ('DoPreloadPostfork' in this && typeof this.DoPreloadPostfork === 'function') {
+  // If we are preloaded, instantiate BrowserElementChild after a content
+  // process is forked.
+  this.DoPreloadPostfork(function() {
+    api = new BrowserElementChild();
+  });
+} else {
+  api = new BrowserElementChild();
+}
diff --git a/dom/browser-element/BrowserElementCopyPaste.js b/dom/browser-element/BrowserElementCopyPaste.js
new file mode 100644
index 000000000..7aa7c5148
--- /dev/null
+++ b/dom/browser-element/BrowserElementCopyPaste.js
@@ -0,0 +1,125 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- /
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+/* 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";
+
+function debug(msg) {
+  // dump("BrowserElementCopyPaste - " + msg + "\n");
+}
+
+debug("loaded");
+
+var { classes: Cc, interfaces: Ci, results: Cr, utils: Cu }  = Components;
+
+var CopyPasteAssistent = {
+  COMMAND_MAP: {
+    'cut': 'cmd_cut',
+    'copy': 'cmd_copyAndCollapseToEnd',
+    'paste': 'cmd_paste',
+    'selectall': 'cmd_selectAll'
+  },
+
+  init: function() {
+    addEventListener("mozcaretstatechanged", this,
+                     /* useCapture = */ true, /* wantsUntrusted = */ false);
+    addMessageListener("browser-element-api:call", this);
+  },
+
+  destroy: function() {
+    removeEventListener("mozcaretstatechanged", this,
+                        /* useCapture = */ true, /* wantsUntrusted = */ false);
+    removeMessageListener("browser-element-api:call", this);
+  },
+
+  handleEvent: function(event) {
+    switch (event.type) {
+      case "mozcaretstatechanged":
+        this._caretStateChangedHandler(event);
+        break;
+    }
+  },
+
+  receiveMessage: function(message) {
+    switch (message.name) {
+      case "browser-element-api:call":
+        this._browserAPIHandler(message);
+        break;
+    }
+  },
+
+  _browserAPIHandler: function(e) {
+    switch (e.data.msg_name) {
+      case 'copypaste-do-command':
+        if (this._isCommandEnabled(e.data.command)) {
+          docShell.doCommand(this.COMMAND_MAP[e.data.command]);
+        }
+        break;
+    }
+  },
+
+  _isCommandEnabled: function(cmd) {
+    let command = this.COMMAND_MAP[cmd];
+    if (!command) {
+      return false;
+    }
+
+    return docShell.isCommandEnabled(command);
+  },
+
+  _caretStateChangedHandler: function(e) {
+    e.stopPropagation();
+
+    let boundingClientRect = e.boundingClientRect;
+    let canPaste = this._isCommandEnabled("paste");
+    let zoomFactor = content.innerWidth == 0 ? 1 : content.screen.width / content.innerWidth;
+
+    let detail = {
+      rect: {
+        width: boundingClientRect ? boundingClientRect.width : 0,
+        height: boundingClientRect ? boundingClientRect.height : 0,
+        top: boundingClientRect ? boundingClientRect.top : 0,
+        bottom: boundingClientRect ? boundingClientRect.bottom : 0,
+        left: boundingClientRect ? boundingClientRect.left : 0,
+        right: boundingClientRect ? boundingClientRect.right : 0,
+      },
+      commands: {
+        canSelectAll: this._isCommandEnabled("selectall"),
+        canCut: this._isCommandEnabled("cut"),
+        canCopy: this._isCommandEnabled("copy"),
+        canPaste: this._isCommandEnabled("paste"),
+      },
+      zoomFactor: zoomFactor,
+      reason: e.reason,
+      collapsed: e.collapsed,
+      caretVisible: e.caretVisible,
+      selectionVisible: e.selectionVisible,
+      selectionEditable: e.selectionEditable,
+      selectedTextContent: e.selectedTextContent
+    };
+
+    // Get correct geometry information if we have nested iframe.
+    let currentWindow = e.target.defaultView;
+    while (currentWindow.realFrameElement) {
+      let currentRect = currentWindow.realFrameElement.getBoundingClientRect();
+      detail.rect.top += currentRect.top;
+      detail.rect.bottom += currentRect.top;
+      detail.rect.left += currentRect.left;
+      detail.rect.right += currentRect.left;
+      currentWindow = currentWindow.realFrameElement.ownerDocument.defaultView;
+
+      let targetDocShell = currentWindow
+          .QueryInterface(Ci.nsIInterfaceRequestor)
+          .getInterface(Ci.nsIWebNavigation);
+      if(targetDocShell.isMozBrowserOrApp) {
+        break;
+      }
+    }
+
+    sendAsyncMsg('caretstatechanged', detail);
+  },
+};
+
+CopyPasteAssistent.init();
diff --git a/dom/browser-element/BrowserElementParent.cpp b/dom/browser-element/BrowserElementParent.cpp
new file mode 100644
index 000000000..fda9348fd
--- /dev/null
+++ b/dom/browser-element/BrowserElementParent.cpp
@@ -0,0 +1,317 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=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/. */
+
+#include "TabParent.h"
+
+// TabParent.h transitively includes <windows.h>, which does
+//   #define CreateEvent CreateEventW
+// That messes up our call to EventDispatcher::CreateEvent below.
+
+#ifdef CreateEvent
+#undef CreateEvent
+#endif
+
+#include "BrowserElementParent.h"
+#include "BrowserElementAudioChannel.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/dom/HTMLIFrameElement.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsVariant.h"
+#include "mozilla/dom/BrowserElementDictionariesBinding.h"
+#include "mozilla/dom/CustomEvent.h"
+#include "mozilla/layout/RenderFrameParent.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::layers;
+using namespace mozilla::layout;
+
+namespace {
+
+using mozilla::BrowserElementParent;
+/**
+ * Create an <iframe mozbrowser> owned by the same document as
+ * aOpenerFrameElement.
+ */
+already_AddRefed<HTMLIFrameElement>
+CreateIframe(Element* aOpenerFrameElement, const nsAString& aName, bool aRemote)
+{
+  nsNodeInfoManager *nodeInfoManager =
+    aOpenerFrameElement->OwnerDoc()->NodeInfoManager();
+
+  RefPtr<NodeInfo> nodeInfo =
+    nodeInfoManager->GetNodeInfo(nsGkAtoms::iframe,
+                                 /* aPrefix = */ nullptr,
+                                 kNameSpaceID_XHTML,
+                                 nsIDOMNode::ELEMENT_NODE);
+
+  RefPtr<HTMLIFrameElement> popupFrameElement =
+    static_cast<HTMLIFrameElement*>(
+      NS_NewHTMLIFrameElement(nodeInfo.forget(), mozilla::dom::NOT_FROM_PARSER));
+
+  popupFrameElement->SetMozbrowser(true);
+
+  // Copy the opener frame's mozapp attribute to the popup frame.
+  if (aOpenerFrameElement->HasAttr(kNameSpaceID_None, nsGkAtoms::mozapp)) {
+    nsAutoString mozapp;
+    aOpenerFrameElement->GetAttr(kNameSpaceID_None, nsGkAtoms::mozapp, mozapp);
+    popupFrameElement->SetAttr(kNameSpaceID_None, nsGkAtoms::mozapp,
+                               mozapp, /* aNotify = */ false);
+  }
+
+  // Copy the opener frame's parentApp attribute to the popup frame.
+  if (aOpenerFrameElement->HasAttr(kNameSpaceID_None, nsGkAtoms::parentapp)) {
+    nsAutoString parentApp;
+    aOpenerFrameElement->GetAttr(kNameSpaceID_None, nsGkAtoms::parentapp,
+                                 parentApp);
+    popupFrameElement->SetAttr(kNameSpaceID_None, nsGkAtoms::parentapp,
+                               parentApp, /* aNotify = */ false);
+  }
+
+  // Copy the window name onto the iframe.
+  popupFrameElement->SetAttr(kNameSpaceID_None, nsGkAtoms::name,
+                             aName, /* aNotify = */ false);
+
+  // Indicate whether the iframe is should be remote.
+  popupFrameElement->SetAttr(kNameSpaceID_None, nsGkAtoms::Remote,
+                             aRemote ? NS_LITERAL_STRING("true") :
+                                       NS_LITERAL_STRING("false"),
+                             /* aNotify = */ false);
+
+  // Copy the opener frame's mozprivatebrowsing attribute to the popup frame.
+  nsAutoString mozprivatebrowsing;
+  if (aOpenerFrameElement->GetAttr(kNameSpaceID_None, nsGkAtoms::mozprivatebrowsing,
+                                   mozprivatebrowsing)) {
+    popupFrameElement->SetAttr(kNameSpaceID_None, nsGkAtoms::mozprivatebrowsing,
+                               mozprivatebrowsing, /* aNotify = */ false);
+  }
+
+  return popupFrameElement.forget();
+}
+
+bool
+DispatchCustomDOMEvent(Element* aFrameElement, const nsAString& aEventName,
+                       JSContext* cx, JS::Handle<JS::Value> aDetailValue,
+                       nsEventStatus *aStatus)
+{
+  NS_ENSURE_TRUE(aFrameElement, false);
+  nsIPresShell *shell = aFrameElement->OwnerDoc()->GetShell();
+  RefPtr<nsPresContext> presContext;
+  if (shell) {
+    presContext = shell->GetPresContext();
+  }
+
+  RefPtr<CustomEvent> event =
+    NS_NewDOMCustomEvent(aFrameElement, presContext, nullptr);
+
+  ErrorResult res;
+  event->InitCustomEvent(cx,
+                         aEventName,
+                         /* aCanBubble = */ true,
+                         /* aCancelable = */ true,
+                         aDetailValue,
+                         res);
+  if (res.Failed()) {
+    return false;
+  }
+  event->SetTrusted(true);
+  // Dispatch the event.
+  // We don't initialize aStatus here, as our callers have already done so.
+  nsresult rv =
+    EventDispatcher::DispatchDOMEvent(aFrameElement, nullptr, event,
+                                      presContext, aStatus);
+  return NS_SUCCEEDED(rv);
+}
+
+} // namespace
+
+namespace mozilla {
+
+/**
+ * Dispatch a mozbrowseropenwindow event to the given opener frame element.
+ * The "popup iframe" (event.detail.frameElement) will be |aPopupFrameElement|.
+ *
+ * Returns true iff there were no unexpected failures and the window.open call
+ * was accepted by the embedder.
+ */
+/*static*/
+BrowserElementParent::OpenWindowResult
+BrowserElementParent::DispatchOpenWindowEvent(Element* aOpenerFrameElement,
+                        Element* aPopupFrameElement,
+                        const nsAString& aURL,
+                        const nsAString& aName,
+                        const nsAString& aFeatures)
+{
+  // Dispatch a CustomEvent at aOpenerFrameElement with a detail object
+  // (OpenWindowEventDetail) containing aPopupFrameElement, aURL, aName, and
+  // aFeatures.
+
+  // Create the event's detail object.
+  OpenWindowEventDetail detail;
+  if (aURL.IsEmpty()) {
+    // URL should never be empty. Assign about:blank as default.
+    detail.mUrl = NS_LITERAL_STRING("about:blank");
+  } else {
+    detail.mUrl = aURL;
+  }
+  detail.mName = aName;
+  detail.mFeatures = aFeatures;
+  detail.mFrameElement = aPopupFrameElement;
+
+  AutoJSContext cx;
+  JS::Rooted<JS::Value> val(cx);
+
+  nsIGlobalObject* sgo = aPopupFrameElement->OwnerDoc()->GetScopeObject();
+  if (!sgo) {
+    return BrowserElementParent::OPEN_WINDOW_IGNORED;
+  }
+
+  JS::Rooted<JSObject*> global(cx, sgo->GetGlobalJSObject());
+  JSAutoCompartment ac(cx, global);
+  if (!ToJSValue(cx, detail, &val)) {
+    MOZ_CRASH("Failed to convert dictionary to JS::Value due to OOM.");
+    return BrowserElementParent::OPEN_WINDOW_IGNORED;
+  }
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+  bool dispatchSucceeded =
+    DispatchCustomDOMEvent(aOpenerFrameElement,
+                           NS_LITERAL_STRING("mozbrowseropenwindow"),
+                           cx,
+                           val, &status);
+
+  if (dispatchSucceeded) {
+    if (aPopupFrameElement->IsInUncomposedDoc()) {
+      return BrowserElementParent::OPEN_WINDOW_ADDED;
+    } else if (status == nsEventStatus_eConsumeNoDefault) {
+      // If the frame was not added to a document, report to callers whether
+      // preventDefault was called on or not
+      return BrowserElementParent::OPEN_WINDOW_CANCELLED;
+    }
+  }
+
+  return BrowserElementParent::OPEN_WINDOW_IGNORED;
+}
+
+/*static*/
+BrowserElementParent::OpenWindowResult
+BrowserElementParent::OpenWindowOOP(TabParent* aOpenerTabParent,
+                                    TabParent* aPopupTabParent,
+                                    PRenderFrameParent* aRenderFrame,
+                                    const nsAString& aURL,
+                                    const nsAString& aName,
+                                    const nsAString& aFeatures,
+                                    TextureFactoryIdentifier* aTextureFactoryIdentifier,
+                                    uint64_t* aLayersId)
+{
+  // Create an iframe owned by the same document which owns openerFrameElement.
+  nsCOMPtr<Element> openerFrameElement = aOpenerTabParent->GetOwnerElement();
+  NS_ENSURE_TRUE(openerFrameElement,
+                 BrowserElementParent::OPEN_WINDOW_IGNORED);
+  RefPtr<HTMLIFrameElement> popupFrameElement =
+    CreateIframe(openerFrameElement, aName, /* aRemote = */ true);
+
+  // Normally an <iframe> element will try to create a frameLoader when the
+  // page touches iframe.contentWindow or sets iframe.src.
+  //
+  // But in our case, we want to delay the creation of the frameLoader until
+  // we've verified that the popup has gone through successfully.  If the popup
+  // is "blocked" by the embedder, we don't want to load the popup's url.
+  //
+  // Therefore we call DisallowCreateFrameLoader() on the element and call
+  // AllowCreateFrameLoader() only after we've verified that the popup was
+  // allowed.
+  popupFrameElement->DisallowCreateFrameLoader();
+
+  OpenWindowResult opened =
+    DispatchOpenWindowEvent(openerFrameElement, popupFrameElement,
+                            aURL, aName, aFeatures);
+
+  if (opened != BrowserElementParent::OPEN_WINDOW_ADDED) {
+    return opened;
+  }
+
+  // The popup was not blocked, so hook up the frame element and the popup tab
+  // parent, and return success.
+  aPopupTabParent->SetOwnerElement(popupFrameElement);
+  popupFrameElement->AllowCreateFrameLoader();
+  popupFrameElement->CreateRemoteFrameLoader(aPopupTabParent);
+
+  RenderFrameParent* rfp = static_cast<RenderFrameParent*>(aRenderFrame);
+  if (!aPopupTabParent->SetRenderFrame(rfp) ||
+      !aPopupTabParent->GetRenderFrameInfo(aTextureFactoryIdentifier, aLayersId)) {
+    return BrowserElementParent::OPEN_WINDOW_IGNORED;
+  }
+
+  return opened;
+}
+
+/* static */
+BrowserElementParent::OpenWindowResult
+BrowserElementParent::OpenWindowInProcess(nsPIDOMWindowOuter* aOpenerWindow,
+                                          nsIURI* aURI,
+                                          const nsAString& aName,
+                                          const nsACString& aFeatures,
+                                          bool aForceNoOpener,
+                                          mozIDOMWindowProxy** aReturnWindow)
+{
+  *aReturnWindow = nullptr;
+
+  // If we call window.open from an <iframe> inside an <iframe mozbrowser>,
+  // it's as though the top-level document inside the <iframe mozbrowser>
+  // called window.open.  (Indeed, in the OOP case, the inner <iframe> lives
+  // out-of-process, so we couldn't touch it if we tried.)
+  //
+  // GetScriptableTop gets us the <iframe mozbrowser>'s window; we'll use its
+  // frame element, rather than aOpenerWindow's frame element, as our "opener
+  // frame element" below.
+  nsCOMPtr<nsPIDOMWindowOuter> win = aOpenerWindow->GetScriptableTop();
+
+  nsCOMPtr<Element> openerFrameElement = win->GetFrameElementInternal();
+  NS_ENSURE_TRUE(openerFrameElement, BrowserElementParent::OPEN_WINDOW_IGNORED);
+
+
+  RefPtr<HTMLIFrameElement> popupFrameElement =
+    CreateIframe(openerFrameElement, aName, /* aRemote = */ false);
+  NS_ENSURE_TRUE(popupFrameElement, BrowserElementParent::OPEN_WINDOW_IGNORED);
+
+  nsAutoCString spec;
+  if (aURI) {
+    aURI->GetSpec(spec);
+  }
+
+  if (!aForceNoOpener) {
+    ErrorResult res;
+    popupFrameElement->PresetOpenerWindow(aOpenerWindow, res);
+    MOZ_ASSERT(!res.Failed());
+  }
+
+  OpenWindowResult opened =
+    DispatchOpenWindowEvent(openerFrameElement, popupFrameElement,
+                            NS_ConvertUTF8toUTF16(spec),
+                            aName,
+                            NS_ConvertUTF8toUTF16(aFeatures));
+
+  if (opened != BrowserElementParent::OPEN_WINDOW_ADDED) {
+    return opened;
+  }
+
+  // Return popupFrameElement's window.
+  RefPtr<nsFrameLoader> frameLoader = popupFrameElement->GetFrameLoader();
+  NS_ENSURE_TRUE(frameLoader, BrowserElementParent::OPEN_WINDOW_IGNORED);
+
+  nsCOMPtr<nsIDocShell> docshell;
+  frameLoader->GetDocShell(getter_AddRefs(docshell));
+  NS_ENSURE_TRUE(docshell, BrowserElementParent::OPEN_WINDOW_IGNORED);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = docshell->GetWindow();
+  window.forget(aReturnWindow);
+
+  return !!*aReturnWindow ? opened : BrowserElementParent::OPEN_WINDOW_CANCELLED;
+}
+
+} // namespace mozilla
diff --git a/dom/browser-element/BrowserElementParent.h b/dom/browser-element/BrowserElementParent.h
new file mode 100644
index 000000000..428884f97
--- /dev/null
+++ b/dom/browser-element/BrowserElementParent.h
@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=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_BrowserElementHelpers_h
+#define mozilla_BrowserElementHelpers_h
+
+#include "nsAString.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/gfx/Rect.h"
+#include "Units.h"
+#include "mozilla/dom/Element.h"
+
+class nsIDOMWindow;
+class nsIURI;
+
+namespace mozilla {
+
+namespace dom {
+class TabParent;
+} // namespace dom
+
+namespace layers {
+struct TextureFactoryIdentifier;
+} // namespace layers
+
+namespace layout {
+class PRenderFrameParent;
+} // namespace layout
+
+/**
+ * BrowserElementParent implements a portion of the parent-process side of
+ * <iframe mozbrowser>.
+ *
+ * Most of the parent-process side of <iframe mozbrowser> is implemented in
+ * BrowserElementParent.js.  This file implements the few parts of this
+ * functionality which must be written in C++.
+ *
+ * We don't communicate with the JS code that lives in BrowserElementParent.js;
+ * the JS and C++ parts are completely separate.
+ */
+class BrowserElementParent
+{
+public:
+
+  /**
+   * Possible results from a window.open call.
+   * ADDED     - The frame was added to a document (i.e. handled by the embedder).
+   * IGNORED   - The frame was not added to a document and the embedder didn't
+   *             call preventDefault() to prevent the platform from handling the call.
+   * CANCELLED - The frame was not added to a document, but the embedder still
+   *             called preventDefault() to prevent the platform from handling the call.
+   */
+
+  enum OpenWindowResult {
+    OPEN_WINDOW_ADDED,
+    OPEN_WINDOW_IGNORED,
+    OPEN_WINDOW_CANCELLED
+  };
+
+  /**
+   * Handle a window.open call from an out-of-process <iframe mozbrowser>.
+   *
+   * window.open inside <iframe mozbrowser> doesn't actually open a new
+   * top-level window.  Instead, the "embedder" (the document which contains
+   * the <iframe mozbrowser> whose content called window.open) gets the
+   * opportunity to place a new <iframe mozbrowser> in the DOM somewhere.  This
+   * new "popup" iframe acts as the opened window.
+   *
+   * This method proceeds in three steps.
+   *
+   * 1) We fire a mozbrowseropenwindow CustomEvent on the opener
+   *    iframe element.  This event's detail is an instance of
+   *    OpenWindowEventDetail.
+   *
+   * 2) The embedder (the document which contains the opener iframe) can accept
+   *    the window.open request by inserting event.detail.frameElement (an iframe
+   *    element) into the DOM somewhere.
+   *
+   * 3) If the embedder accepted the window.open request, we return true and
+   *    set aPopupTabParent's frame element to event.detail.frameElement.
+   *    Otherwise, we return false.
+   *
+   * @param aURL the URL the new window should load.  The empty string is
+   *             allowed.
+   * @param aOpenerTabParent the TabParent whose TabChild called window.open.
+   * @param aPopupTabParent the TabParent inside which the opened window will
+   *                        live.
+   * @return an OpenWindowresult that describes whether the embedder added the
+   *         frame to a document and whether it called preventDefault to prevent
+   *         the platform from handling the open request.
+   */
+  static OpenWindowResult
+  OpenWindowOOP(dom::TabParent* aOpenerTabParent,
+                dom::TabParent* aPopupTabParent,
+                layout::PRenderFrameParent* aRenderFrame,
+                const nsAString& aURL,
+                const nsAString& aName,
+                const nsAString& aFeatures,
+                layers::TextureFactoryIdentifier* aTextureFactoryIdentifier,
+                uint64_t* aLayersId);
+
+  /**
+   * Handle a window.open call from an in-process <iframe mozbrowser>.
+   *
+   * (These parameter types are silly, but they match what our caller has in
+   * hand.  Feel free to add an override, if they are inconvenient to you.)
+   *
+   * @param aURI the URI the new window should load.  May be null.
+   * @return an OpenWindowResult that describes whether the browser added the
+   *         frame to a document or whether they called preventDefault to prevent
+   *         the platform from handling the open request
+   */
+  static OpenWindowResult
+  OpenWindowInProcess(nsPIDOMWindowOuter* aOpenerWindow,
+                      nsIURI* aURI,
+                      const nsAString& aName,
+                      const nsACString& aFeatures,
+                      bool aForceNoOpener,
+                      mozIDOMWindowProxy** aReturnWindow);
+
+private:
+  static OpenWindowResult
+  DispatchOpenWindowEvent(dom::Element* aOpenerFrameElement,
+                          dom::Element* aPopupFrameElement,
+                          const nsAString& aURL,
+                          const nsAString& aName,
+                          const nsAString& aFeatures);
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/dom/browser-element/BrowserElementParent.js b/dom/browser-element/BrowserElementParent.js
new file mode 100644
index 000000000..67d05f0ab
--- /dev/null
+++ b/dom/browser-element/BrowserElementParent.js
@@ -0,0 +1,1202 @@
+/* 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";
+
+var Cu = Components.utils;
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+
+/* BrowserElementParent injects script to listen for certain events in the
+ * child.  We then listen to messages from the child script and take
+ * appropriate action here in the parent.
+ */
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/BrowserElementPromptService.jsm");
+
+function debug(msg) {
+  //dump("BrowserElementParent - " + msg + "\n");
+}
+
+function getIntPref(prefName, def) {
+  try {
+    return Services.prefs.getIntPref(prefName);
+  }
+  catch(err) {
+    return def;
+  }
+}
+
+function handleWindowEvent(e) {
+  if (this._browserElementParents) {
+    let beps = ThreadSafeChromeUtils.nondeterministicGetWeakMapKeys(this._browserElementParents);
+    beps.forEach(bep => bep._handleOwnerEvent(e));
+  }
+}
+
+function defineNoReturnMethod(fn) {
+  return function method() {
+    if (!this._domRequestReady) {
+      // Remote browser haven't been created, we just queue the API call.
+      let args = Array.slice(arguments);
+      args.unshift(this);
+      this._pendingAPICalls.push(method.bind.apply(fn, args));
+      return;
+    }
+    if (this._isAlive()) {
+      fn.apply(this, arguments);
+    }
+  };
+}
+
+function defineDOMRequestMethod(msgName) {
+  return function() {
+    return this._sendDOMRequest(msgName);
+  };
+}
+
+function BrowserElementParentProxyCallHandler() {
+}
+
+BrowserElementParentProxyCallHandler.prototype = {
+  _frameElement: null,
+  _mm: null,
+
+  MOZBROWSER_EVENT_NAMES: Object.freeze([
+    "loadstart", "loadend", "close", "error", "firstpaint",
+    "documentfirstpaint", "audioplaybackchange",
+    "contextmenu", "securitychange", "locationchange",
+    "iconchange", "scrollareachanged", "titlechange",
+    "opensearch", "manifestchange", "metachange",
+    "resize", "scrollviewchange",
+    "caretstatechanged", "activitydone", "scroll", "opentab"]),
+
+  init: function(frameElement, mm) {
+    this._frameElement = frameElement;
+    this._mm = mm;
+    this.innerWindowIDSet = new Set();
+
+    mm.addMessageListener("browser-element-api:proxy-call", this);
+  },
+
+  // Message manager callback receives messages from BrowserElementProxy.js
+  receiveMessage: function(mmMsg) {
+    let data = mmMsg.json;
+
+    let mm;
+    try {
+      mm = mmMsg.target.QueryInterface(Ci.nsIFrameLoaderOwner)
+                     .frameLoader.messageManager;
+    } catch(e) {
+      mm = mmMsg.target;
+    }
+    if (!mm.assertPermission("browser:embedded-system-app")) {
+      dump("BrowserElementParent.js: Method call " + data.methodName +
+        " from a content process with no 'browser:embedded-system-app'" +
+        " privileges.\n");
+      return;
+    }
+
+    switch (data.methodName) {
+      case '_proxyInstanceInit':
+        if (!this.innerWindowIDSet.size) {
+          this._attachEventListeners();
+        }
+        this.innerWindowIDSet.add(data.innerWindowID);
+
+        break;
+
+      case '_proxyInstanceUninit':
+        this.innerWindowIDSet.delete(data.innerWindowID);
+        if (!this.innerWindowIDSet.size) {
+          this._detachEventListeners();
+        }
+
+        break;
+
+      // void methods
+      case 'setVisible':
+      case 'setActive':
+      case 'sendMouseEvent':
+      case 'sendTouchEvent':
+      case 'goBack':
+      case 'goForward':
+      case 'reload':
+      case 'stop':
+      case 'zoom':
+      case 'findAll':
+      case 'findNext':
+      case 'clearMatch':
+      case 'mute':
+      case 'unmute':
+      case 'setVolume':
+        this._frameElement[data.methodName]
+          .apply(this._frameElement, data.args);
+
+        break;
+
+      // DOMRequest methods
+      case 'getVisible':
+      case 'download':
+      case 'purgeHistory':
+      case 'getCanGoBack':
+      case 'getCanGoForward':
+      case 'getContentDimensions':
+      case 'setInputMethodActive':
+      case 'executeScript':
+      case 'getMuted':
+      case 'getVolume':
+        let req = this._frameElement[data.methodName]
+          .apply(this._frameElement, data.args);
+        req.onsuccess = () => {
+          this._sendToProxy({
+            domRequestId: data.domRequestId,
+            innerWindowID: data.innerWindowID,
+            result: req.result
+          });
+        };
+        req.onerror = () => {
+          this._sendToProxy({
+            domRequestId: data.domRequestId,
+            innerWindowID: data.innerWindowID,
+            err: req.error
+          });
+        };
+
+        break;
+
+      // Not implemented
+      case 'getActive': // Sync ???
+      case 'addNextPaintListener': // Takes a callback
+      case 'removeNextPaintListener': // Takes a callback
+      case 'getScreenshot': // Need to pass a blob back
+        dump("BrowserElementParentProxyCallHandler Error:" +
+          "Attempt to call unimplemented method " + data.methodName + ".\n");
+        break;
+
+      default:
+        dump("BrowserElementParentProxyCallHandler Error:" +
+          "Attempt to call non-exist method " + data.methodName + ".\n");
+        break;
+    }
+  },
+
+  // Receving events from the frame element and forward it.
+  handleEvent: function(evt) {
+    // Ignore the events from nested mozbrowser iframes
+    if (evt.target !== this._frameElement) {
+      return;
+    }
+
+    let detailString;
+    try {
+      detailString = JSON.stringify(evt.detail);
+    } catch (e) {
+      dump("BrowserElementParentProxyCallHandler Error:" +
+        "Event detail of " + evt.type + " can't be stingified.\n");
+      return;
+    }
+
+    this.innerWindowIDSet.forEach((innerWindowID) => {
+      this._sendToProxy({
+        eventName: evt.type,
+        innerWindowID: innerWindowID,
+        eventDetailString: detailString
+      });
+    });
+  },
+
+  _sendToProxy: function(data) {
+    this._mm.sendAsyncMessage("browser-element-api:proxy", data);
+  },
+
+  _attachEventListeners: function() {
+    this.MOZBROWSER_EVENT_NAMES.forEach(function(eventName) {
+      this._frameElement.addEventListener(
+        "mozbrowser" + eventName, this, true);
+    }, this);
+  },
+
+  _detachEventListeners: function() {
+    this.MOZBROWSER_EVENT_NAMES.forEach(function(eventName) {
+      this._frameElement.removeEventListener(
+        "mozbrowser" + eventName, this, true);
+    }, this);
+  }
+};
+
+function BrowserElementParent() {
+  debug("Creating new BrowserElementParent object");
+  this._domRequestCounter = 0;
+  this._domRequestReady = false;
+  this._pendingAPICalls = [];
+  this._pendingDOMRequests = {};
+  this._pendingSetInputMethodActive = [];
+  this._nextPaintListeners = [];
+  this._pendingDOMFullscreen = false;
+
+  Services.obs.addObserver(this, 'oop-frameloader-crashed', /* ownsWeak = */ true);
+  Services.obs.addObserver(this, 'ask-children-to-execute-copypaste-command', /* ownsWeak = */ true);
+  Services.obs.addObserver(this, 'back-docommand', /* ownsWeak = */ true);
+
+  this.proxyCallHandler = new BrowserElementParentProxyCallHandler();
+}
+
+BrowserElementParent.prototype = {
+
+  classDescription: "BrowserElementAPI implementation",
+  classID: Components.ID("{9f171ac4-0939-4ef8-b360-3408aedc3060}"),
+  contractID: "@mozilla.org/dom/browser-element-api;1",
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIBrowserElementAPI,
+                                         Ci.nsIObserver,
+                                         Ci.nsISupportsWeakReference]),
+
+  setFrameLoader: function(frameLoader) {
+    debug("Setting frameLoader");
+    this._frameLoader = frameLoader;
+    this._frameElement = frameLoader.QueryInterface(Ci.nsIFrameLoader).ownerElement;
+    if (!this._frameElement) {
+      debug("No frame element?");
+      return;
+    }
+    // Listen to visibilitychange on the iframe's owner window, and forward
+    // changes down to the child.  We want to do this while registering as few
+    // visibilitychange listeners on _window as possible, because such a listener
+    // may live longer than this BrowserElementParent object.
+    //
+    // To accomplish this, we register just one listener on the window, and have
+    // it reference a WeakMap whose keys are all the BrowserElementParent objects
+    // on the window.  Then when the listener fires, we iterate over the
+    // WeakMap's keys (which we can do, because we're chrome) to notify the
+    // BrowserElementParents.
+    if (!this._window._browserElementParents) {
+      this._window._browserElementParents = new WeakMap();
+      let handler = handleWindowEvent.bind(this._window);
+      let windowEvents = ['visibilitychange', 'fullscreenchange'];
+      let els = Cc["@mozilla.org/eventlistenerservice;1"]
+                  .getService(Ci.nsIEventListenerService);
+      for (let event of windowEvents) {
+        els.addSystemEventListener(this._window, event, handler,
+                                   /* useCapture = */ true);
+      }
+    }
+
+    this._window._browserElementParents.set(this, null);
+
+    // Insert ourself into the prompt service.
+    BrowserElementPromptService.mapFrameToBrowserElementParent(this._frameElement, this);
+    this._setupMessageListener();
+
+    this.proxyCallHandler.init(
+      this._frameElement, this._frameLoader.messageManager);
+  },
+
+  destroyFrameScripts() {
+    debug("Destroying frame scripts");
+    this._mm.sendAsyncMessage("browser-element-api:destroy");
+  },
+
+  _runPendingAPICall: function() {
+    if (!this._pendingAPICalls) {
+      return;
+    }
+    for (let i = 0; i < this._pendingAPICalls.length; i++) {
+      try {
+        this._pendingAPICalls[i]();
+      } catch (e) {
+        // throw the expections from pending functions.
+        debug('Exception when running pending API call: ' +  e);
+      }
+    }
+    delete this._pendingAPICalls;
+  },
+
+  _setupMessageListener: function() {
+    this._mm = this._frameLoader.messageManager;
+    this._mm.addMessageListener('browser-element-api:call', this);
+    this._mm.loadFrameScript("chrome://global/content/extensions.js", true);
+  },
+
+  receiveMessage: function(aMsg) {
+    if (!this._isAlive()) {
+      return;
+    }
+
+    // Messages we receive are handed to functions which take a (data) argument,
+    // where |data| is the message manager's data object.
+    // We use a single message and dispatch to various function based
+    // on data.msg_name
+    let mmCalls = {
+      "hello": this._recvHello,
+      "loadstart": this._fireProfiledEventFromMsg,
+      "loadend": this._fireProfiledEventFromMsg,
+      "close": this._fireEventFromMsg,
+      "error": this._fireEventFromMsg,
+      "firstpaint": this._fireProfiledEventFromMsg,
+      "documentfirstpaint": this._fireProfiledEventFromMsg,
+      "nextpaint": this._recvNextPaint,
+      "got-purge-history": this._gotDOMRequestResult,
+      "got-screenshot": this._gotDOMRequestResult,
+      "got-contentdimensions": this._gotDOMRequestResult,
+      "got-can-go-back": this._gotDOMRequestResult,
+      "got-can-go-forward": this._gotDOMRequestResult,
+      "got-muted": this._gotDOMRequestResult,
+      "got-volume": this._gotDOMRequestResult,
+      "requested-dom-fullscreen": this._requestedDOMFullscreen,
+      "fullscreen-origin-change": this._fullscreenOriginChange,
+      "exit-dom-fullscreen": this._exitDomFullscreen,
+      "got-visible": this._gotDOMRequestResult,
+      "visibilitychange": this._childVisibilityChange,
+      "got-set-input-method-active": this._gotDOMRequestResult,
+      "scrollviewchange": this._handleScrollViewChange,
+      "caretstatechanged": this._handleCaretStateChanged,
+      "findchange": this._handleFindChange,
+      "execute-script-done": this._gotDOMRequestResult,
+      "got-audio-channel-volume": this._gotDOMRequestResult,
+      "got-set-audio-channel-volume": this._gotDOMRequestResult,
+      "got-audio-channel-muted": this._gotDOMRequestResult,
+      "got-set-audio-channel-muted": this._gotDOMRequestResult,
+      "got-is-audio-channel-active": this._gotDOMRequestResult,
+      "got-web-manifest": this._gotDOMRequestResult,
+    };
+
+    let mmSecuritySensitiveCalls = {
+      "audioplaybackchange": this._fireEventFromMsg,
+      "showmodalprompt": this._handleShowModalPrompt,
+      "contextmenu": this._fireCtxMenuEvent,
+      "securitychange": this._fireEventFromMsg,
+      "locationchange": this._fireEventFromMsg,
+      "iconchange": this._fireEventFromMsg,
+      "scrollareachanged": this._fireEventFromMsg,
+      "titlechange": this._fireProfiledEventFromMsg,
+      "opensearch": this._fireEventFromMsg,
+      "manifestchange": this._fireEventFromMsg,
+      "metachange": this._fireEventFromMsg,
+      "resize": this._fireEventFromMsg,
+      "activitydone": this._fireEventFromMsg,
+      "scroll": this._fireEventFromMsg,
+      "opentab": this._fireEventFromMsg
+    };
+
+    if (aMsg.data.msg_name in mmCalls) {
+      return mmCalls[aMsg.data.msg_name].apply(this, arguments);
+    } else if (aMsg.data.msg_name in mmSecuritySensitiveCalls) {
+      return mmSecuritySensitiveCalls[aMsg.data.msg_name].apply(this, arguments);
+    }
+  },
+
+  _removeMessageListener: function() {
+    this._mm.removeMessageListener('browser-element-api:call', this);
+  },
+
+  /**
+   * You shouldn't touch this._frameElement or this._window if _isAlive is
+   * false.  (You'll likely get an exception if you do.)
+   */
+  _isAlive: function() {
+    return !Cu.isDeadWrapper(this._frameElement) &&
+           !Cu.isDeadWrapper(this._frameElement.ownerDocument) &&
+           !Cu.isDeadWrapper(this._frameElement.ownerDocument.defaultView);
+  },
+
+  get _window() {
+    return this._frameElement.ownerDocument.defaultView;
+  },
+
+  get _windowUtils() {
+    return this._window.QueryInterface(Ci.nsIInterfaceRequestor)
+                       .getInterface(Ci.nsIDOMWindowUtils);
+  },
+
+  promptAuth: function(authDetail, callback) {
+    let evt;
+    let self = this;
+    let callbackCalled = false;
+    let cancelCallback = function() {
+      if (!callbackCalled) {
+        callbackCalled = true;
+        callback(false, null, null);
+      }
+    };
+
+    // We don't handle password-only prompts.
+    if (authDetail.isOnlyPassword) {
+      cancelCallback();
+      return;
+    }
+
+    /* username and password */
+    let detail = {
+      host:     authDetail.host,
+      path:     authDetail.path,
+      realm:    authDetail.realm,
+      isProxy:  authDetail.isProxy
+    };
+
+    evt = this._createEvent('usernameandpasswordrequired', detail,
+                            /* cancelable */ true);
+    Cu.exportFunction(function(username, password) {
+      if (callbackCalled)
+        return;
+      callbackCalled = true;
+      callback(true, username, password);
+    }, evt.detail, { defineAs: 'authenticate' });
+
+    Cu.exportFunction(cancelCallback, evt.detail, { defineAs: 'cancel' });
+
+    this._frameElement.dispatchEvent(evt);
+
+    if (!evt.defaultPrevented) {
+      cancelCallback();
+    }
+  },
+
+  _sendAsyncMsg: function(msg, data) {
+    try {
+      if (!data) {
+        data = { };
+      }
+
+      data.msg_name = msg;
+      this._mm.sendAsyncMessage('browser-element-api:call', data);
+    } catch (e) {
+      return false;
+    }
+    return true;
+  },
+
+  _recvHello: function() {
+    debug("recvHello");
+
+    // Inform our child if our owner element's document is invisible.  Note
+    // that we must do so here, rather than in the BrowserElementParent
+    // constructor, because the BrowserElementChild may not be initialized when
+    // we run our constructor.
+    if (this._window.document.hidden) {
+      this._ownerVisibilityChange();
+    }
+
+    if (!this._domRequestReady) {
+      // At least, one message listener such as for hello is registered.
+      // So we can use sendAsyncMessage now.
+      this._domRequestReady = true;
+      this._runPendingAPICall();
+    }
+  },
+
+  _fireCtxMenuEvent: function(data) {
+    let detail = data.json;
+    let evtName = detail.msg_name;
+
+    debug('fireCtxMenuEventFromMsg: ' + evtName + ' ' + detail);
+    let evt = this._createEvent(evtName, detail, /* cancellable */ true);
+
+    if (detail.contextmenu) {
+      var self = this;
+      Cu.exportFunction(function(id) {
+        self._sendAsyncMsg('fire-ctx-callback', {menuitem: id});
+      }, evt.detail, { defineAs: 'contextMenuItemSelected' });
+    }
+
+    // The embedder may have default actions on context menu events, so
+    // we fire a context menu event even if the child didn't define a
+    // custom context menu
+    return !this._frameElement.dispatchEvent(evt);
+  },
+
+  /**
+   * add profiler marker for each event fired.
+   */
+  _fireProfiledEventFromMsg: function(data) {
+    if (Services.profiler !== undefined) {
+      Services.profiler.AddMarker(data.json.msg_name);
+    }
+    this._fireEventFromMsg(data);
+  },
+
+  /**
+   * Fire either a vanilla or a custom event, depending on the contents of
+   * |data|.
+   */
+  _fireEventFromMsg: function(data) {
+    let detail = data.json;
+    let name = detail.msg_name;
+
+    // For events that send a "_payload_" property, we just want to transmit
+    // this in the event.
+    if ("_payload_" in detail) {
+      detail = detail._payload_;
+    }
+
+    debug('fireEventFromMsg: ' + name + ', ' + JSON.stringify(detail));
+    let evt = this._createEvent(name, detail,
+                                /* cancelable = */ false);
+    this._frameElement.dispatchEvent(evt);
+  },
+
+  _handleShowModalPrompt: function(data) {
+    // Fire a showmodalprmopt event on the iframe.  When this method is called,
+    // the child is spinning in a nested event loop waiting for an
+    // unblock-modal-prompt message.
+    //
+    // If the embedder calls preventDefault() on the showmodalprompt event,
+    // we'll block the child until event.detail.unblock() is called.
+    //
+    // Otherwise, if preventDefault() is not called, we'll send the
+    // unblock-modal-prompt message to the child as soon as the event is done
+    // dispatching.
+
+    let detail = data.json;
+    debug('handleShowPrompt ' + JSON.stringify(detail));
+
+    // Strip off the windowID property from the object we send along in the
+    // event.
+    let windowID = detail.windowID;
+    delete detail.windowID;
+    debug("Event will have detail: " + JSON.stringify(detail));
+    let evt = this._createEvent('showmodalprompt', detail,
+                                /* cancelable = */ true);
+
+    let self = this;
+    let unblockMsgSent = false;
+    function sendUnblockMsg() {
+      if (unblockMsgSent) {
+        return;
+      }
+      unblockMsgSent = true;
+
+      // We don't need to sanitize evt.detail.returnValue (e.g. converting the
+      // return value of confirm() to a boolean); Gecko does that for us.
+
+      let data = { windowID: windowID,
+                   returnValue: evt.detail.returnValue };
+      self._sendAsyncMsg('unblock-modal-prompt', data);
+    }
+
+    Cu.exportFunction(sendUnblockMsg, evt.detail, { defineAs: 'unblock' });
+
+    this._frameElement.dispatchEvent(evt);
+
+    if (!evt.defaultPrevented) {
+      // Unblock the inner frame immediately.  Otherwise we'll unblock upon
+      // evt.detail.unblock().
+      sendUnblockMsg();
+    }
+  },
+
+  // Called when state of accessible caret in child has changed.
+  // The fields of data is as following:
+  //  - rect: Contains bounding rectangle of selection, Include width, height,
+  //          top, bottom, left and right.
+  //  - commands: Describe what commands can be executed in child. Include canSelectAll,
+  //              canCut, canCopy and canPaste. For example: if we want to check if cut
+  //              command is available, using following code, if (data.commands.canCut) {}.
+  //  - zoomFactor: Current zoom factor in child frame.
+  //  - reason: The reason causes the state changed. Include "visibilitychange",
+  //            "updateposition", "longpressonemptycontent", "taponcaret", "presscaret",
+  //            "releasecaret".
+  //  - collapsed: Indicate current selection is collapsed or not.
+  //  - caretVisible: Indicate the caret visiibility.
+  //  - selectionVisible: Indicate current selection is visible or not.
+  //  - selectionEditable: Indicate current selection is editable or not.
+  //  - selectedTextContent: Contains current selected text content, which is
+  //                         equivalent to the string returned by Selection.toString().
+  _handleCaretStateChanged: function(data) {
+    let evt = this._createEvent('caretstatechanged', data.json,
+                                /* cancelable = */ false);
+
+    let self = this;
+    function sendDoCommandMsg(cmd) {
+      let data = { command: cmd };
+      self._sendAsyncMsg('copypaste-do-command', data);
+    }
+    Cu.exportFunction(sendDoCommandMsg, evt.detail, { defineAs: 'sendDoCommandMsg' });
+
+    this._frameElement.dispatchEvent(evt);
+  },
+
+  _handleScrollViewChange: function(data) {
+    let evt = this._createEvent("scrollviewchange", data.json,
+                                /* cancelable = */ false);
+    this._frameElement.dispatchEvent(evt);
+  },
+
+  _handleFindChange: function(data) {
+    let evt = this._createEvent("findchange", data.json,
+                                /* cancelable = */ false);
+    this._frameElement.dispatchEvent(evt);
+  },
+
+  _createEvent: function(evtName, detail, cancelable) {
+    // This will have to change if we ever want to send a CustomEvent with null
+    // detail.  For now, it's OK.
+    if (detail !== undefined && detail !== null) {
+      detail = Cu.cloneInto(detail, this._window);
+      return new this._window.CustomEvent('mozbrowser' + evtName,
+                                          { bubbles: true,
+                                            cancelable: cancelable,
+                                            detail: detail });
+    }
+
+    return new this._window.Event('mozbrowser' + evtName,
+                                  { bubbles: true,
+                                    cancelable: cancelable });
+  },
+
+  /**
+   * Kick off a DOMRequest in the child process.
+   *
+   * We'll fire an event called |msgName| on the child process, passing along
+   * an object with two fields:
+   *
+   *  - id:  the ID of this request.
+   *  - arg: arguments to pass to the child along with this request.
+   *
+   * We expect the child to pass the ID back to us upon completion of the
+   * request.  See _gotDOMRequestResult.
+   */
+  _sendDOMRequest: function(msgName, args) {
+    let id = 'req_' + this._domRequestCounter++;
+    let req = Services.DOMRequest.createRequest(this._window);
+    let self = this;
+    let send = function() {
+      if (!self._isAlive()) {
+        return;
+      }
+      if (self._sendAsyncMsg(msgName, {id: id, args: args})) {
+        self._pendingDOMRequests[id] = req;
+      } else {
+        Services.DOMRequest.fireErrorAsync(req, "fail");
+      }
+    };
+    if (this._domRequestReady) {
+      send();
+    } else {
+      // Child haven't been loaded.
+      this._pendingAPICalls.push(send);
+    }
+    return req;
+  },
+
+  /**
+   * Called when the child process finishes handling a DOMRequest.  data.json
+   * must have the fields [id, successRv], if the DOMRequest was successful, or
+   * [id, errorMsg], if the request was not successful.
+   *
+   * The fields have the following meanings:
+   *
+   *  - id:        the ID of the DOM request (see _sendDOMRequest)
+   *  - successRv: the request's return value, if the request succeeded
+   *  - errorMsg:  the message to pass to DOMRequest.fireError(), if the request
+   *               failed.
+   *
+   */
+  _gotDOMRequestResult: function(data) {
+    let req = this._pendingDOMRequests[data.json.id];
+    delete this._pendingDOMRequests[data.json.id];
+
+    if ('successRv' in data.json) {
+      debug("Successful gotDOMRequestResult.");
+      let clientObj = Cu.cloneInto(data.json.successRv, this._window);
+      Services.DOMRequest.fireSuccess(req, clientObj);
+    }
+    else {
+      debug("Got error in gotDOMRequestResult.");
+      Services.DOMRequest.fireErrorAsync(req,
+        Cu.cloneInto(data.json.errorMsg, this._window));
+    }
+  },
+
+  setVisible: defineNoReturnMethod(function(visible) {
+    this._sendAsyncMsg('set-visible', {visible: visible});
+    this._frameLoader.visible = visible;
+  }),
+
+  getVisible: defineDOMRequestMethod('get-visible'),
+
+  setActive: defineNoReturnMethod(function(active) {
+    this._frameLoader.visible = active;
+  }),
+
+  getActive: function() {
+    if (!this._isAlive()) {
+      throw Components.Exception("Dead content process",
+                                 Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+    }
+
+    return this._frameLoader.visible;
+  },
+
+  getChildProcessOffset: function() {
+    let offset = { x: 0, y: 0 };
+    let tabParent = this._frameLoader.tabParent;
+    if (tabParent) {
+      let offsetX = {};
+      let offsetY = {};
+      tabParent.getChildProcessOffset(offsetX, offsetY);
+      offset.x = offsetX.value;
+      offset.y = offsetY.value;
+    }
+    return offset;
+  },
+
+  sendMouseEvent: defineNoReturnMethod(function(type, x, y, button, clickCount, modifiers) {
+    let offset = this.getChildProcessOffset();
+    x += offset.x;
+    y += offset.y;
+
+    this._sendAsyncMsg("send-mouse-event", {
+      "type": type,
+      "x": x,
+      "y": y,
+      "button": button,
+      "clickCount": clickCount,
+      "modifiers": modifiers
+    });
+  }),
+
+  sendTouchEvent: defineNoReturnMethod(function(type, identifiers, touchesX, touchesY,
+                                                radiisX, radiisY, rotationAngles, forces,
+                                                count, modifiers) {
+
+    let offset = this.getChildProcessOffset();
+    for (var i = 0; i < touchesX.length; i++) {
+      touchesX[i] += offset.x;
+    }
+    for (var i = 0; i < touchesY.length; i++) {
+      touchesY[i] += offset.y;
+    }
+    this._sendAsyncMsg("send-touch-event", {
+      "type": type,
+      "identifiers": identifiers,
+      "touchesX": touchesX,
+      "touchesY": touchesY,
+      "radiisX": radiisX,
+      "radiisY": radiisY,
+      "rotationAngles": rotationAngles,
+      "forces": forces,
+      "count": count,
+      "modifiers": modifiers
+    });
+  }),
+
+  getCanGoBack: defineDOMRequestMethod('get-can-go-back'),
+  getCanGoForward: defineDOMRequestMethod('get-can-go-forward'),
+  getContentDimensions: defineDOMRequestMethod('get-contentdimensions'),
+
+  findAll: defineNoReturnMethod(function(searchString, caseSensitivity) {
+    return this._sendAsyncMsg('find-all', {
+      searchString,
+      caseSensitive: caseSensitivity == Ci.nsIBrowserElementAPI.FIND_CASE_SENSITIVE
+    });
+  }),
+
+  findNext: defineNoReturnMethod(function(direction) {
+    return this._sendAsyncMsg('find-next', {
+      backward: direction == Ci.nsIBrowserElementAPI.FIND_BACKWARD
+    });
+  }),
+
+  clearMatch: defineNoReturnMethod(function() {
+    return this._sendAsyncMsg('clear-match');
+  }),
+
+  mute: defineNoReturnMethod(function() {
+    this._sendAsyncMsg('mute');
+  }),
+
+  unmute: defineNoReturnMethod(function() {
+    this._sendAsyncMsg('unmute');
+  }),
+
+  getMuted: defineDOMRequestMethod('get-muted'),
+
+  getVolume: defineDOMRequestMethod('get-volume'),
+
+  setVolume: defineNoReturnMethod(function(volume) {
+    this._sendAsyncMsg('set-volume', {volume});
+  }),
+
+  goBack: defineNoReturnMethod(function() {
+    this._sendAsyncMsg('go-back');
+  }),
+
+  goForward: defineNoReturnMethod(function() {
+    this._sendAsyncMsg('go-forward');
+  }),
+
+  reload: defineNoReturnMethod(function(hardReload) {
+    this._sendAsyncMsg('reload', {hardReload: hardReload});
+  }),
+
+  stop: defineNoReturnMethod(function() {
+    this._sendAsyncMsg('stop');
+  }),
+
+  executeScript: function(script, options) {
+    if (!this._isAlive()) {
+      throw Components.Exception("Dead content process",
+                                 Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+    }
+
+    // Enforcing options.url or options.origin
+    if (!options.url && !options.origin) {
+      throw Components.Exception("Invalid argument", Cr.NS_ERROR_INVALID_ARG);
+    }
+    return this._sendDOMRequest('execute-script', {script, options});
+  },
+
+  /*
+   * The valid range of zoom scale is defined in preference "zoom.maxPercent" and "zoom.minPercent".
+   */
+  zoom: defineNoReturnMethod(function(zoom) {
+    zoom *= 100;
+    zoom = Math.min(getIntPref("zoom.maxPercent", 300), zoom);
+    zoom = Math.max(getIntPref("zoom.minPercent", 50), zoom);
+    this._sendAsyncMsg('zoom', {zoom: zoom / 100.0});
+  }),
+
+  purgeHistory: defineDOMRequestMethod('purge-history'),
+
+
+  download: function(_url, _options) {
+    if (!this._isAlive()) {
+      return null;
+    }
+
+    let uri = Services.io.newURI(_url, null, null);
+    let url = uri.QueryInterface(Ci.nsIURL);
+
+    debug('original _options = ' + uneval(_options));
+
+    // Ensure we have _options, we always use it to send the filename.
+    _options = _options || {};
+    if (!_options.filename) {
+      _options.filename = url.fileName;
+    }
+
+    debug('final _options = ' + uneval(_options));
+
+    // Ensure we have a filename.
+    if (!_options.filename) {
+      throw Components.Exception("Invalid argument", Cr.NS_ERROR_INVALID_ARG);
+    }
+
+    let interfaceRequestor =
+      this._frameLoader.loadContext.QueryInterface(Ci.nsIInterfaceRequestor);
+    let req = Services.DOMRequest.createRequest(this._window);
+
+    function DownloadListener() {
+      debug('DownloadListener Constructor');
+    }
+    DownloadListener.prototype = {
+      extListener: null,
+      onStartRequest: function(aRequest, aContext) {
+        debug('DownloadListener - onStartRequest');
+        let extHelperAppSvc =
+          Cc['@mozilla.org/uriloader/external-helper-app-service;1'].
+          getService(Ci.nsIExternalHelperAppService);
+        let channel = aRequest.QueryInterface(Ci.nsIChannel);
+
+        // First, we'll ensure the filename doesn't have any leading
+        // periods. We have to do it here to avoid ending up with a filename
+        // that's only an extension with no extension (e.g. Sending in
+        // '.jpeg' without stripping the '.' would result in a filename of
+        // 'jpeg' where we want 'jpeg.jpeg'.
+        _options.filename = _options.filename.replace(/^\.+/, "");
+
+        let ext = null;
+        let mimeSvc = extHelperAppSvc.QueryInterface(Ci.nsIMIMEService);
+        try {
+          ext = '.' + mimeSvc.getPrimaryExtension(channel.contentType, '');
+        } catch (e) { ext = null; }
+
+        // Check if we need to add an extension to the filename.
+        if (ext && !_options.filename.endsWith(ext)) {
+          _options.filename += ext;
+        }
+        // Set the filename to use when saving to disk.
+        channel.contentDispositionFilename = _options.filename;
+
+        this.extListener =
+          extHelperAppSvc.doContent(
+              channel.contentType,
+              aRequest,
+              interfaceRequestor,
+              true);
+        this.extListener.onStartRequest(aRequest, aContext);
+      },
+      onStopRequest: function(aRequest, aContext, aStatusCode) {
+        debug('DownloadListener - onStopRequest (aStatusCode = ' +
+               aStatusCode + ')');
+        if (aStatusCode == Cr.NS_OK) {
+          // Everything looks great.
+          debug('DownloadListener - Download Successful.');
+          Services.DOMRequest.fireSuccess(req, aStatusCode);
+        }
+        else {
+          // In case of failure, we'll simply return the failure status code.
+          debug('DownloadListener - Download Failed!');
+          Services.DOMRequest.fireError(req, aStatusCode);
+        }
+
+        if (this.extListener) {
+          this.extListener.onStopRequest(aRequest, aContext, aStatusCode);
+        }
+      },
+      onDataAvailable: function(aRequest, aContext, aInputStream,
+                                aOffset, aCount) {
+        this.extListener.onDataAvailable(aRequest, aContext, aInputStream,
+                                         aOffset, aCount);
+      },
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsIStreamListener,
+                                             Ci.nsIRequestObserver])
+    };
+
+    let referrer = Services.io.newURI(_options.referrer, null, null);
+    let principal =
+      Services.scriptSecurityManager.createCodebasePrincipal(
+        referrer, this._frameLoader.loadContext.originAttributes);
+
+    let channel = NetUtil.newChannel({
+      uri: url,
+      loadingPrincipal: principal,
+      securityFlags: SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS,
+      contentPolicyType: Ci.nsIContentPolicy.TYPE_OTHER
+    });
+
+    // XXX We would set private browsing information prior to calling this.
+    channel.notificationCallbacks = interfaceRequestor;
+
+    // Since we're downloading our own local copy we'll want to bypass the
+    // cache and local cache if the channel let's us specify this.
+    let flags = Ci.nsIChannel.LOAD_CALL_CONTENT_SNIFFERS |
+                Ci.nsIChannel.LOAD_BYPASS_CACHE;
+    if (channel instanceof Ci.nsICachingChannel) {
+      debug('This is a caching channel. Forcing bypass.');
+      flags |= Ci.nsICachingChannel.LOAD_BYPASS_LOCAL_CACHE_IF_BUSY;
+    }
+
+    channel.loadFlags |= flags;
+
+    if (channel instanceof Ci.nsIHttpChannel) {
+      debug('Setting HTTP referrer = ' + (referrer && referrer.spec));
+      channel.referrer = referrer;
+      if (channel instanceof Ci.nsIHttpChannelInternal) {
+        channel.forceAllowThirdPartyCookie = true;
+      }
+    }
+
+    // Set-up complete, let's get things started.
+    channel.asyncOpen2(new DownloadListener());
+
+    return req;
+  },
+
+  getScreenshot: function(_width, _height, _mimeType) {
+    if (!this._isAlive()) {
+      throw Components.Exception("Dead content process",
+                                 Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+    }
+
+    let width = parseInt(_width);
+    let height = parseInt(_height);
+    let mimeType = (typeof _mimeType === 'string') ?
+      _mimeType.trim().toLowerCase() : 'image/jpeg';
+    if (isNaN(width) || isNaN(height) || width < 0 || height < 0) {
+      throw Components.Exception("Invalid argument",
+                                 Cr.NS_ERROR_INVALID_ARG);
+    }
+
+    return this._sendDOMRequest('get-screenshot',
+                                {width: width, height: height,
+                                 mimeType: mimeType});
+  },
+
+  _recvNextPaint: function(data) {
+    let listeners = this._nextPaintListeners;
+    this._nextPaintListeners = [];
+    for (let listener of listeners) {
+      try {
+        listener.recvNextPaint();
+      } catch (e) {
+        // If a listener throws we'll continue.
+      }
+    }
+  },
+
+  addNextPaintListener: function(listener) {
+    if (!this._isAlive()) {
+      throw Components.Exception("Dead content process",
+                                 Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+    }
+
+    let self = this;
+    let run = function() {
+      if (self._nextPaintListeners.push(listener) == 1)
+        self._sendAsyncMsg('activate-next-paint-listener');
+    };
+    if (!this._domRequestReady) {
+      this._pendingAPICalls.push(run);
+    } else {
+      run();
+    }
+  },
+
+  removeNextPaintListener: function(listener) {
+    if (!this._isAlive()) {
+      throw Components.Exception("Dead content process",
+                                 Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+    }
+
+    let self = this;
+    let run = function() {
+      for (let i = self._nextPaintListeners.length - 1; i >= 0; i--) {
+        if (self._nextPaintListeners[i] == listener) {
+          self._nextPaintListeners.splice(i, 1);
+          break;
+        }
+      }
+
+      if (self._nextPaintListeners.length == 0)
+        self._sendAsyncMsg('deactivate-next-paint-listener');
+    };
+    if (!this._domRequestReady) {
+      this._pendingAPICalls.push(run);
+    } else {
+      run();
+    }
+  },
+
+  setInputMethodActive: function(isActive) {
+    if (!this._isAlive()) {
+      throw Components.Exception("Dead content process",
+                                 Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+    }
+
+    if (typeof isActive !== 'boolean') {
+      throw Components.Exception("Invalid argument",
+                                 Cr.NS_ERROR_INVALID_ARG);
+    }
+
+    return this._sendDOMRequest('set-input-method-active',
+                                {isActive: isActive});
+  },
+
+  getAudioChannelVolume: function(aAudioChannel) {
+    return this._sendDOMRequest('get-audio-channel-volume',
+                                {audioChannel: aAudioChannel});
+  },
+
+  setAudioChannelVolume: function(aAudioChannel, aVolume) {
+    return this._sendDOMRequest('set-audio-channel-volume',
+                                {audioChannel: aAudioChannel,
+                                 volume: aVolume});
+  },
+
+  getAudioChannelMuted: function(aAudioChannel) {
+    return this._sendDOMRequest('get-audio-channel-muted',
+                                {audioChannel: aAudioChannel});
+  },
+
+  setAudioChannelMuted: function(aAudioChannel, aMuted) {
+    return this._sendDOMRequest('set-audio-channel-muted',
+                                {audioChannel: aAudioChannel,
+                                 muted: aMuted});
+  },
+
+  isAudioChannelActive: function(aAudioChannel) {
+    return this._sendDOMRequest('get-is-audio-channel-active',
+                                {audioChannel: aAudioChannel});
+  },
+
+  getWebManifest: defineDOMRequestMethod('get-web-manifest'),
+  /**
+   * Called when the visibility of the window which owns this iframe changes.
+   */
+  _ownerVisibilityChange: function() {
+    this._sendAsyncMsg('owner-visibility-change',
+                       {visible: !this._window.document.hidden});
+  },
+
+  /*
+   * Called when the child notices that its visibility has changed.
+   *
+   * This is sometimes redundant; for example, the child's visibility may
+   * change in response to a setVisible request that we made here!  But it's
+   * not always redundant; for example, the child's visibility may change in
+   * response to its parent docshell being hidden.
+   */
+  _childVisibilityChange: function(data) {
+    debug("_childVisibilityChange(" + data.json.visible + ")");
+    this._frameLoader.visible = data.json.visible;
+
+    this._fireEventFromMsg(data);
+  },
+
+  _requestedDOMFullscreen: function() {
+    this._pendingDOMFullscreen = true;
+    this._windowUtils.remoteFrameFullscreenChanged(this._frameElement);
+  },
+
+  _fullscreenOriginChange: function(data) {
+    Services.obs.notifyObservers(
+      this._frameElement, "fullscreen-origin-change", data.json.originNoSuffix);
+  },
+
+  _exitDomFullscreen: function(data) {
+    this._windowUtils.remoteFrameFullscreenReverted();
+  },
+
+  _handleOwnerEvent: function(evt) {
+    switch (evt.type) {
+      case 'visibilitychange':
+        this._ownerVisibilityChange();
+        break;
+      case 'fullscreenchange':
+        if (!this._window.document.fullscreenElement) {
+          this._sendAsyncMsg('exit-fullscreen');
+        } else if (this._pendingDOMFullscreen) {
+          this._pendingDOMFullscreen = false;
+          this._sendAsyncMsg('entered-fullscreen');
+        }
+        break;
+    }
+  },
+
+  _fireFatalError: function() {
+    let evt = this._createEvent('error', {type: 'fatal'},
+                                /* cancelable = */ false);
+    this._frameElement.dispatchEvent(evt);
+  },
+
+  observe: function(subject, topic, data) {
+    switch(topic) {
+    case 'oop-frameloader-crashed':
+      if (this._isAlive() && subject == this._frameLoader) {
+        this._fireFatalError();
+      }
+      break;
+    case 'ask-children-to-execute-copypaste-command':
+      if (this._isAlive() && this._frameElement == subject.wrappedJSObject) {
+        this._sendAsyncMsg('copypaste-do-command', { command: data });
+      }
+      break;
+    case 'back-docommand':
+      if (this._isAlive() && this._frameLoader.visible) {
+          this.goBack();
+      }
+      break;
+    default:
+      debug('Unknown topic: ' + topic);
+      break;
+    };
+  },
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([BrowserElementParent]);
diff --git a/dom/browser-element/BrowserElementParent.manifest b/dom/browser-element/BrowserElementParent.manifest
new file mode 100644
index 000000000..547ff7f3d
--- /dev/null
+++ b/dom/browser-element/BrowserElementParent.manifest
@@ -0,0 +1,2 @@
+component {9f171ac4-0939-4ef8-b360-3408aedc3060} BrowserElementParent.js
+contract @mozilla.org/dom/browser-element-api;1 {9f171ac4-0939-4ef8-b360-3408aedc3060}
diff --git a/dom/browser-element/BrowserElementPromptService.jsm b/dom/browser-element/BrowserElementPromptService.jsm
new file mode 100644
index 000000000..1442304db
--- /dev/null
+++ b/dom/browser-element/BrowserElementPromptService.jsm
@@ -0,0 +1,685 @@
+/* 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/. */
+/* vim: set ft=javascript : */
+
+"use strict";
+
+var Cu = Components.utils;
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cm = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+
+this.EXPORTED_SYMBOLS = ["BrowserElementPromptService"];
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+
+const NS_PREFBRANCH_PREFCHANGE_TOPIC_ID = "nsPref:changed";
+const BROWSER_FRAMES_ENABLED_PREF = "dom.mozBrowserFramesEnabled";
+
+function debug(msg) {
+  //dump("BrowserElementPromptService - " + msg + "\n");
+}
+
+function BrowserElementPrompt(win, browserElementChild) {
+  this._win = win;
+  this._browserElementChild = browserElementChild;
+}
+
+BrowserElementPrompt.prototype = {
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIPrompt]),
+
+  alert: function(title, text) {
+    this._browserElementChild.showModalPrompt(
+      this._win, {promptType: "alert", title: title, message: text, returnValue: undefined});
+  },
+
+  alertCheck: function(title, text, checkMsg, checkState) {
+    // Treat this like a normal alert() call, ignoring the checkState.  The
+    // front-end can do its own suppression of the alert() if it wants.
+    this.alert(title, text);
+  },
+
+  confirm: function(title, text) {
+    return this._browserElementChild.showModalPrompt(
+      this._win, {promptType: "confirm", title: title, message: text, returnValue: undefined});
+  },
+
+  confirmCheck: function(title, text, checkMsg, checkState) {
+    return this.confirm(title, text);
+  },
+
+  // Each button is described by an object with the following schema
+  // {
+  //   string messageType,  // 'builtin' or 'custom'
+  //   string message, // 'ok', 'cancel', 'yes', 'no', 'save', 'dontsave',
+  //                   // 'revert' or a string from caller if messageType was 'custom'.
+  // }
+  //
+  // Expected result from embedder:
+  // {
+  //   int button, // Index of the button that user pressed.
+  //   boolean checked, // True if the check box is checked.
+  // }
+  confirmEx: function(title, text, buttonFlags, button0Title, button1Title,
+                      button2Title, checkMsg, checkState) {
+    let buttonProperties = this._buildConfirmExButtonProperties(buttonFlags,
+                                                                button0Title,
+                                                                button1Title,
+                                                                button2Title);
+    let defaultReturnValue = { selectedButton: buttonProperties.defaultButton };
+    if (checkMsg) {
+      defaultReturnValue.checked = checkState.value;
+    }
+    let ret = this._browserElementChild.showModalPrompt(
+      this._win,
+      {
+        promptType: "custom-prompt",
+        title: title,
+        message: text,
+        defaultButton: buttonProperties.defaultButton,
+        buttons: buttonProperties.buttons,
+        showCheckbox: !!checkMsg,
+        checkboxMessage: checkMsg,
+        checkboxCheckedByDefault: !!checkState.value,
+        returnValue: defaultReturnValue
+      }
+    );
+    if (checkMsg) {
+      checkState.value = ret.checked;
+    }
+    return buttonProperties.indexToButtonNumberMap[ret.selectedButton];
+  },
+
+  prompt: function(title, text, value, checkMsg, checkState) {
+    let rv = this._browserElementChild.showModalPrompt(
+      this._win,
+      { promptType: "prompt",
+        title: title,
+        message: text,
+        initialValue: value.value,
+        returnValue: null });
+
+    value.value = rv;
+
+    // nsIPrompt::Prompt returns true if the user pressed "OK" at the prompt,
+    // and false if the user pressed "Cancel".
+    //
+    // BrowserElementChild returns null for "Cancel" and returns the string the
+    // user entered otherwise.
+    return rv !== null;
+  },
+
+  promptUsernameAndPassword: function(title, text, username, password, checkMsg, checkState) {
+    throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+  },
+
+  promptPassword: function(title, text, password, checkMsg, checkState) {
+    throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+  },
+
+  select: function(title, text, aCount, aSelectList, aOutSelection) {
+    throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+  },
+
+  _buildConfirmExButtonProperties: function(buttonFlags, button0Title,
+                                            button1Title, button2Title) {
+    let r = {
+      defaultButton: -1,
+      buttons: [],
+      // This map is for translating array index to the button number that
+      // is recognized by Gecko. This shouldn't be exposed to embedder.
+      indexToButtonNumberMap: []
+    };
+
+    let defaultButton = 0;  // Default to Button 0.
+    if (buttonFlags & Ci.nsIPrompt.BUTTON_POS_1_DEFAULT) {
+      defaultButton = 1;
+    } else if (buttonFlags & Ci.nsIPrompt.BUTTON_POS_2_DEFAULT) {
+      defaultButton = 2;
+    }
+
+    // Properties of each button.
+    let buttonPositions = [
+      Ci.nsIPrompt.BUTTON_POS_0,
+      Ci.nsIPrompt.BUTTON_POS_1,
+      Ci.nsIPrompt.BUTTON_POS_2
+    ];
+
+    function buildButton(buttonTitle, buttonNumber) {
+      let ret = {};
+      let buttonPosition = buttonPositions[buttonNumber];
+      let mask = 0xff * buttonPosition;  // 8 bit mask
+      let titleType = (buttonFlags & mask) / buttonPosition;
+
+      ret.messageType = 'builtin';
+      switch(titleType) {
+      case Ci.nsIPrompt.BUTTON_TITLE_OK:
+        ret.message = 'ok';
+        break;
+      case Ci.nsIPrompt.BUTTON_TITLE_CANCEL:
+        ret.message = 'cancel';
+        break;
+      case Ci.nsIPrompt.BUTTON_TITLE_YES:
+        ret.message = 'yes';
+        break;
+      case Ci.nsIPrompt.BUTTON_TITLE_NO:
+        ret.message = 'no';
+        break;
+      case Ci.nsIPrompt.BUTTON_TITLE_SAVE:
+        ret.message = 'save';
+        break;
+      case Ci.nsIPrompt.BUTTON_TITLE_DONT_SAVE:
+        ret.message = 'dontsave';
+        break;
+      case Ci.nsIPrompt.BUTTON_TITLE_REVERT:
+        ret.message = 'revert';
+        break;
+      case Ci.nsIPrompt.BUTTON_TITLE_IS_STRING:
+        ret.message = buttonTitle;
+        ret.messageType = 'custom';
+        break;
+      default:
+        // This button is not shown.
+        return;
+      }
+
+      // If this is the default button, set r.defaultButton to
+      // the index of this button in the array. This value is going to be
+      // exposed to the embedder.
+      if (defaultButton === buttonNumber) {
+        r.defaultButton = r.buttons.length;
+      }
+      r.buttons.push(ret);
+      r.indexToButtonNumberMap.push(buttonNumber);
+    }
+
+    buildButton(button0Title, 0);
+    buildButton(button1Title, 1);
+    buildButton(button2Title, 2);
+
+    // If defaultButton is still -1 here, it means the default button won't
+    // be shown.
+    if (r.defaultButton === -1) {
+      throw new Components.Exception("Default button won't be shown",
+                                     Cr.NS_ERROR_FAILURE);
+    }
+
+    return r;
+  },
+};
+
+
+function BrowserElementAuthPrompt() {
+}
+
+BrowserElementAuthPrompt.prototype = {
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIAuthPrompt2]),
+
+  promptAuth: function promptAuth(channel, level, authInfo) {
+    throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+  },
+
+  asyncPromptAuth: function asyncPromptAuth(channel, callback, context, level, authInfo) {
+    debug("asyncPromptAuth");
+
+    // The cases that we don't support now.
+    if ((authInfo.flags & Ci.nsIAuthInformation.AUTH_PROXY) &&
+        (authInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD)) {
+      throw Cr.NS_ERROR_FAILURE;
+    }
+
+    let frame = this._getFrameFromChannel(channel);
+    if (!frame) {
+      debug("Cannot get frame, asyncPromptAuth fail");
+      throw Cr.NS_ERROR_FAILURE;
+    }
+
+    let browserElementParent =
+      BrowserElementPromptService.getBrowserElementParentForFrame(frame);
+
+    if (!browserElementParent) {
+      debug("Failed to load browser element parent.");
+      throw Cr.NS_ERROR_FAILURE;
+    }
+
+    let consumer = {
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsICancelable]),
+      callback: callback,
+      context: context,
+      cancel: function() {
+        this.callback.onAuthCancelled(this.context, false);
+        this.callback = null;
+        this.context = null;
+      }
+    };
+
+    let [hostname, httpRealm] = this._getAuthTarget(channel, authInfo);
+    let hashKey = level + "|" + hostname + "|" + httpRealm;
+    let asyncPrompt = this._asyncPrompts[hashKey];
+    if (asyncPrompt) {
+      asyncPrompt.consumers.push(consumer);
+      return consumer;
+    }
+
+    asyncPrompt = {
+      consumers: [consumer],
+      channel: channel,
+      authInfo: authInfo,
+      level: level,
+      inProgress: false,
+      browserElementParent: browserElementParent
+    };
+
+    this._asyncPrompts[hashKey] = asyncPrompt;
+    this._doAsyncPrompt();
+    return consumer;
+  },
+
+  // Utilities for nsIAuthPrompt2 ----------------
+
+  _asyncPrompts: {},
+  _asyncPromptInProgress: new WeakMap(),
+  _doAsyncPrompt: function() {
+    // Find the key of a prompt whose browser element parent does not have
+    // async prompt in progress.
+    let hashKey = null;
+    for (let key in this._asyncPrompts) {
+      let prompt = this._asyncPrompts[key];
+      if (!this._asyncPromptInProgress.get(prompt.browserElementParent)) {
+        hashKey = key;
+        break;
+      }
+    }
+
+    // Didn't find an available prompt, so just return.
+    if (!hashKey)
+      return;
+
+    let prompt = this._asyncPrompts[hashKey];
+    let [hostname, httpRealm] = this._getAuthTarget(prompt.channel,
+                                                    prompt.authInfo);
+
+    this._asyncPromptInProgress.set(prompt.browserElementParent, true);
+    prompt.inProgress = true;
+
+    let self = this;
+    let callback = function(ok, username, password) {
+      debug("Async auth callback is called, ok = " +
+            ok + ", username = " + username);
+
+      // Here we got the username and password provided by embedder, or
+      // ok = false if the prompt was cancelled by embedder.
+      delete self._asyncPrompts[hashKey];
+      prompt.inProgress = false;
+      self._asyncPromptInProgress.delete(prompt.browserElementParent);
+
+      // Fill authentication information with username and password provided
+      // by user.
+      let flags = prompt.authInfo.flags;
+      if (username) {
+        if (flags & Ci.nsIAuthInformation.NEED_DOMAIN) {
+          // Domain is separated from username by a backslash
+          let idx = username.indexOf("\\");
+          if (idx == -1) {
+            prompt.authInfo.username = username;
+          } else {
+            prompt.authInfo.domain   = username.substring(0, idx);
+            prompt.authInfo.username = username.substring(idx + 1);
+          }
+        } else {
+          prompt.authInfo.username = username;
+        }
+      }
+
+      if (password) {
+        prompt.authInfo.password = password;
+      }
+
+      for (let consumer of prompt.consumers) {
+        if (!consumer.callback) {
+          // Not having a callback means that consumer didn't provide it
+          // or canceled the notification.
+          continue;
+        }
+
+        try {
+          if (ok) {
+            debug("Ok, calling onAuthAvailable to finish auth");
+            consumer.callback.onAuthAvailable(consumer.context, prompt.authInfo);
+          } else {
+            debug("Cancelled, calling onAuthCancelled to finish auth.");
+            consumer.callback.onAuthCancelled(consumer.context, true);
+          }
+        } catch (e) { /* Throw away exceptions caused by callback */ }
+      }
+
+      // Process the next prompt, if one is pending.
+      self._doAsyncPrompt();
+    };
+
+    let runnable = {
+      run: function() {
+        // Call promptAuth of browserElementParent, to show the prompt.
+        prompt.browserElementParent.promptAuth(
+          self._createAuthDetail(prompt.channel, prompt.authInfo),
+          callback);
+      }
+    }
+
+    Services.tm.currentThread.dispatch(runnable, Ci.nsIThread.DISPATCH_NORMAL);
+  },
+
+  _getFrameFromChannel: function(channel) {
+    let loadContext = channel.notificationCallbacks.getInterface(Ci.nsILoadContext);
+    return loadContext.topFrameElement;
+  },
+
+  _createAuthDetail: function(channel, authInfo) {
+    let [hostname, httpRealm] = this._getAuthTarget(channel, authInfo);
+    return {
+      host:             hostname,
+      path:             channel.URI.path,
+      realm:            httpRealm,
+      username:         authInfo.username,
+      isProxy:          !!(authInfo.flags & Ci.nsIAuthInformation.AUTH_PROXY),
+      isOnlyPassword:   !!(authInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD)
+    };
+  },
+
+  // The code is taken from nsLoginManagerPrompter.js, with slight
+  // modification for parameter name consistency here.
+  _getAuthTarget : function (channel, authInfo) {
+    let hostname, realm;
+
+    // If our proxy is demanding authentication, don't use the
+    // channel's actual destination.
+    if (authInfo.flags & Ci.nsIAuthInformation.AUTH_PROXY) {
+      if (!(channel instanceof Ci.nsIProxiedChannel))
+        throw new Error("proxy auth needs nsIProxiedChannel");
+
+      let info = channel.proxyInfo;
+      if (!info)
+        throw new Error("proxy auth needs nsIProxyInfo");
+
+      // Proxies don't have a scheme, but we'll use "moz-proxy://"
+      // so that it's more obvious what the login is for.
+      var idnService = Cc["@mozilla.org/network/idn-service;1"].
+                       getService(Ci.nsIIDNService);
+      hostname = "moz-proxy://" +
+                  idnService.convertUTF8toACE(info.host) +
+                  ":" + info.port;
+      realm = authInfo.realm;
+      if (!realm)
+        realm = hostname;
+
+      return [hostname, realm];
+    }
+
+    hostname = this._getFormattedHostname(channel.URI);
+
+    // If a HTTP WWW-Authenticate header specified a realm, that value
+    // will be available here. If it wasn't set or wasn't HTTP, we'll use
+    // the formatted hostname instead.
+    realm = authInfo.realm;
+    if (!realm)
+      realm = hostname;
+
+    return [hostname, realm];
+  },
+
+  /**
+   * Strip out things like userPass and path for display.
+   */
+  _getFormattedHostname : function(uri) {
+    return uri.scheme + "://" + uri.hostPort;
+  },
+};
+
+
+function AuthPromptWrapper(oldImpl, browserElementImpl) {
+  this._oldImpl = oldImpl;
+  this._browserElementImpl = browserElementImpl;
+}
+
+AuthPromptWrapper.prototype = {
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIAuthPrompt2]),
+  promptAuth: function(channel, level, authInfo) {
+    if (this._canGetParentElement(channel)) {
+      return this._browserElementImpl.promptAuth(channel, level, authInfo);
+    } else {
+      return this._oldImpl.promptAuth(channel, level, authInfo);
+    }
+  },
+
+  asyncPromptAuth: function(channel, callback, context, level, authInfo) {
+    if (this._canGetParentElement(channel)) {
+      return this._browserElementImpl.asyncPromptAuth(channel, callback, context, level, authInfo);
+    } else {
+      return this._oldImpl.asyncPromptAuth(channel, callback, context, level, authInfo);
+    }
+  },
+
+  _canGetParentElement: function(channel) {
+    try {
+      let context = channel.notificationCallbacks.getInterface(Ci.nsILoadContext);
+      let frame = context.topFrameElement;
+      if (!frame) {
+        // This function returns a boolean value
+        return !!context.nestedFrameId;
+      }
+
+      if (!BrowserElementPromptService.getBrowserElementParentForFrame(frame))
+        return false;
+
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+
+function BrowserElementPromptFactory(toWrap) {
+  this._wrapped = toWrap;
+}
+
+BrowserElementPromptFactory.prototype = {
+  classID: Components.ID("{24f3d0cf-e417-4b85-9017-c9ecf8bb1299}"),
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIPromptFactory]),
+
+  _mayUseNativePrompt: function() {
+    try {
+      return Services.prefs.getBoolPref("browser.prompt.allowNative");
+    } catch (e) {
+      // This properity is default to true.
+      return true;
+    }
+  },
+
+  _getNativePromptIfAllowed: function(win, iid, err) {
+    if (this._mayUseNativePrompt())
+      return this._wrapped.getPrompt(win, iid);
+    else {
+      // Not allowed, throw an exception.
+      throw err;
+    }
+  },
+
+  getPrompt: function(win, iid) {
+    // It is possible for some object to get a prompt without passing
+    // valid reference of window, like nsNSSComponent. In such case, we
+    // should just fall back to the native prompt service
+    if (!win)
+      return this._getNativePromptIfAllowed(win, iid, Cr.NS_ERROR_INVALID_ARG);
+
+    if (iid.number != Ci.nsIPrompt.number &&
+        iid.number != Ci.nsIAuthPrompt2.number) {
+      debug("We don't recognize the requested IID (" + iid + ", " +
+            "allowed IID: " +
+            "nsIPrompt=" + Ci.nsIPrompt + ", " +
+            "nsIAuthPrompt2=" + Ci.nsIAuthPrompt2 + ")");
+      return this._getNativePromptIfAllowed(win, iid, Cr.NS_ERROR_INVALID_ARG);
+    }
+
+    // Try to find a BrowserElementChild for the window.
+    let browserElementChild =
+      BrowserElementPromptService.getBrowserElementChildForWindow(win);
+
+    if (iid.number === Ci.nsIAuthPrompt2.number) {
+      debug("Caller requests an instance of nsIAuthPrompt2.");
+
+      if (browserElementChild) {
+        // If we are able to get a BrowserElementChild, it means that
+        // the auth prompt is for a mozbrowser. Therefore we don't need to
+        // fall back.
+        return new BrowserElementAuthPrompt().QueryInterface(iid);
+      }
+
+      // Because nsIAuthPrompt2 is called in parent process. If caller
+      // wants nsIAuthPrompt2 and we cannot get BrowserElementchild,
+      // it doesn't mean that we should fallback. It is possible that we can
+      // get the BrowserElementParent from nsIChannel that passed to
+      // functions of nsIAuthPrompt2.
+      if (this._mayUseNativePrompt()) {
+        return new AuthPromptWrapper(
+            this._wrapped.getPrompt(win, iid),
+            new BrowserElementAuthPrompt().QueryInterface(iid))
+          .QueryInterface(iid);
+      } else {
+        // Falling back is not allowed, so we don't need wrap the
+        // BrowserElementPrompt.
+        return new BrowserElementAuthPrompt().QueryInterface(iid);
+      }
+    }
+
+    if (!browserElementChild) {
+      debug("We can't find a browserElementChild for " +
+            win + ", " + win.location);
+      return this._getNativePromptIfAllowed(win, iid, Cr.NS_ERROR_FAILURE);
+    }
+
+    debug("Returning wrapped getPrompt for " + win);
+    return new BrowserElementPrompt(win, browserElementChild)
+                                   .QueryInterface(iid);
+  }
+};
+
+this.BrowserElementPromptService = {
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver,
+                                         Ci.nsISupportsWeakReference]),
+
+  _initialized: false,
+
+  _init: function() {
+    if (this._initialized) {
+      return;
+    }
+
+    // If the pref is disabled, do nothing except wait for the pref to change.
+    if (!this._browserFramesPrefEnabled()) {
+      var prefs = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+      prefs.addObserver(BROWSER_FRAMES_ENABLED_PREF, this, /* ownsWeak = */ true);
+      return;
+    }
+
+    this._initialized = true;
+    this._browserElementParentMap = new WeakMap();
+
+    var os = Cc["@mozilla.org/observer-service;1"].getService(Ci.nsIObserverService);
+    os.addObserver(this, "outer-window-destroyed", /* ownsWeak = */ true);
+
+    // Wrap the existing @mozilla.org/prompter;1 implementation.
+    var contractID = "@mozilla.org/prompter;1";
+    var oldCID = Cm.contractIDToCID(contractID);
+    var newCID = BrowserElementPromptFactory.prototype.classID;
+    var oldFactory = Cm.getClassObject(Cc[contractID], Ci.nsIFactory);
+
+    if (oldCID == newCID) {
+      debug("WARNING: Wrapped prompt factory is already installed!");
+      return;
+    }
+
+    Cm.unregisterFactory(oldCID, oldFactory);
+
+    var oldInstance = oldFactory.createInstance(null, Ci.nsIPromptFactory);
+    var newInstance = new BrowserElementPromptFactory(oldInstance);
+
+    var newFactory = {
+      createInstance: function(outer, iid) {
+        if (outer != null) {
+          throw Cr.NS_ERROR_NO_AGGREGATION;
+        }
+        return newInstance.QueryInterface(iid);
+      }
+    };
+    Cm.registerFactory(newCID,
+                       "BrowserElementPromptService's prompter;1 wrapper",
+                       contractID, newFactory);
+
+    debug("Done installing new prompt factory.");
+  },
+
+  _getOuterWindowID: function(win) {
+    return win.QueryInterface(Ci.nsIInterfaceRequestor)
+              .getInterface(Ci.nsIDOMWindowUtils)
+              .outerWindowID;
+  },
+
+  _browserElementChildMap: {},
+  mapWindowToBrowserElementChild: function(win, browserElementChild) {
+    this._browserElementChildMap[this._getOuterWindowID(win)] = browserElementChild;
+  },
+  unmapWindowToBrowserElementChild: function(win) {
+    delete this._browserElementChildMap[this._getOuterWindowID(win)];
+  },
+
+  getBrowserElementChildForWindow: function(win) {
+    // We only have a mapping for <iframe mozbrowser>s, not their inner
+    // <iframes>, so we look up win.top below.  window.top (when called from
+    // script) respects <iframe mozbrowser> boundaries.
+    return this._browserElementChildMap[this._getOuterWindowID(win.top)];
+  },
+
+  mapFrameToBrowserElementParent: function(frame, browserElementParent) {
+    this._browserElementParentMap.set(frame, browserElementParent);
+  },
+
+  getBrowserElementParentForFrame: function(frame) {
+    return this._browserElementParentMap.get(frame);
+  },
+
+  _observeOuterWindowDestroyed: function(outerWindowID) {
+    let id = outerWindowID.QueryInterface(Ci.nsISupportsPRUint64).data;
+    debug("observeOuterWindowDestroyed " + id);
+    delete this._browserElementChildMap[outerWindowID.data];
+  },
+
+  _browserFramesPrefEnabled: function() {
+    var prefs = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+    try {
+      return prefs.getBoolPref(BROWSER_FRAMES_ENABLED_PREF);
+    }
+    catch(e) {
+      return false;
+    }
+  },
+
+  observe: function(subject, topic, data) {
+    switch(topic) {
+    case NS_PREFBRANCH_PREFCHANGE_TOPIC_ID:
+      if (data == BROWSER_FRAMES_ENABLED_PREF) {
+        this._init();
+      }
+      break;
+    case "outer-window-destroyed":
+      this._observeOuterWindowDestroyed(subject);
+      break;
+    default:
+      debug("Observed unexpected topic " + topic);
+    }
+  }
+};
+
+BrowserElementPromptService._init();
diff --git a/dom/browser-element/BrowserElementProxy.js b/dom/browser-element/BrowserElementProxy.js
new file mode 100644
index 000000000..852b93358
--- /dev/null
+++ b/dom/browser-element/BrowserElementProxy.js
@@ -0,0 +1,219 @@
+/* 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';
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+const Cr = Components.results;
+
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import('resource://gre/modules/Services.jsm');
+
+function defineNoReturnMethod(methodName) {
+  return function noReturnMethod() {
+    let args = Array.slice(arguments);
+    this._sendToParent(methodName, args);
+  };
+}
+
+function defineDOMRequestMethod(methodName) {
+  return function domRequestMethod() {
+    let args = Array.slice(arguments);
+    return this._sendDOMRequest(methodName, args);
+  };
+}
+
+function defineUnimplementedMethod(methodName) {
+  return function unimplementedMethod() {
+    throw Components.Exception(
+      'Unimplemented method: ' + methodName, Cr.NS_ERROR_FAILURE);
+  };
+}
+
+/**
+ * The BrowserElementProxy talks to the Browser IFrameElement instance on
+ * behave of the embedded document. It implements all the methods on
+ * the Browser IFrameElement and the methods will work if they are applicable.
+ *
+ * The message is forwarded to BrowserElementParent.js by creating an
+ * 'browser-element-api:proxy-call' observer message.
+ * BrowserElementChildPreload will get notified and send the message through
+ * to the main process through sendAsyncMessage with message of the same name.
+ *
+ * The return message will follow the same route. The message name on the
+ * return route is 'browser-element-api:proxy'.
+ *
+ * Both BrowserElementProxy and BrowserElementParent must be modified if there
+ * is a new method implemented, or a new event added to the Browser
+ * IFrameElement.
+ *
+ * Other details unmentioned here are checks of message sender and recipients
+ * to identify proxy instance on different innerWindows or ensure the content
+ * process has the right permission.
+ */
+function BrowserElementProxy() {
+  // Pad the 0th element so that DOMRequest ID will always be a truthy value.
+  this._pendingDOMRequests = [ undefined ];
+}
+
+BrowserElementProxy.prototype = {
+  classDescription: 'BrowserElementProxy allowed embedded frame to control ' +
+                    'it\'s own embedding browser element frame instance.',
+  classID:          Components.ID('{7e95d54c-9930-49c8-9a10-44fe40fe8251}'),
+  contractID:       '@mozilla.org/dom/browser-element-proxy;1',
+
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsIDOMGlobalPropertyInitializer,
+    Ci.nsIObserver]),
+
+  _window: null,
+  _innerWindowID: undefined,
+
+  get allowedAudioChannels() {
+    return this._window.navigator.mozAudioChannelManager ?
+      this._window.navigator.mozAudioChannelManager.allowedAudioChannels :
+      null;
+  },
+
+  init: function(win) {
+    this._window = win;
+    this._innerWindowID = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                          .getInterface(Ci.nsIDOMWindowUtils)
+                          .currentInnerWindowID;
+
+    this._sendToParent('_proxyInstanceInit');
+    Services.obs.addObserver(this, 'browser-element-api:proxy', false);
+  },
+
+  uninit: function(win) {
+    this._sendToParent('_proxyInstanceUninit');
+
+    this._window = null;
+    this._innerWindowID = undefined;
+
+    Services.obs.removeObserver(this, 'browser-element-api:proxy');
+  },
+
+  observe: function(subject, topic, stringifedData) {
+    let data = JSON.parse(stringifedData);
+
+    if (subject !== this._window ||
+        data.innerWindowID !== data.innerWindowID) {
+      return;
+    }
+
+    if (data.eventName) {
+      this._fireEvent(data.eventName, JSON.parse(data.eventDetailString));
+
+      return;
+    }
+
+    if ('domRequestId' in data) {
+      let req = this._pendingDOMRequests[data.domRequestId];
+      this._pendingDOMRequests[data.domRequestId] = undefined;
+
+      if (!req) {
+        dump('BrowserElementProxy Error: ' +
+          'Multiple observer messages for the same DOMRequest result.\n');
+        return;
+      }
+
+      if ('result' in data) {
+        let clientObj = Cu.cloneInto(data.result, this._window);
+        Services.DOMRequest.fireSuccess(req, clientObj);
+      } else {
+        let clientObj = Cu.cloneInto(data.error, this._window);
+        Services.DOMRequest.fireSuccess(req, clientObj);
+      }
+
+      return;
+    }
+
+    dump('BrowserElementProxy Error: ' +
+          'Received unhandled observer messages ' + stringifedData + '.\n');
+  },
+
+  _sendDOMRequest: function(methodName, args) {
+    let id = this._pendingDOMRequests.length;
+    let req = Services.DOMRequest.createRequest(this._window);
+
+    this._pendingDOMRequests.push(req);
+    this._sendToParent(methodName, args, id);
+
+    return req;
+  },
+
+  _sendToParent: function(methodName, args, domRequestId) {
+    let data = {
+      methodName: methodName,
+      args: args,
+      innerWindowID: this._innerWindowID
+    };
+
+    if (domRequestId) {
+      data.domRequestId = domRequestId;
+    }
+
+    Services.obs.notifyObservers(
+      this._window, 'browser-element-api:proxy-call', JSON.stringify(data));
+  },
+
+  _fireEvent: function(name, detail) {
+    let evt = this._createEvent(name, detail,
+                                /* cancelable = */ false);
+    this.__DOM_IMPL__.dispatchEvent(evt);
+  },
+
+  _createEvent: function(evtName, detail, cancelable) {
+    // This will have to change if we ever want to send a CustomEvent with null
+    // detail.  For now, it's OK.
+    if (detail !== undefined && detail !== null) {
+      detail = Cu.cloneInto(detail, this._window);
+      return new this._window.CustomEvent(evtName,
+                                          { bubbles: false,
+                                            cancelable: cancelable,
+                                            detail: detail });
+    }
+
+    return new this._window.Event(evtName,
+                                  { bubbles: false,
+                                    cancelable: cancelable });
+  },
+
+  setVisible: defineNoReturnMethod('setVisible'),
+  setActive: defineNoReturnMethod('setActive'),
+  sendMouseEvent: defineNoReturnMethod('sendMouseEvent'),
+  sendTouchEvent: defineNoReturnMethod('sendTouchEvent'),
+  goBack: defineNoReturnMethod('goBack'),
+  goForward: defineNoReturnMethod('goForward'),
+  reload: defineNoReturnMethod('reload'),
+  stop: defineNoReturnMethod('stop'),
+  zoom: defineNoReturnMethod('zoom'),
+  findAll: defineNoReturnMethod('findAll'),
+  findNext: defineNoReturnMethod('findNext'),
+  clearMatch: defineNoReturnMethod('clearMatch'),
+  mute: defineNoReturnMethod('mute'),
+  unmute: defineNoReturnMethod('unmute'),
+  setVolume: defineNoReturnMethod('setVolume'),
+
+  getVisible: defineDOMRequestMethod('getVisible'),
+  download: defineDOMRequestMethod('download'),
+  purgeHistory: defineDOMRequestMethod('purgeHistory'),
+  getCanGoBack: defineDOMRequestMethod('getCanGoBack'),
+  getCanGoForward: defineDOMRequestMethod('getCanGoForward'),
+  getContentDimensions: defineDOMRequestMethod('getContentDimensions'),
+  setInputMethodActive: defineDOMRequestMethod('setInputMethodActive'),
+  executeScript: defineDOMRequestMethod('executeScript'),
+  getMuted: defineDOMRequestMethod('getMuted'),
+  getVolume: defineDOMRequestMethod('getVolume'),
+
+  getActive: defineUnimplementedMethod('getActive'),
+  addNextPaintListener: defineUnimplementedMethod('addNextPaintListener'),
+  removeNextPaintListener: defineUnimplementedMethod('removeNextPaintListener'),
+  getScreenshot: defineUnimplementedMethod('getScreenshot')
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([BrowserElementProxy]);
diff --git a/dom/browser-element/BrowserElementProxy.manifest b/dom/browser-element/BrowserElementProxy.manifest
new file mode 100644
index 000000000..b26639523
--- /dev/null
+++ b/dom/browser-element/BrowserElementProxy.manifest
@@ -0,0 +1,2 @@
+component {7e95d54c-9930-49c8-9a10-44fe40fe8251} BrowserElementProxy.js
+contract @mozilla.org/dom/browser-element-proxy;1 {7e95d54c-9930-49c8-9a10-44fe40fe8251}
diff --git a/dom/browser-element/mochitest/async.js b/dom/browser-element/mochitest/async.js
new file mode 100644
index 000000000..d0007fa09
--- /dev/null
+++ b/dom/browser-element/mochitest/async.js
@@ -0,0 +1,78 @@
+/* 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/. */
+
+/*
+ * This is an approximate implementation of ES7's async-await pattern.
+ * see: https://github.com/tc39/ecmascript-asyncawait
+ *
+ * It allows for simple creation of async function and "tasks".
+ *
+ * For example:
+ *
+ *  var myThinger = {
+ *    doAsynThing: async(function*(url){
+ *      var result = yield fetch(url);
+ *      return process(result);
+ *    });
+ * }
+ *
+ * And Task-like things can be created as follows:
+ *
+ * var myTask = async(function*{
+ *   var result = yield fetch(url);
+ *   return result;
+ * });
+ * //returns a promise
+ *
+ * myTask().then(doSomethingElse);
+ *
+ */
+
+(function(exports) {
+  "use strict";
+  function async(func, self) {
+    return function asyncFunction() {
+      const functionArgs = Array.from(arguments);
+      return new Promise(function(resolve, reject) {
+        var gen;
+        if (typeof func !== "function") {
+          reject(new TypeError("Expected a Function."));
+        }
+        //not a generator, wrap it.
+        if (func.constructor.name !== "GeneratorFunction") {
+          gen = (function*() {
+            return func.apply(self, functionArgs);
+          }());
+        } else {
+          gen = func.apply(self, functionArgs);
+        }
+        try {
+          step(gen.next(undefined));
+        } catch (err) {
+          reject(err);
+        }
+
+        function step({value, done}) {
+          if (done) {
+            return resolve(value);
+          }
+          if (value instanceof Promise) {
+            return value.then(
+              result => step(gen.next(result)),
+              error => {
+                try {
+                  step(gen.throw(error));
+                } catch (err) {
+                  throw err;
+                }
+              }
+            ).catch(err => reject(err));
+          }
+          step(gen.next(value));
+        }
+      });
+    };
+  }
+  exports.async = async;
+}(this || self));
diff --git a/dom/browser-element/mochitest/audio.ogg b/dom/browser-element/mochitest/audio.ogg
new file mode 100644
index 000000000..44ab64f81
--- /dev/null
+++ b/dom/browser-element/mochitest/audio.ogg
diff --git a/dom/browser-element/mochitest/browserElementTestHelpers.js b/dom/browser-element/mochitest/browserElementTestHelpers.js
new file mode 100644
index 000000000..004b25333
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElementTestHelpers.js
@@ -0,0 +1,306 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Helpers for managing the browser frame preferences.
+"use strict";
+
+function _getPath() {
+  return window.location.pathname
+               .substring(0, window.location.pathname.lastIndexOf('/'))
+               .replace("/priority", "");
+}
+
+const browserElementTestHelpers = {
+  _getBoolPref: function(pref) {
+    try {
+      return SpecialPowers.getBoolPref(pref);
+    }
+    catch (e) {
+      return undefined;
+    }
+  },
+
+  _setPref: function(pref, value) {
+    this.lockTestReady();
+    if (value !== undefined && value !== null) {
+      SpecialPowers.pushPrefEnv({'set': [[pref, value]]}, this.unlockTestReady.bind(this));
+    } else {
+      SpecialPowers.pushPrefEnv({'clear': [[pref]]}, this.unlockTestReady.bind(this));
+    }
+  },
+
+  _setPrefs: function() {
+    this.lockTestReady();
+    SpecialPowers.pushPrefEnv({'set': Array.slice(arguments)}, this.unlockTestReady.bind(this));
+  },
+
+  _testReadyLockCount: 0,
+  _firedTestReady: false,
+  lockTestReady: function() {
+    this._testReadyLockCount++;
+  },
+
+  unlockTestReady: function() {
+    this._testReadyLockCount--;
+    if (this._testReadyLockCount == 0 && !this._firedTestReady) {
+      this._firedTestReady = true;
+      dispatchEvent(new Event("testready"));
+    }
+  },
+
+  enableProcessPriorityManager: function() {
+    this._setPrefs(
+      ['dom.ipc.processPriorityManager.BACKGROUND.LRUPoolLevels', 2],
+      ['dom.ipc.processPriorityManager.BACKGROUND_PERCEIVABLE.LRUPoolLevels', 2],
+      ['dom.ipc.processPriorityManager.testMode', true],
+      ['dom.ipc.processPriorityManager.enabled', true]
+    );
+  },
+
+  setClipboardPlainTextOnlyPref: function(value) {
+    this._setPref('clipboard.plainTextOnly', value);
+  },
+
+  setEnabledPref: function(value) {
+    this._setPrefs(['dom.mozBrowserFramesEnabled', value],
+                   ['network.disable.ipc.security', value]);
+  },
+
+  setupAccessibleCaretPref: function() {
+    this._setPref('layout.accessiblecaret.enabled', true);
+    // Disable hide carets for mouse input for select-all tests so that we can
+    // get mozbrowsercaretstatechanged events.
+    this._setPref('layout.accessiblecaret.hide_carets_for_mouse_input', false);
+  },
+
+  getOOPByDefaultPref: function() {
+    return this._getBoolPref("dom.ipc.browser_frames.oop_by_default");
+  },
+
+  addPermission: function() {
+    this.lockTestReady();
+    SpecialPowers.pushPermissions(
+      [{'type': "browser", 'allow': 1, 'context': document}],
+      this.unlockTestReady.bind(this));
+  },
+
+  _observers: [],
+
+  // This function is a wrapper which lets you register an observer to one of
+  // the process priority manager's test-only topics.  observerFn should be a
+  // function which takes (subject, topic, data).
+  //
+  // We'll clean up any observers you add at the end of the test.
+  addProcessPriorityObserver: function(processPriorityTopic, observerFn) {
+    var topic = "process-priority-manager:TEST-ONLY:" + processPriorityTopic;
+
+    // SpecialPowers appears to require that the observer be an object, not a
+    // function.
+    var observer = {
+      observe: observerFn
+    };
+
+    SpecialPowers.addObserver(observer, topic, /* weak = */ false);
+    this._observers.push([observer, topic]);
+  },
+
+  cleanUp: function() {
+    for (var i = 0; i < this._observers.length; i++) {
+      SpecialPowers.removeObserver(this._observers[i][0],
+                                   this._observers[i][1]);
+    }
+  },
+
+  // Some basically-empty pages from different domains you can load.
+  'emptyPage1': 'http://example.com' + _getPath() + '/file_empty.html',
+  'fileEmptyPage1': 'file_empty.html',
+  'emptyPage2': 'http://example.org' + _getPath() + '/file_empty.html',
+  'emptyPage3': 'http://test1.example.org' + _getPath() + '/file_empty.html',
+  'focusPage': 'http://example.org' + _getPath() + '/file_focus.html',
+};
+
+// Returns a promise which is resolved when a subprocess is created.  The
+// argument to resolve() is the childID of the subprocess.
+function expectProcessCreated(/* optional */ initialPriority) {
+  return new Promise(function(resolve, reject) {
+    var observed = false;
+    browserElementTestHelpers.addProcessPriorityObserver(
+      "process-created",
+      function(subject, topic, data) {
+        // Don't run this observer twice, so we don't ok(true) twice.  (It's fine
+        // to resolve a promise twice; the second resolve() call does nothing.)
+        if (observed) {
+          return;
+        }
+        observed = true;
+
+        var childID = parseInt(data);
+        ok(true, 'Got new process, id=' + childID);
+        if (initialPriority) {
+          expectPriorityChange(childID, initialPriority).then(function() {
+            resolve(childID);
+          });
+        } else {
+          resolve(childID);
+        }
+      }
+    );
+  });
+}
+
+// Just like expectProcessCreated(), except we'll call ok(false) if a second
+// process is created.
+function expectOnlyOneProcessCreated(/* optional */ initialPriority) {
+  var p = expectProcessCreated(initialPriority);
+  p.then(function() {
+    expectProcessCreated().then(function(childID) {
+      ok(false, 'Got unexpected process creation, childID=' + childID);
+    });
+  });
+  return p;
+}
+
+// Returns a promise which is resolved or rejected the next time the process
+// childID changes its priority. We resolve if the priority matches
+// expectedPriority, and we reject otherwise.
+
+function expectPriorityChange(childID, expectedPriority) {
+  return new Promise(function(resolve, reject) {
+    var observed = false;
+    browserElementTestHelpers.addProcessPriorityObserver(
+      'process-priority-set',
+      function(subject, topic, data) {
+        if (observed) {
+          return;
+        }
+
+        var [id, priority] = data.split(":");
+        if (id != childID) {
+          return;
+        }
+
+        // Make sure we run the is() calls in this observer only once, otherwise
+        // we'll expect /every/ priority change to match expectedPriority.
+        observed = true;
+
+        is(priority, expectedPriority,
+           'Expected priority of childID ' + childID +
+           ' to change to ' + expectedPriority);
+
+        if (priority == expectedPriority) {
+          resolve();
+        } else {
+          reject();
+        }
+      }
+    );
+  });
+}
+
+// Returns a promise which is resolved or rejected the next time the
+// process childID changes its priority.  We resolve if the expectedPriority
+// matches the priority and the LRU parameter matches expectedLRU and we
+// reject otherwise.
+
+function expectPriorityWithLRUSet(childID, expectedPriority, expectedLRU) {
+  return new Promise(function(resolve, reject) {
+    var observed = false;
+    browserElementTestHelpers.addProcessPriorityObserver(
+      'process-priority-with-LRU-set',
+      function(subject, topic, data) {
+        if (observed) {
+          return;
+        }
+
+        var [id, priority, lru] = data.split(":");
+        if (id != childID) {
+          return;
+        }
+
+        // Make sure we run the is() calls in this observer only once,
+        // otherwise we'll expect /every/ priority/LRU change to match
+        // expectedPriority/expectedLRU.
+        observed = true;
+
+        is(lru, expectedLRU,
+           'Expected LRU ' + lru +
+           ' of childID ' + childID +
+           ' to change to ' + expectedLRU);
+
+        if ((priority == expectedPriority) && (lru == expectedLRU)) {
+          resolve();
+        } else {
+          reject();
+        }
+      }
+    );
+  });
+}
+
+// Returns a promise which is resolved the first time the given iframe fires
+// the mozbrowser##eventName event.
+function expectMozbrowserEvent(iframe, eventName) {
+  return new Promise(function(resolve, reject) {
+    iframe.addEventListener('mozbrowser' + eventName, function handler(e) {
+      iframe.removeEventListener('mozbrowser' + eventName, handler);
+      resolve(e);
+    });
+  });
+}
+
+// Set some prefs:
+//
+//  * browser.pagethumbnails.capturing_disabled: true
+//
+//    Disable tab view; it seriously messes us up.
+//
+//  * dom.ipc.browser_frames.oop_by_default
+//
+//    Enable or disable OOP-by-default depending on the test's filename.  You
+//    can still force OOP on or off with <iframe mozbrowser remote=true/false>,
+//    at least until bug 756376 lands.
+//
+//  * dom.ipc.tabs.disabled: false
+//
+//    Allow us to create OOP frames.  Even if they're not the default, some
+//    "in-process" tests create OOP frames.
+//
+//  * network.disable.ipc.security: true
+//
+//    Disable the networking security checks; our test harness just tests
+//    browser elements without sticking them in apps, and the security checks
+//    dislike that.
+//
+//    Unfortunately setting network.disable.ipc.security to false before the
+//    child process(es) created by this test have shut down can cause us to
+//    assert and kill the child process.  That doesn't cause the tests to fail,
+//    but it's still scary looking.  So we just set the pref to true and never
+//    pop that value.  We'll rely on the tests which test IPC security to set
+//    it to false.
+//
+//  * security.mixed_content.block_active_content: false
+//
+//    Disable mixed active content blocking, so that tests can confirm that mixed
+//    content results in a broken security state.
+
+(function() {
+  var oop = location.pathname.indexOf('_inproc_') == -1;
+
+  browserElementTestHelpers.lockTestReady();
+  SpecialPowers.setBoolPref("network.disable.ipc.security", true);
+  SpecialPowers.pushPrefEnv({set: [["browser.pagethumbnails.capturing_disabled", true],
+                                   ["dom.ipc.browser_frames.oop_by_default", oop],
+                                   ["dom.ipc.tabs.disabled", false],
+                                   ["security.mixed_content.block_active_content", false]]},
+                            browserElementTestHelpers.unlockTestReady.bind(browserElementTestHelpers));
+})();
+
+addEventListener('unload', function() {
+  browserElementTestHelpers.cleanUp();
+});
+
+// Wait for the load event before unlocking the test-ready event.
+browserElementTestHelpers.lockTestReady();
+addEventListener('load', function() {
+  SimpleTest.executeSoon(browserElementTestHelpers.unlockTestReady.bind(browserElementTestHelpers));
+});
diff --git a/dom/browser-element/mochitest/browserElement_ActiveStateChange.js b/dom/browser-element/mochitest/browserElement_ActiveStateChange.js
new file mode 100644
index 000000000..cfbc1cb1e
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ActiveStateChange.js
@@ -0,0 +1,108 @@
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var fileURL = 'chrome://mochitests/content/chrome/dom/browser-element/mochitest/file_browserElement_ActiveStateChange.html';
+var generator = runTests();
+var testFrame;
+var ac;
+
+function assert(aVal, aMessage) {
+  return (!aVal) ? error(aMessage) : 0;
+}
+
+function error(aMessage) {
+  ok(false, "Error : " + aMessage);
+  finish();
+}
+
+function continueTest() {
+  try {
+    generator.next();
+  } catch (e if e instanceof StopIteration) {
+    error("Stop test because of exception!");
+  }
+}
+
+function finish() {
+  document.body.removeChild(testFrame);
+  SimpleTest.finish();
+}
+
+function setCommand(aArg) {
+  assert(!!ac, "Audio channel doesn't exist!");
+  info("# Command = " + aArg);
+
+  testFrame.src = fileURL + '#' + aArg;
+  var expectedActive = false;
+  switch (aArg) {
+    case 'play':
+      expectedActive = true;
+      break;
+    case 'pause':
+      expectedActive = false;
+      break;
+    default :
+      error("Undefined command!");
+  }
+
+  ac.onactivestatechanged = () => {
+    ac.onactivestatechanged = null;
+    ac.isActive().onsuccess = (e) => {
+      is(expectedActive, e.target.result,
+         "Correct active state = " + expectedActive);
+      continueTest();
+    }
+  };
+}
+
+function runTests() {
+  setCommand('play');
+  yield undefined;
+
+  setCommand('pause');
+  yield undefined;
+
+  finish();
+  yield undefined;
+}
+
+function setupTestFrame() {
+  testFrame = document.createElement('iframe');
+  testFrame.setAttribute('mozbrowser', 'true');
+  testFrame.src = fileURL;
+
+  function loadend() {
+    testFrame.removeEventListener('mozbrowserloadend', loadend);
+    ok("allowedAudioChannels" in testFrame, "allowedAudioChannels exist");
+    var channels = testFrame.allowedAudioChannels;
+    is(channels.length, 9, "9 audio channel by default");
+
+    ac = channels[0];
+
+    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
+    ok("isActive" in ac, "isActive exists");
+    ok("onactivestatechanged" in ac, "onactivestatechanged exists");
+
+    generator.next();
+  }
+
+  function alertError(e) {
+    testFrame.removeEventListener('mozbrowsershowmodalprompt', alertError);
+    var message = e.detail.message
+    error(message);
+  }
+
+  testFrame.addEventListener('mozbrowserloadend', loadend);
+  testFrame.addEventListener('mozbrowsershowmodalprompt', alertError);
+  document.body.appendChild(testFrame);
+}
+
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [["b2g.system_startup_url", window.location.href]]},
+                            function() {
+    SimpleTest.executeSoon(setupTestFrame);
+  });
+});
+
diff --git a/dom/browser-element/mochitest/browserElement_Alert.js b/dom/browser-element/mochitest/browserElement_Alert.js
new file mode 100644
index 000000000..3c7c50720
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Alert.js
@@ -0,0 +1,304 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that alert works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var numPendingChildTests = 0;
+var iframe;
+var mm;
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  mm = SpecialPowers.getBrowserFrameMessageManager(iframe);
+  mm.addMessageListener('test-success', function(msg) {
+    numPendingChildTests--;
+    ok(true, SpecialPowers.wrap(msg).json);
+  });
+  mm.addMessageListener('test-fail', function(msg) {
+    numPendingChildTests--;
+    ok(false, SpecialPowers.wrap(msg).json);
+  });
+
+  // Wait for the initial load to finish, then navigate the page, then wait
+  // for that load to finish, then start test1.
+  iframe.addEventListener('mozbrowserloadend', function loadend() {
+    iframe.removeEventListener('mozbrowserloadend', loadend);
+    iframe.src = browserElementTestHelpers.emptyPage1;
+
+    iframe.addEventListener('mozbrowserloadend', function loadend2() {
+      iframe.removeEventListener('mozbrowserloadend', loadend2);
+      SimpleTest.executeSoon(test1);
+    });
+  });
+
+}
+
+function test1() {
+  iframe.addEventListener('mozbrowsershowmodalprompt', test2);
+
+  // Do window.alert within the iframe, then modify the global |testState|
+  // after the alert.
+  var script = 'data:,\
+    this.testState = 0; \
+    content.alert("Hello, world!"); \
+    this.testState = 1; \
+  ';
+
+  mm.loadFrameScript(script, /* allowDelayedLoad = */ false);
+
+  // Triggers a mozbrowsershowmodalprompt event, which sends us down to test2.
+}
+
+// test2 is a mozbrowsershowmodalprompt listener.
+function test2(e) {
+  iframe.removeEventListener("mozbrowsershowmodalprompt", test2);
+
+  is(e.detail.message, 'Hello, world!');
+  e.preventDefault(); // cause the alert to block.
+
+  SimpleTest.executeSoon(function() { test2a(e); });
+}
+
+function test2a(e) {
+  // The iframe should be blocked on the alert call at the moment, so testState
+  // should still be 0.
+  var script = 'data:,\
+    if (this.testState === 0) { \
+      sendAsyncMessage("test-success", "1: Correct testState"); \
+    } \
+    else { \
+      sendAsyncMessage("test-fail", "1: Wrong testState: " + this.testState); \
+    }';
+
+  mm.loadFrameScript(script, /* allowDelayedLoad = */ false);
+  numPendingChildTests++;
+
+  waitForPendingTests(function() { test3(e); });
+}
+
+function test3(e) {
+  // Now unblock the iframe and check that the script completed.
+  e.detail.unblock();
+
+  var script2 = 'data:,\
+    if (this.testState === 1) { \
+      sendAsyncMessage("test-success", "2: Correct testState"); \
+    } \
+    else { \
+      sendAsyncMessage("test-try-again", "2: Wrong testState (for now): " + this.testState); \
+    }';
+
+  // Urgh.  e.unblock() didn't necessarily unblock us immediately, so we have
+  // to spin and wait.
+  function onTryAgain() {
+    SimpleTest.executeSoon(function() {
+      //dump('onTryAgain\n');
+      mm.loadFrameScript(script2, /* allowDelayedLoad = */ false);
+    });
+  }
+
+  mm.addMessageListener('test-try-again', onTryAgain);
+  numPendingChildTests++;
+
+  onTryAgain();
+  waitForPendingTests(function() {
+    mm.removeMessageListener('test-try-again', onTryAgain);
+    test4();
+  });
+}
+
+function test4() {
+  // Navigate the iframe while an alert is pending.  This shouldn't screw
+  // things up.
+
+  iframe.addEventListener("mozbrowsershowmodalprompt", test5);
+
+  var script = 'data:,content.alert("test4");';
+  mm.loadFrameScript(script, /* allowDelayedLoad = */ false);
+}
+
+// test4 is a mozbrowsershowmodalprompt listener.
+function test5(e) {
+  iframe.removeEventListener('mozbrowsershowmodalprompt', test5);
+
+  is(e.detail.message, 'test4');
+  e.preventDefault(); // cause the page to block.
+
+  SimpleTest.executeSoon(test5a);
+}
+
+function test5a() {
+  iframe.addEventListener('mozbrowserloadend', test5b);
+  iframe.src = browserElementTestHelpers.emptyPage2;
+}
+
+function test5b() {
+  iframe.removeEventListener('mozbrowserloadend', test5b);
+  SimpleTest.executeSoon(test6);
+}
+
+// Test nested alerts
+var promptBlockers = [];
+function test6() {
+  iframe.addEventListener("mozbrowsershowmodalprompt", test6a);
+
+  var script = 'data:,\
+    this.testState = 0; \
+    content.alert(1); \
+    this.testState = 3; \
+  ';
+  mm.loadFrameScript(script, /* allowDelayedLoad = */ false);
+}
+
+function test6a(e) {
+  iframe.removeEventListener("mozbrowsershowmodalprompt", test6a);
+
+  is(e.detail.message, '1');
+  e.preventDefault(); // cause the alert to block.
+  promptBlockers.push(e);
+
+  SimpleTest.executeSoon(test6b);
+}
+
+function test6b() {
+  var script = 'data:,\
+    if (this.testState === 0) { \
+      sendAsyncMessage("test-success", "1: Correct testState"); \
+    } \
+    else { \
+      sendAsyncMessage("test-fail", "1: Wrong testState: " + this.testState); \
+    }';
+  mm.loadFrameScript(script, /* allowDelayedLoad = */ false);
+  numPendingChildTests++;
+
+  waitForPendingTests(test6c);
+}
+
+function test6c() {
+  iframe.addEventListener("mozbrowsershowmodalprompt", test6d);
+
+  var script = 'data:,\
+    this.testState = 1; \
+    content.alert(2); \
+    this.testState = 2; \
+  ';
+  mm.loadFrameScript(script, /* allowDelayedLoad = */ false);
+}
+
+function test6d(e) {
+  iframe.removeEventListener("mozbrowsershowmodalprompt", test6d);
+
+  is(e.detail.message, '2');
+  e.preventDefault(); // cause the alert to block.
+  promptBlockers.push(e);
+
+  SimpleTest.executeSoon(test6e);
+}
+
+function test6e() {
+  var script = 'data:,\
+    if (this.testState === 1) { \
+      sendAsyncMessage("test-success", "2: Correct testState"); \
+    } \
+    else { \
+      sendAsyncMessage("test-fail", "2: Wrong testState: " + this.testState); \
+    }';
+  mm.loadFrameScript(script, /* allowDelayedLoad = */ false);
+  numPendingChildTests++;
+
+  waitForPendingTests(test6f);
+}
+
+function test6f() {
+  var e = promptBlockers.pop();
+  // Now unblock the iframe and check that the script completed.
+  e.detail.unblock();
+
+  var script2 = 'data:,\
+    if (this.testState === 2) { \
+      sendAsyncMessage("test-success", "3: Correct testState"); \
+    } \
+    else { \
+      sendAsyncMessage("test-try-again", "3: Wrong testState (for now): " + this.testState); \
+    }';
+
+  // Urgh.  e.unblock() didn't necessarily unblock us immediately, so we have
+  // to spin and wait.
+  function onTryAgain() {
+    SimpleTest.executeSoon(function() {
+      //dump('onTryAgain\n');
+      mm.loadFrameScript(script2, /* allowDelayedLoad = */ false);
+    });
+  }
+
+  mm.addMessageListener('test-try-again', onTryAgain);
+  numPendingChildTests++;
+
+  onTryAgain();
+  waitForPendingTests(function() {
+    mm.removeMessageListener('test-try-again', onTryAgain);
+    test6g();
+  });
+}
+
+function test6g() {
+  var e = promptBlockers.pop();
+  // Now unblock the iframe and check that the script completed.
+  e.detail.unblock();
+
+  var script2 = 'data:,\
+    if (this.testState === 3) { \
+      sendAsyncMessage("test-success", "4: Correct testState"); \
+    } \
+    else { \
+      sendAsyncMessage("test-try-again", "4: Wrong testState (for now): " + this.testState); \
+    }';
+
+  // Urgh.  e.unblock() didn't necessarily unblock us immediately, so we have
+  // to spin and wait.
+  function onTryAgain() {
+    SimpleTest.executeSoon(function() {
+      //dump('onTryAgain\n');
+      mm.loadFrameScript(script2, /* allowDelayedLoad = */ false);
+    });
+  }
+
+  mm.addMessageListener('test-try-again', onTryAgain);
+  numPendingChildTests++;
+
+  onTryAgain();
+  waitForPendingTests(function() {
+    mm.removeMessageListener('test-try-again', onTryAgain);
+    test6h();
+  });
+}
+
+function test6h() {
+  SimpleTest.finish();
+}
+
+var prevNumPendingTests = null;
+function waitForPendingTests(next) {
+  if (numPendingChildTests !== prevNumPendingTests) {
+    dump("Waiting for end; " + numPendingChildTests + " pending tests\n");
+    prevNumPendingTests = numPendingChildTests;
+  }
+
+  if (numPendingChildTests > 0) {
+    SimpleTest.executeSoon(function() { waitForPendingTests(next); });
+    return;
+  }
+
+  prevNumPendingTests = null;
+  next();
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_AlertInFrame.js b/dom/browser-element/mochitest/browserElement_AlertInFrame.js
new file mode 100644
index 000000000..e9b606154
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_AlertInFrame.js
@@ -0,0 +1,24 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that alert works from inside an <iframe> inside an <iframe mozbrowser>.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    is(e.detail.message, 'Hello');
+    SimpleTest.finish();
+  });
+
+  iframe.src = 'file_browserElement_AlertInFrame.html';
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_AudioChannel.js b/dom/browser-element/mochitest/browserElement_AudioChannel.js
new file mode 100644
index 000000000..20f7b4e47
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_AudioChannel.js
@@ -0,0 +1,199 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 1113086 - tests for AudioChannel API into BrowserElement
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function noaudio() {
+  info("Test : no-audio");
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.src = 'chrome://mochitests/content/chrome/dom/browser-element/mochitest/file_empty.html';
+
+  function noaudio_loadend() {
+    ok("mute" in iframe, "iframe.mute exists");
+    ok("unmute" in iframe, "iframe.unmute exists");
+    ok("getMuted" in iframe, "iframe.getMuted exists");
+    ok("getVolume" in iframe, "iframe.getVolume exists");
+    ok("setVolume" in iframe, "iframe.setVolume exists");
+
+    ok("allowedAudioChannels" in iframe, "allowedAudioChannels exist");
+    var channels = iframe.allowedAudioChannels;
+    is(channels.length, 9, "9 audio channel by default");
+
+    var ac = channels[0];
+
+    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
+    ok("getVolume" in ac, "ac.getVolume exists");
+    ok("setVolume" in ac, "ac.setVolume exists");
+    ok("getMuted" in ac, "ac.getMuted exists");
+    ok("setMuted" in ac, "ac.setMuted exists");
+    ok("isActive" in ac, "ac.isActive exists");
+
+    new Promise(function(r, rr) {
+      var req = ac.getVolume();
+      ok(req instanceof DOMRequest, "This is a domRequest.");
+      req.onsuccess = function(e) {
+        is(e.target.result, 1.0, "The default volume should be 1.0");
+        r();
+      }
+    })
+
+    .then(function() {
+      return new Promise(function(resolve) {
+        iframe.mute();
+        iframe.getMuted()
+          .then(result => is(result, true, "iframe.getMuted should be true."))
+          .then(resolve);
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(resolve) {
+        iframe.unmute();
+        iframe.getMuted()
+          .then(result => is(result, false, "iframe.getMuted should be false."))
+          .then(resolve);
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(resolve) {
+        iframe.setVolume(0);
+        iframe.getVolume()
+          .then(result => is(result, 0, "iframe.getVolume should be 0."))
+          .then(resolve);
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(resolve) {
+        iframe.setVolume(1);
+        iframe.getVolume()
+          .then(result => is(result, 1, "iframe.getVolume should be 1."))
+          .then(resolve);
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(r, rr) {
+        ac.getMuted().onsuccess = function(e) {
+          is(e.target.result, false, "The default muted value should be false");
+          r();
+        }
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(r, rr) {
+        ac.setVolume(0.8).onsuccess = function() { r(); }
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(r, rr) {
+        ac.getVolume().onsuccess = function(e) {
+          // the actual value is 0.800000011920929..
+          ok(Math.abs(0.8 - e.target.result) < 0.01, "The new volume should be 0.8: " + e.target.result);
+          r();
+        }
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(r, rr) {
+        ac.setVolume(1.0).onsuccess = function() { r(); }
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(r, rr) {
+        ac.setMuted(true).onsuccess = function() { r(); }
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(r, rr) {
+        ac.getMuted().onsuccess = function(e) {
+          is(e.target.result, true, "The new muted value should be true");
+          r();
+        }
+      });
+    })
+
+    .then(function() {
+      return new Promise(function(r, rr) {
+        ac.isActive().onsuccess = function(e) {
+          is(e.target.result, false, "ac.isActive is false: no audio element active.");
+          r();
+        }
+      });
+    })
+
+    .then(runTests);
+  }
+
+  iframe.addEventListener('mozbrowserloadend', noaudio_loadend);
+  document.body.appendChild(iframe);
+}
+
+function audio() {
+  info("Test : audio");
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.src = 'chrome://mochitests/content/chrome/dom/browser-element/mochitest/iframe_file_audio.html';
+
+  function audio_loadend() {
+    ok("mute" in iframe, "iframe.mute exists");
+    ok("unmute" in iframe, "iframe.unmute exists");
+    ok("getMuted" in iframe, "iframe.getMuted exists");
+    ok("getVolume" in iframe, "iframe.getVolume exists");
+    ok("setVolume" in iframe, "iframe.setVolume exists");
+
+    ok("allowedAudioChannels" in iframe, "allowedAudioChannels exist");
+    var channels = iframe.allowedAudioChannels;
+    is(channels.length, 9, "9 audio channel by default");
+
+    var ac = channels[0];
+
+    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
+    ok("getVolume" in ac, "ac.getVolume exists");
+    ok("setVolume" in ac, "ac.setVolume exists");
+    ok("getMuted" in ac, "ac.getMuted exists");
+    ok("setMuted" in ac, "ac.setMuted exists");
+    ok("isActive" in ac, "ac.isActive exists");
+
+    ac.onactivestatechanged = function() {
+      ok(true, "activestatechanged event received.");
+      ac.onactivestatechanged = null;
+      document.body.removeChild(iframe);
+      runTests();
+    }
+  }
+
+  iframe.addEventListener('mozbrowserloadend', audio_loadend);
+  document.body.appendChild(iframe);
+}
+
+var tests = [ noaudio, audio ];
+
+function runTests() {
+  if (tests.length == 0) {
+    SimpleTest.finish();
+    return;
+  }
+
+  var test = tests.shift();
+  test();
+}
+
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [["b2g.system_startup_url", window.location.href]]},
+                            function() {
+    SimpleTest.executeSoon(runTests);
+  });
+});
diff --git a/dom/browser-element/mochitest/browserElement_AudioChannelMutedByDefault.js b/dom/browser-element/mochitest/browserElement_AudioChannelMutedByDefault.js
new file mode 100644
index 000000000..897c4318a
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_AudioChannelMutedByDefault.js
@@ -0,0 +1,103 @@
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var fileURL = 'chrome://mochitests/content/chrome/dom/browser-element/mochitest/file_browserElement_AudioChannelMutedByDefault.html';
+var testFrame;
+var ac;
+
+function alertListener(e) {
+  var message = e.detail.message
+  if (/^OK/.exec(message)) {
+    ok(true, "Message from file : " + message);
+  } else if (/^KO/.exec(message)) {
+    error(message);
+  } else if (/DONE/.exec(message)) {
+    ok(true, "Audio playback success!");
+    finish();
+  } else {
+    error("Undefined event.");
+  }
+}
+
+function assert(aVal, aMessage) {
+  return (!aVal) ? error(aMessage) : 0;
+}
+
+function error(aMessage) {
+  ok(false, "Error : " + aMessage);
+  finish();
+}
+
+function finish() {
+  testFrame.removeEventListener('mozbrowsershowmodalprompt', alertListener);
+  document.body.removeChild(testFrame);
+  SimpleTest.finish();
+}
+
+function setCommand(aArg) {
+  assert(!!ac, "Audio channel doesn't exist!");
+  info("# Command = " + aArg);
+  testFrame.src = fileURL + '#' + aArg;
+
+  switch (aArg) {
+    case 'play':
+      ac.onactivestatechanged = () => {
+        ac.onactivestatechanged = null;
+        ok(true, "activestatechanged event received.");
+
+        new Promise(function(r, rr) {
+          ac.getMuted().onsuccess = function(e) {
+            is(e.target.result, true, "Muted channel by default");
+            r();
+          }
+        }).then(function() {
+          ac.setMuted(false).onsuccess = function(e) {
+            ok(true, "Unmuted the channel.");
+          }
+        });
+      };
+      break;
+    default :
+      error("Undefined command!");
+  }
+}
+
+function runTests() {
+  setCommand('play');
+}
+
+function setupTestFrame() {
+  testFrame = document.createElement('iframe');
+  testFrame.setAttribute('mozbrowser', 'true');
+  testFrame.src = fileURL;
+
+  function loadend() {
+    testFrame.removeEventListener('mozbrowserloadend', loadend);
+    ok("allowedAudioChannels" in testFrame, "allowedAudioChannels exist");
+    var channels = testFrame.allowedAudioChannels;
+    is(channels.length, 9, "9 audio channel by default");
+
+    ac = channels[0];
+    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
+    ok("getMuted" in ac, "ac.getMuted exists");
+    ok("setMuted" in ac, "ac.setMuted exists");
+    ok("onactivestatechanged" in ac, "onactivestatechanged exists");
+
+    runTests();
+  }
+
+  info("Set EventListeners.");
+  testFrame.addEventListener('mozbrowsershowmodalprompt', alertListener);
+  testFrame.addEventListener('mozbrowserloadend', loadend);
+  document.body.appendChild(testFrame);
+}
+
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [["b2g.system_startup_url", window.location.href],
+                                     ["dom.audiochannel.mutedByDefault", true]]},
+                            function() {
+    SimpleTest.executeSoon(setupTestFrame);
+  });
+});
diff --git a/dom/browser-element/mochitest/browserElement_AudioChannelSeeking.js b/dom/browser-element/mochitest/browserElement_AudioChannelSeeking.js
new file mode 100644
index 000000000..f354a9d82
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_AudioChannelSeeking.js
@@ -0,0 +1,128 @@
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var fileURL = 'chrome://mochitests/content/chrome/dom/browser-element/mochitest/file_browserElement_AudioChannelSeeking.html';
+var generator = runTests();
+var testFrame;
+var ac;
+
+function alertListener(e) {
+  var message = e.detail.message
+  if (/^OK/.exec(message)) {
+    ok(true, "Message from file : " + message);
+    continueTest();
+  } else if (/^KO/.exec(message)) {
+    error(message);
+  } else if (/^INFO/.exec(message)) {
+    info("Message from file : " + message);
+  } else {
+    error("Undefined event.");
+  }
+}
+
+function assert(aVal, aMessage) {
+  return (!aVal) ? error(aMessage) : 0;
+}
+
+function error(aMessage) {
+  ok(false, "Error : " + aMessage);
+  finish();
+}
+
+function continueTest() {
+  try {
+    generator.next();
+  } catch (e if e instanceof StopIteration) {
+    error("Stop test because of exception!");
+  }
+}
+
+function finish() {
+  testFrame.removeEventListener('mozbrowsershowmodalprompt', alertListener);
+  ok(true, "Remove event-listener.");
+  document.body.removeChild(testFrame);
+  ok(true, "Remove test-frame from document.");
+  SimpleTest.finish();
+}
+
+function setCommand(aArg) {
+  assert(!!ac, "Audio channel doesn't exist!");
+  info("# Command = " + aArg);
+  testFrame.src = fileURL + '#' + aArg;
+
+  switch (aArg) {
+    case 'play':
+      ac.onactivestatechanged = () => {
+        ac.onactivestatechanged = null;
+        ok(true, "Receive onactivestatechanged after audio started.");
+        continueTest();
+      };
+      break;
+    case 'seeking':
+      ac.onactivestatechanged = () => {
+        ac.onactivestatechanged = null;
+        error("Should not receive onactivestatechanged during seeking!");
+      };
+      break;
+    case 'pause':
+      ac.onactivestatechanged = null;
+      break;
+    default :
+      error("Undefined command!");
+  }
+}
+
+function runTests() {
+  setCommand('play');
+  yield undefined;
+
+  setCommand('seeking');
+  yield undefined;
+
+  setCommand('seeking');
+  yield undefined;
+
+  setCommand('seeking');
+  yield undefined;
+
+  setCommand('pause');
+  yield undefined;
+
+  finish();
+  yield undefined;
+}
+
+function setupTestFrame() {
+  testFrame = document.createElement('iframe');
+  testFrame.setAttribute('mozbrowser', 'true');
+  testFrame.src = fileURL;
+
+  function loadend() {
+    testFrame.removeEventListener('mozbrowserloadend', loadend);
+    ok("allowedAudioChannels" in testFrame, "allowedAudioChannels exist");
+    var channels = testFrame.allowedAudioChannels;
+    is(channels.length, 9, "9 audio channel by default");
+
+    ac = channels[0];
+    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
+    ok("onactivestatechanged" in ac, "onactivestatechanged exists");
+
+    continueTest();
+  }
+
+  testFrame.addEventListener('mozbrowsershowmodalprompt', alertListener);
+  testFrame.addEventListener('mozbrowserloadend', loadend);
+  ok(true, "Add event-listeners.");
+
+  document.body.appendChild(testFrame);
+  ok(true, "Append test-frame to document.");
+}
+
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [["b2g.system_startup_url", window.location.href]]},
+                            function() {
+    SimpleTest.executeSoon(setupTestFrame);
+  });
+});
diff --git a/dom/browser-element/mochitest/browserElement_AudioChannel_nested.js b/dom/browser-element/mochitest/browserElement_AudioChannel_nested.js
new file mode 100644
index 000000000..2ed432b2a
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_AudioChannel_nested.js
@@ -0,0 +1,69 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 1113086 - tests for AudioChannel API into BrowserElement
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTests() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  var listener = function(e) {
+    var message = e.detail.message;
+    if (/^OK/.exec(message)) {
+      ok(true, "Message from app: " + message);
+    } else if (/^KO/.exec(message)) {
+      ok(false, "Message from app: " + message);
+    } else if (/DONE/.exec(message)) {
+      ok(true, "Messaging from app complete");
+      iframe.removeEventListener('mozbrowsershowmodalprompt', listener);
+      SimpleTest.finish();
+    }
+  }
+
+  function audio_loadend() {
+    ok("mute" in iframe, "iframe.mute exists");
+    ok("unmute" in iframe, "iframe.unmute exists");
+    ok("getMuted" in iframe, "iframe.getMuted exists");
+    ok("getVolume" in iframe, "iframe.getVolume exists");
+    ok("setVolume" in iframe, "iframe.setVolume exists");
+
+    ok("allowedAudioChannels" in iframe, "allowedAudioChannels exist");
+    var channels = iframe.allowedAudioChannels;
+    is(channels.length, 9, "9 audio channel by default");
+
+    var ac = channels[0];
+
+    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
+    ok("getVolume" in ac, "ac.getVolume exists");
+    ok("setVolume" in ac, "ac.setVolume exists");
+    ok("getMuted" in ac, "ac.getMuted exists");
+    ok("setMuted" in ac, "ac.setMuted exists");
+    ok("isActive" in ac, "ac.isActive exists");
+
+    info("Setting the volume...");
+    ac.setVolume(0.5);
+
+    ac.onactivestatechanged = function() {
+      ok(true, "activestatechanged event received.");
+      ac.onactivestatechanged = null;
+    }
+  }
+
+  iframe.addEventListener('mozbrowserloadend', audio_loadend);
+  iframe.addEventListener('mozbrowsershowmodalprompt', listener, false);
+  document.body.appendChild(iframe);
+
+  iframe.src = 'chrome://mochitests/content/chrome/dom/browser-element/mochitest/file_browserElement_AudioChannel_nested.html';
+}
+
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [["b2g.system_startup_url", window.location.href]]},
+                            function() {
+    SimpleTest.executeSoon(runTests);
+  });
+});
diff --git a/dom/browser-element/mochitest/browserElement_AudioPlayback.js b/dom/browser-element/mochitest/browserElement_AudioPlayback.js
new file mode 100644
index 000000000..bcbe89cb1
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_AudioPlayback.js
@@ -0,0 +1,75 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test the mozbrowseraudioplaybackchange event is fired correctly.
+'use strict';
+
+const { Services } = SpecialPowers.Cu.import('resource://gre/modules/Services.jsm');
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+/**
+ * Content script passed to the child iframe
+ */
+function playAudioScript() {
+  var audio = new content.Audio();
+  content.document.body.appendChild(audio);
+  audio.oncanplay = function() {
+    audio.play();
+  };
+  audio.src = 'audio.ogg';
+}
+
+/**
+ * Creates a simple mozbrowser frame
+ */
+function createFrame() {
+  let iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+  return iframe;
+}
+
+function runTest() {
+  SimpleTest.waitForExplicitFinish();
+
+  let iframe = createFrame();
+  let iframe2 = createFrame();
+
+  // When the first iframe is finished loading inject a script to create
+  // an audio element and play it.
+  iframe.addEventListener('mozbrowserloadend', () => {
+    let mm = SpecialPowers.getBrowserFrameMessageManager(iframe);
+    mm.loadFrameScript('data:,(' + playAudioScript.toString() + ')();', false);
+  });
+
+  // Two events should come in, when the audio starts, and stops playing.
+  // The first one should have a detail of 'active' and the second one
+  // should have a detail of 'inactive-pause'.
+  let expectedNextData = 'active';
+  iframe.addEventListener('mozbrowseraudioplaybackchange', (e) => {
+    is(e.detail, expectedNextData, 'Audio detail should be correct')
+    is(e.target, iframe, 'event target should be the first iframe')
+    if (e.detail === 'inactive-pause') {
+      SimpleTest.finish();
+    }
+    expectedNextData = 'inactive-pause';
+  });
+
+  // Make sure an event only goes to the first iframe.
+  iframe2.addEventListener('mozbrowseraudioplaybackchange', (e) => {
+    ok(false,
+       'mozbrowseraudioplaybackchange should dispatch to the correct browser');
+  });
+
+  // Load a simple page to get the process started.
+  iframe.src = browserElementTestHelpers.fileEmptyPage1;
+}
+
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [["b2g.system_startup_url", window.location.href]]},
+                            function() {
+    SimpleTest.executeSoon(runTest);
+  });
+});
diff --git a/dom/browser-element/mochitest/browserElement_Auth.js b/dom/browser-element/mochitest/browserElement_Auth.js
new file mode 100644
index 000000000..ef95409be
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Auth.js
@@ -0,0 +1,246 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that auth prompt works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+const { NetUtil } = SpecialPowers.Cu.import('resource://gre/modules/NetUtil.jsm');
+
+function testFail(msg) {
+  ok(false, JSON.stringify(msg));
+}
+
+var iframe;
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  // Wait for the initial load to finish, then navigate the page, then start test
+  // by loading SJS with http 401 response.
+  iframe.addEventListener('mozbrowserloadend', function loadend() {
+    iframe.removeEventListener('mozbrowserloadend', loadend);
+    iframe.addEventListener('mozbrowserusernameandpasswordrequired', testHttpAuthCancel);
+    SimpleTest.executeSoon(function() {
+      // Use absolute path because we need to specify host.
+      iframe.src = 'http://test/tests/dom/browser-element/mochitest/file_http_401_response.sjs';
+    });
+  });
+}
+
+function testHttpAuthCancel(e) {
+  iframe.removeEventListener("mozbrowserusernameandpasswordrequired", testHttpAuthCancel);
+  // Will cancel authentication, but prompt should not be shown again. Instead,
+  // we will be led to fail message
+  iframe.addEventListener("mozbrowserusernameandpasswordrequired", testFail);
+  iframe.addEventListener("mozbrowsertitlechange", function onTitleChange(e) {
+    iframe.removeEventListener("mozbrowsertitlechange", onTitleChange);
+    iframe.removeEventListener("mozbrowserusernameandpasswordrequired", testFail);
+    is(e.detail, 'http auth failed', 'expected authentication to fail');
+    iframe.addEventListener('mozbrowserusernameandpasswordrequired', testHttpAuth);
+    SimpleTest.executeSoon(function() {
+      // Use absolute path because we need to specify host.
+      iframe.src = 'http://test/tests/dom/browser-element/mochitest/file_http_401_response.sjs';
+    });
+  });
+
+  is(e.detail.realm, 'http_realm', 'expected realm matches');
+  is(e.detail.host, 'http://test', 'expected host matches');
+  is(e.detail.path,
+     '/tests/dom/browser-element/mochitest/file_http_401_response.sjs',
+     'expected path matches');
+  e.preventDefault();
+
+  SimpleTest.executeSoon(function() {
+    e.detail.cancel();
+  });
+}
+
+function testHttpAuth(e) {
+  iframe.removeEventListener("mozbrowserusernameandpasswordrequired", testHttpAuth);
+
+  // Will authenticate with correct password, prompt should not be
+  // called again.
+  iframe.addEventListener("mozbrowserusernameandpasswordrequired", testFail);
+  iframe.addEventListener("mozbrowsertitlechange", function onTitleChange(e) {
+    iframe.removeEventListener("mozbrowsertitlechange", onTitleChange);
+    iframe.removeEventListener("mozbrowserusernameandpasswordrequired", testFail);
+    is(e.detail, 'http auth success', 'expect authentication to succeed');
+    SimpleTest.executeSoon(testProxyAuth);
+  });
+
+  is(e.detail.realm, 'http_realm', 'expected realm matches');
+  is(e.detail.host, 'http://test', 'expected host matches');
+  is(e.detail.path,
+     '/tests/dom/browser-element/mochitest/file_http_401_response.sjs',
+     'expected path matches');
+  is(e.detail.isProxy, false, 'expected isProxy is false');
+  e.preventDefault();
+
+  SimpleTest.executeSoon(function() {
+    e.detail.authenticate("httpuser", "httppass");
+  });
+}
+
+function testProxyAuth(e) {
+  // The testingSJS simulates the 407 proxy authentication required response
+  // for proxy server, which will trigger the browser element to send prompt
+  // event with proxy infomation.
+  var testingSJS = 'http://test/tests/dom/browser-element/mochitest/file_http_407_response.sjs';
+  var mozproxy;
+
+  function onUserNameAndPasswordRequired(e) {
+    iframe.removeEventListener("mozbrowserusernameandpasswordrequired",
+                               onUserNameAndPasswordRequired);
+    iframe.addEventListener("mozbrowsertitlechange", function onTitleChange(e) {
+      iframe.removeEventListener("mozbrowsertitlechange", onTitleChange);
+      iframe.removeEventListener("mozbrowserusernameandpasswordrequired", testFail);
+      is(e.detail, 'http auth success', 'expect authentication to succeed');
+      SimpleTest.executeSoon(testAuthJarNoInterfere);
+    });
+
+    is(e.detail.realm, 'http_realm', 'expected realm matches');
+    is(e.detail.host, mozproxy, 'expected host matches');
+    is(e.detail.path,
+       '/tests/dom/browser-element/mochitest/file_http_407_response.sjs',
+       'expected path matches');
+    is(e.detail.isProxy, true, 'expected isProxy is true');
+    e.preventDefault();
+
+    SimpleTest.executeSoon(function() {
+      e.detail.authenticate("proxyuser", "proxypass");
+    });
+  }
+
+  // Resolve proxy information used by the test suite, we need it to validate
+  // whether the proxy information delivered with the prompt event is correct.
+  var resolveCallback = SpecialPowers.wrapCallbackObject({
+    QueryInterface: function (iid) {
+      const interfaces = [Ci.nsIProtocolProxyCallback, Ci.nsISupports];
+
+      if (!interfaces.some( function(v) { return iid.equals(v) } )) {
+        throw SpecialPowers.Cr.NS_ERROR_NO_INTERFACE;
+      }
+      return this;
+    },
+
+    onProxyAvailable: function (req, channel, pi, status) {
+      isnot(pi, null, 'expected proxy information available');
+      if (pi) {
+        mozproxy = "moz-proxy://" + pi.host + ":" + pi.port;
+      }
+      iframe.addEventListener("mozbrowserusernameandpasswordrequired",
+                              onUserNameAndPasswordRequired);
+
+      iframe.src = testingSJS;
+    }
+  });
+
+  var channel = NetUtil.newChannel({
+    uri: testingSJS,
+    loadUsingSystemPrincipal: true
+  });
+
+  var pps = SpecialPowers.Cc["@mozilla.org/network/protocol-proxy-service;1"]
+            .getService();
+
+  pps.asyncResolve(channel, 0, resolveCallback);
+}
+
+function testAuthJarNoInterfere(e) {
+  var authMgr = SpecialPowers.Cc['@mozilla.org/network/http-auth-manager;1']
+    .getService(SpecialPowers.Ci.nsIHttpAuthManager);
+  var secMan = SpecialPowers.Cc["@mozilla.org/scriptsecuritymanager;1"]
+               .getService(SpecialPowers.Ci.nsIScriptSecurityManager);
+  var ioService = SpecialPowers.Cc["@mozilla.org/network/io-service;1"]
+                  .getService(SpecialPowers.Ci.nsIIOService);
+  var uri = ioService.newURI("http://test/tests/dom/browser-element/mochitest/file_http_401_response.sjs", null, null);
+
+  // Set a bunch of auth data that should not conflict with the correct auth data already
+  // stored in the cache.
+  var attrs = {appId: 1};
+  var principal = secMan.createCodebasePrincipal(uri, attrs);
+  authMgr.setAuthIdentity('http', 'test', -1, 'basic', 'http_realm',
+                          'tests/dom/browser-element/mochitest/file_http_401_response.sjs',
+                          '', 'httpuser', 'wrongpass', false, principal);
+  attrs = {appId: 1, inIsolatedMozBrowser: true};
+  principal = secMan.createCodebasePrincipal(uri, attrs);
+  authMgr.setAuthIdentity('http', 'test', -1, 'basic', 'http_realm',
+                          'tests/dom/browser-element/mochitest/file_http_401_response.sjs',
+                          '', 'httpuser', 'wrongpass', false, principal);
+  principal = secMan.createCodebasePrincipal(uri, {});
+  authMgr.setAuthIdentity('http', 'test', -1, 'basic', 'http_realm',
+                          'tests/dom/browser-element/mochitest/file_http_401_response.sjs',
+                          '', 'httpuser', 'wrongpass', false, principal);
+
+  // Will authenticate with correct password, prompt should not be
+  // called again.
+  iframe.addEventListener("mozbrowserusernameandpasswordrequired", testFail);
+  iframe.addEventListener("mozbrowsertitlechange", function onTitleChange(e) {
+    iframe.removeEventListener("mozbrowsertitlechange", onTitleChange);
+    iframe.removeEventListener("mozbrowserusernameandpasswordrequired", testFail);
+    is(e.detail, 'http auth success', 'expected authentication success');
+    SimpleTest.executeSoon(testAuthJarInterfere);
+  });
+
+  // Once more with feeling. Ensure that our new auth data doesn't interfere with this mozbrowser's
+  // auth data.
+  iframe.src = 'http://test/tests/dom/browser-element/mochitest/file_http_401_response.sjs';
+}
+
+function testAuthJarInterfere(e) {
+  var authMgr = SpecialPowers.Cc['@mozilla.org/network/http-auth-manager;1']
+    .getService(SpecialPowers.Ci.nsIHttpAuthManager);
+  var secMan = SpecialPowers.Cc["@mozilla.org/scriptsecuritymanager;1"]
+               .getService(SpecialPowers.Ci.nsIScriptSecurityManager);
+  var ioService = SpecialPowers.Cc["@mozilla.org/network/io-service;1"]
+                  .getService(SpecialPowers.Ci.nsIIOService);
+  var uri = ioService.newURI("http://test/tests/dom/browser-element/mochitest/file_http_401_response.sjs", null, null);
+
+  // Set some auth data that should overwrite the successful stored details.
+  var principal = secMan.createCodebasePrincipal(uri, {inIsolatedMozBrowser: true});
+  authMgr.setAuthIdentity('http', 'test', -1, 'basic', 'http_realm',
+                          'tests/dom/browser-element/mochitest/file_http_401_response.sjs',
+                          '', 'httpuser', 'wrongpass', false, principal);
+
+  // Will authenticate with correct password, prompt should not be
+  // called again.
+  var gotusernamepasswordrequired = false;
+  function onUserNameAndPasswordRequired() {
+      gotusernamepasswordrequired = true;
+  }
+  iframe.addEventListener("mozbrowserusernameandpasswordrequired",
+                          onUserNameAndPasswordRequired);
+  iframe.addEventListener("mozbrowsertitlechange", function onTitleChange(e) {
+    iframe.removeEventListener("mozbrowsertitlechange", onTitleChange);
+    iframe.removeEventListener("mozbrowserusernameandpasswordrequired",
+                               onUserNameAndPasswordRequired);
+    ok(gotusernamepasswordrequired,
+       "Should have dispatched mozbrowserusernameandpasswordrequired event");
+    testFinish();
+  });
+
+  // Once more with feeling. Ensure that our new auth data interferes with this mozbrowser's
+  // auth data.
+  iframe.src = 'http://test/tests/dom/browser-element/mochitest/file_http_401_response.sjs';
+}
+
+function testFinish() {
+  // Clear login information stored in password manager.
+  var authMgr = SpecialPowers.Cc['@mozilla.org/network/http-auth-manager;1']
+    .getService(SpecialPowers.Ci.nsIHttpAuthManager);
+  authMgr.clearAll();
+
+  var pwmgr = SpecialPowers.Cc["@mozilla.org/login-manager;1"]
+    .getService(SpecialPowers.Ci.nsILoginManager);
+  pwmgr.removeAllLogins();
+
+  SimpleTest.finish();
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_BackForward.js b/dom/browser-element/mochitest/browserElement_BackForward.js
new file mode 100644
index 000000000..26b6344c4
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_BackForward.js
@@ -0,0 +1,104 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 741755 - Test that canGo{Back,Forward} and go{Forward,Back} work with
+// <iframe mozbrowser>.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframe;
+function addOneShotIframeEventListener(event, fn) {
+  function wrapper(e) {
+    iframe.removeEventListener(event, wrapper);
+    fn(e);
+  };
+
+  iframe.addEventListener(event, wrapper);
+}
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  addOneShotIframeEventListener('mozbrowserloadend', function() {
+    SimpleTest.executeSoon(test2);
+  });
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+  document.body.appendChild(iframe);
+}
+
+function checkCanGoBackAndForward(canGoBack, canGoForward, nextTest) {
+  var seenCanGoBackResult = false;
+  iframe.getCanGoBack().onsuccess = function(e) {
+    is(seenCanGoBackResult, false, "onsuccess handler shouldn't be called twice.");
+    seenCanGoBackResult = true;
+    is(e.target.result, canGoBack);
+    maybeRunNextTest();
+  };
+
+  var seenCanGoForwardResult = false;
+  iframe.getCanGoForward().onsuccess = function(e) {
+    is(seenCanGoForwardResult, false, "onsuccess handler shouldn't be called twice.");
+    seenCanGoForwardResult = true;
+    is(e.target.result, canGoForward);
+    maybeRunNextTest();
+  };
+
+  function maybeRunNextTest() {
+    if (seenCanGoBackResult && seenCanGoForwardResult) {
+      nextTest();
+    }
+  }
+}
+
+function test2() {
+  checkCanGoBackAndForward(false, false, test3);
+}
+
+function test3() {
+  addOneShotIframeEventListener('mozbrowserloadend', function() {
+    checkCanGoBackAndForward(true, false, test4);
+  });
+
+  SimpleTest.executeSoon(function() {
+    iframe.src = browserElementTestHelpers.emptyPage2;
+  });
+}
+
+function test4() {
+  addOneShotIframeEventListener('mozbrowserlocationchange', function(e) {
+    is(e.detail.url, browserElementTestHelpers.emptyPage3);
+    is(e.detail.canGoBack, true);
+    is(e.detail.canGoForward, false);
+    checkCanGoBackAndForward(true, false, test5);
+  });
+
+  SimpleTest.executeSoon(function() {
+    iframe.src = browserElementTestHelpers.emptyPage3;
+  });
+}
+
+function test5() {
+  addOneShotIframeEventListener('mozbrowserlocationchange', function(e) {
+    is(e.detail.url, browserElementTestHelpers.emptyPage2);
+    is(e.detail.canGoBack, true);
+    is(e.detail.canGoForward, true);
+    checkCanGoBackAndForward(true, true, test6);
+  });
+  iframe.goBack();
+}
+
+function test6() {
+  addOneShotIframeEventListener('mozbrowserlocationchange', function(e) {
+    is(e.detail.url, browserElementTestHelpers.emptyPage1);
+    is(e.detail.canGoBack, false);
+    is(e.detail.canGoForward, true);
+    checkCanGoBackAndForward(false, true, SimpleTest.finish);
+  });
+  iframe.goBack();
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_BadScreenshot.js b/dom/browser-element/mochitest/browserElement_BadScreenshot.js
new file mode 100644
index 000000000..7b194da86
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_BadScreenshot.js
@@ -0,0 +1,71 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 800170 - Test that we get errors when we pass bad arguments to
+// mozbrowser's getScreenshot.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframe;
+var numPendingTests = 0;
+
+// Call iframe.getScreenshot with the given args.  If expectSuccess is true, we
+// expect the screenshot's onsuccess handler to fire.  Otherwise, we expect
+// getScreenshot() to throw an exception.
+function checkScreenshotResult(expectSuccess, args) {
+  var req;
+  try {
+    req = iframe.getScreenshot.apply(iframe, args);
+  }
+  catch(e) {
+    ok(!expectSuccess, "getScreenshot(" + JSON.stringify(args) + ") threw an exception.");
+    return;
+  }
+
+  numPendingTests++;
+  req.onsuccess = function() {
+    ok(expectSuccess, "getScreenshot(" + JSON.stringify(args) + ") succeeded.");
+    numPendingTests--;
+    if (numPendingTests == 0) {
+      SimpleTest.finish();
+    }
+  };
+
+  // We never expect to see onerror.
+  req.onerror = function() {
+    ok(false, "getScreenshot(" + JSON.stringify(args) + ") ran onerror.");
+    numPendingTests--;
+    if (numPendingTests == 0) {
+      SimpleTest.finish();
+    }
+  };
+}
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+  iframe.src = 'data:text/html,<html>' +
+    '<body style="background:green">hello</body></html>';
+
+  iframe.addEventListener('mozbrowserfirstpaint', function() {
+    // This one should succeed.
+    checkScreenshotResult(true, [100, 100]);
+
+    // These should fail.
+    checkScreenshotResult(false, []);
+    checkScreenshotResult(false, [100]);
+    checkScreenshotResult(false, ['a', 100]);
+    checkScreenshotResult(false, [100, 'a']);
+    checkScreenshotResult(false, [-1, 100]);
+    checkScreenshotResult(false, [100, -1]);
+
+    if (numPendingTests == 0) {
+      SimpleTest.finish();
+    }
+  });
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_BrowserWindowNamespace.js b/dom/browser-element/mochitest/browserElement_BrowserWindowNamespace.js
new file mode 100644
index 000000000..87c4a216c
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_BrowserWindowNamespace.js
@@ -0,0 +1,57 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 780351 - Test that mozbrowser does /not/ divide the window name namespace.
+// Multiple mozbrowsers inside the same app are like multiple browser tabs;
+// they share a window name namespace.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+
+  // Two mozbrowser frames with the same code both do the same
+  // window.open("foo", "bar") call.  We should only get one
+  // mozbrowseropenwindow event.
+
+  iframe1.addEventListener('mozbrowseropenwindow', function(e) {
+    ok(true, "Got first mozbrowseropenwindow event.");
+    document.body.appendChild(e.detail.frameElement);
+
+    e.detail.frameElement.addEventListener('mozbrowserlocationchange', function(e) {
+      if (e.detail.url == "http://example.com/#2") {
+        ok(true, "Got locationchange to http://example.com/#2");
+        SimpleTest.finish();
+      }
+      else {
+        ok(true, "Got locationchange to " + e.detail.url);
+      }
+    });
+
+    SimpleTest.executeSoon(function() {
+      var iframe2 = document.createElement('iframe');
+      // Make sure that iframe1 and iframe2 are in the same TabGroup by linking
+      // them through opener. Right now this API requires chrome privileges, as
+      // it is on MozFrameLoaderOwner.
+      SpecialPowers.wrap(iframe2).presetOpenerWindow(iframe1.contentWindow);
+      iframe2.setAttribute('mozbrowser', 'true');
+
+      iframe2.addEventListener('mozbrowseropenwindow', function(e) {
+        ok(false, "Got second mozbrowseropenwindow event.");
+      });
+
+      document.body.appendChild(iframe2);
+      iframe2.src = 'file_browserElement_BrowserWindowNamespace.html#2';
+    });
+  });
+
+  document.body.appendChild(iframe1);
+  iframe1.src = 'file_browserElement_BrowserWindowNamespace.html#1';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_BrowserWindowResize.js b/dom/browser-element/mochitest/browserElement_BrowserWindowResize.js
new file mode 100644
index 000000000..420b4bc34
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_BrowserWindowResize.js
@@ -0,0 +1,51 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 891763 - Test the mozbrowserresize event
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var srcResizeTo = "data:text/html,       \
+    <script type='application/javascript'> \
+      window.resizeTo(300, 300);           \
+    <\/script>                             \
+  ";
+
+  var srcResizeBy = "data:text/html,       \
+    <script type='application/javascript'> \
+      window.resizeBy(-100, -100);         \
+    <\/script>                             \
+  ";
+
+  var count = 0;
+  function checkSize(iframe) {
+    count++;
+    is(iframe.clientWidth,  400, "iframe width does not change");
+    is(iframe.clientHeight, 400, "iframe height does not change");
+    if (count == 2) {
+      SimpleTest.finish();
+    }
+  }
+
+  function testIFrameWithSrc(src) {
+    var iframe = document.createElement('iframe');
+    iframe.setAttribute('mozbrowser', 'true');
+    iframe.style = "border:none; width:400px; height:400px;";
+    iframe.src = src;
+    iframe.addEventListener("mozbrowserresize", function (e) {
+      is(e.detail.width,  300, "Received correct resize event width");
+      is(e.detail.height, 300, "Received correct resize event height");
+      SimpleTest.executeSoon(checkSize.bind(undefined, iframe));
+    });
+    document.body.appendChild(iframe);
+  }
+
+  testIFrameWithSrc(srcResizeTo);
+  testIFrameWithSrc(srcResizeBy);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Close.js b/dom/browser-element/mochitest/browserElement_Close.js
new file mode 100644
index 000000000..57bdf384d
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Close.js
@@ -0,0 +1,24 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that window.close() works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  iframe.addEventListener("mozbrowserclose", function(e) {
+    ok(true, "got mozbrowserclose event.");
+    SimpleTest.finish();
+  });
+
+  iframe.src = "data:text/html,<html><body><script>window.close()</scr"+"ipt></body></html>";
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_CloseFromOpener.js b/dom/browser-element/mochitest/browserElement_CloseFromOpener.js
new file mode 100644
index 000000000..65ea4d1b7
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_CloseFromOpener.js
@@ -0,0 +1,33 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 764718 - Test that window.close() works from the opener window.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    ok(true, "got openwindow event.");
+    document.body.appendChild(e.detail.frameElement);
+
+    e.detail.frameElement.addEventListener("mozbrowserclose", function(e) {
+      ok(true, "got mozbrowserclose event.");
+      SimpleTest.finish();
+    });
+  });
+
+
+  document.body.appendChild(iframe);
+
+  // file_browserElement_CloseFromOpener opens a new window and then calls
+  // close() on it.
+  iframe.src = "file_browserElement_CloseFromOpener.html";
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_ContextmenuEvents.js b/dom/browser-element/mochitest/browserElement_ContextmenuEvents.js
new file mode 100644
index 000000000..66aa8e015
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ContextmenuEvents.js
@@ -0,0 +1,351 @@
+'use strict';
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.setClipboardPlainTextOnlyPref(false);
+browserElementTestHelpers.addPermission();
+
+var audioUrl = 'http://mochi.test:8888/tests/dom/browser-element/mochitest/audio.ogg';
+var videoUrl = 'http://mochi.test:8888/tests/dom/browser-element/mochitest/short-video.ogv';
+
+function runTests() {
+  createIframe(function onIframeLoaded() {
+    checkEmptyContextMenu();
+  });
+}
+
+function checkEmptyContextMenu() {
+  sendContextMenuTo('body', function onContextMenu(detail) {
+    is(detail.contextmenu, null, 'Body context clicks have no context menu');
+
+    checkInnerContextMenu();
+  });
+}
+
+function checkInnerContextMenu() {
+  sendContextMenuTo('#inner-link', function onContextMenu(detail) {
+    is(detail.systemTargets.length, 1, 'Includes anchor data');
+    is(detail.contextmenu.items.length, 3, 'Inner clicks trigger correct customized menu');
+    is(detail.contextmenu.items[0].label, 'foo', 'Customized menu has a "foo" menu item');
+    is(detail.contextmenu.items[1].label, 'bar', 'Customized menu has a "bar" menu item');
+    is(detail.contextmenu.items[2].id, 'copy-link', '#inner-link has a copy-link menu item');
+    is(detail.contextmenu.customized, true, 'Make sure contextmenu has customized items');
+
+    var target = detail.systemTargets[0];
+    is(target.nodeName, 'A', 'Reports correct nodeName');
+    is(target.data.uri, 'foo.html', 'Reports correct uri');
+    is(target.data.text, 'Menu 1', 'Reports correct link text');
+
+    checkCustomContextMenu();
+  });
+}
+
+function checkCustomContextMenu() {
+  sendContextMenuTo('#menu1-trigger', function onContextMenu(detail) {
+    is(detail.contextmenu.items.length, 2, 'trigger custom contextmenu');
+
+    checkNestedContextMenu();
+  });
+}
+
+function checkNestedContextMenu() {
+  sendContextMenuTo('#menu2-trigger', function onContextMenu(detail) {
+    var innerMenu = detail.contextmenu.items.filter(function(x) {
+      return x.type === 'menu';
+    });
+    is(detail.systemTargets.length, 2, 'Includes two systemTargets');
+    is(detail.systemTargets[0].nodeName, 'IMG', 'Includes "IMG" node');
+    is(detail.systemTargets[0].data.uri, 'example.png', 'Img data has the correct uri');
+    is(detail.systemTargets[1].nodeName, 'A', 'Includes "A" node');
+    is(detail.systemTargets[1].data.uri, 'bar.html', 'Anchor has the correct uri');
+    ok(innerMenu.length > 0, 'Menu contains a nested menu');
+
+    is(detail.contextmenu.items.length, 4, 'We have correct # of menu items')
+    is(detail.contextmenu.customized, true, 'Make sure contextmenu has customized items');
+    is(detail.contextmenu.items[0].label, 'outer', 'Customized menu has an "outer" menu item');
+    is(detail.contextmenu.items[1].label, 'submenu', 'Customized menu has an "submenu" menu item');
+    is(detail.contextmenu.items[2].id, 'copy-link', 'Has a copy-link menu item');
+    is(detail.contextmenu.items[3].id, 'copy-image', 'Has a copy-image menu item');
+    checkPreviousContextMenuHandler();
+  });
+}
+
+ // Finished testing the data passed to the contextmenu handler,
+ // now we start selecting contextmenu items
+function checkPreviousContextMenuHandler() {
+  // This is previously triggered contextmenu data, since we have
+  // fired subsequent contextmenus this should not be mistaken
+  // for a current menuitem
+  var detail = previousContextMenuDetail;
+  var previousId = detail.contextmenu.items[0].id;
+  checkContextMenuCallbackForId(detail, previousId, function onCallbackFired(label) {
+    is(label, null, 'Callback label should be empty since this handler is old');
+
+    checkCurrentContextMenuHandler();
+  });
+}
+
+function checkCurrentContextMenuHandler() {
+  // This triggers a current menuitem
+  var detail = currentContextMenuDetail;
+
+  var innerMenu = detail.contextmenu.items.filter(function(x) {
+    return x.type === 'menu';
+  });
+
+  var currentId = innerMenu[0].items[1].id;
+  checkContextMenuCallbackForId(detail, currentId, function onCallbackFired(label) {
+    is(label, 'inner 2', 'Callback label should be set correctly');
+
+    checkAgainCurrentContextMenuHandler();
+  });
+}
+
+function checkAgainCurrentContextMenuHandler() {
+  // Once an item it selected, subsequent selections are ignored
+  var detail = currentContextMenuDetail;
+
+  var innerMenu = detail.contextmenu.items.filter(function(x) {
+    return x.type === 'menu';
+  });
+
+  var currentId = innerMenu[0].items[1].id;
+  checkContextMenuCallbackForId(detail, currentId, function onCallbackFired(label) {
+    is(label, null, 'Callback label should be empty since this handler has already been used');
+
+    checkCallbackWithPreventDefault();
+  });
+};
+
+// Finished testing callbacks if the embedder calls preventDefault() on the
+// mozbrowsercontextmenu event, now we start checking for some cases where the embedder
+// does not want to call preventDefault() for some reasons.
+function checkCallbackWithPreventDefault() {
+  sendContextMenuTo('#menu1-trigger', function onContextMenu(detail) {
+    var id = detail.contextmenu.items[0].id;
+    checkContextMenuCallbackForId(detail, id, function onCallbackFired(label) {
+      is(label, 'foo', 'Callback label should be set correctly');
+
+      checkCallbackWithoutPreventDefault();
+    });
+  });
+}
+
+function checkCallbackWithoutPreventDefault() {
+  sendContextMenuTo('#menu1-trigger', function onContextMenu(detail) {
+    var id = detail.contextmenu.items[0].id;
+    checkContextMenuCallbackForId(detail, id, function onCallbackFired(label) {
+      is(label, null, 'Callback label should be null');
+
+      checkImageContextMenu();
+    });
+  }, /* ignorePreventDefault */ true);
+}
+
+function checkImageContextMenu() {
+  sendContextMenuTo('#menu3-trigger', function onContextMenu(detail) {
+    var target = detail.systemTargets[0];
+    is(target.nodeName, 'IMG', 'Reports correct nodeName');
+    is(target.data.uri, 'example.png', 'Reports correct uri');
+    is(detail.contextmenu.items.length, 1, 'Reports correct # of menu items');
+    is(detail.contextmenu.items[0].id, 'copy-image', 'IMG has a copy-image menu item');
+    is(detail.contextmenu.customized, false, 'Make sure we do not have customized items');
+
+    checkVideoContextMenu();
+  }, /* ignorePreventDefault */ true);
+}
+
+function checkVideoContextMenu() {
+  sendContextMenuTo('#menu4-trigger', function onContextMenu(detail) {
+    var target = detail.systemTargets[0];
+    is(target.nodeName, 'VIDEO', 'Reports correct nodeName');
+    is(target.data.uri, videoUrl, 'Reports uri correctly in data');
+    is(target.data.hasVideo, true, 'Video data in video tag does "hasVideo"');
+
+    checkAudioContextMenu();
+  }, /* ignorePreventDefault */ true);
+}
+
+function checkAudioContextMenu() {
+  sendContextMenuTo('#menu6-trigger', function onContextMenu(detail) {
+    var target = detail.systemTargets[0];
+    is(target.nodeName, 'AUDIO', 'Reports correct nodeName');
+    is(target.data.uri, audioUrl, 'Reports uri correctly in data');
+
+    checkAudioinVideoContextMenu();
+  }, /* ignorePreventDefault */ true);
+}
+
+function checkAudioinVideoContextMenu() {
+  sendSrcTo('#menu5-trigger', audioUrl, function onSrcSet() {
+    sendContextMenuTo('#menu5-trigger', function onContextMenu(detail) {
+      var target = detail.systemTargets[0];
+      is(target.nodeName, 'VIDEO', 'Reports correct nodeName');
+      is(target.data.uri, audioUrl, 'Reports uri correctly in data');
+      is(target.data.hasVideo, false, 'Audio data in video tag reports no "hasVideo"');
+
+      checkFormNoMethod();
+    }, /* ignorePreventDefault */ true);
+  });
+}
+
+function checkFormNoMethod() {
+  sendContextMenuTo('#menu7-trigger', function onContextMenu(detail) {
+    var target = detail.systemTargets[0];
+    is(target.nodeName, 'INPUT', 'Reports correct nodeName');
+    is(target.data.method, 'get', 'Reports correct method');
+    is(target.data.action, 'no_method', 'Reports correct action url');
+    is(target.data.name, 'input1', 'Reports correct input name');
+
+    checkFormGetMethod();
+  }, /* ignorePreventDefault */ true);
+}
+
+function checkFormGetMethod() {
+  sendContextMenuTo('#menu8-trigger', function onContextMenu(detail) {
+    var target = detail.systemTargets[0];
+    is(target.nodeName, 'INPUT', 'Reports correct nodeName');
+    is(target.data.method, 'get', 'Reports correct method');
+    is(target.data.action, 'http://example.com/get_method', 'Reports correct action url');
+    is(target.data.name, 'input2', 'Reports correct input name');
+
+    checkFormPostMethod();
+  }, /* ignorePreventDefault */ true);
+}
+
+function checkFormPostMethod() {
+  sendContextMenuTo('#menu9-trigger', function onContextMenu(detail) {
+    var target = detail.systemTargets[0];
+    is(target.nodeName, 'INPUT', 'Reports correct nodeName');
+    is(target.data.method, 'post', 'Reports correct method');
+    is(target.data.action, 'post_method', 'Reports correct action url');
+    is(target.data.name, 'input3', 'Reports correct input name');
+
+    SimpleTest.finish();
+  }, /* ignorePreventDefault */ true);
+}
+
+/* Helpers */
+var mm = null;
+var previousContextMenuDetail = null;
+var currentContextMenuDetail = null;
+
+function sendSrcTo(selector, src, callback) {
+  mm.sendAsyncMessage('setsrc', { 'selector': selector, 'src': src });
+  mm.addMessageListener('test:srcset', function onSrcSet(msg) {
+    mm.removeMessageListener('test:srcset', onSrcSet);
+    callback();
+  });
+}
+
+function sendContextMenuTo(selector, callback, ignorePreventDefault) {
+  iframe.addEventListener('mozbrowsercontextmenu', function oncontextmenu(e) {
+    iframe.removeEventListener(e.type, oncontextmenu);
+
+    // The embedder should call preventDefault() on the event if it will handle
+    // it. Not calling preventDefault() means it won't handle the event and 
+    // should not be able to deal with context menu callbacks.
+    if (ignorePreventDefault !== true) {
+      e.preventDefault();
+    }
+
+    // Keep a reference to previous/current contextmenu event details.
+    previousContextMenuDetail = currentContextMenuDetail;
+    currentContextMenuDetail = e.detail;
+
+    setTimeout(function() { callback(e.detail); });
+  });
+
+  mm.sendAsyncMessage('contextmenu', { 'selector': selector });
+}
+
+function checkContextMenuCallbackForId(detail, id, callback) {
+  mm.addMessageListener('test:callbackfired', function onCallbackFired(msg) {
+    mm.removeMessageListener('test:callbackfired', onCallbackFired);
+
+    msg = SpecialPowers.wrap(msg);
+    setTimeout(function() { callback(msg.data.label); });
+  });
+
+  detail.contextMenuItemSelected(id);
+}
+
+
+var iframe = null;
+function createIframe(callback) {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.src = 'data:text/html,<html>' +
+    '<body>' +
+    '<menu type="context" id="menu1" label="firstmenu">' +
+      '<menuitem label="foo" onclick="window.onContextMenuCallbackFired(event)"></menuitem>' +
+      '<menuitem label="bar" onclick="window.onContextMenuCallbackFired(event)"></menuitem>' +
+    '</menu>' +
+    '<menu type="context" id="menu2" label="secondmenu">' +
+      '<menuitem label="outer" onclick="window.onContextMenuCallbackFired(event)"></menuitem>' +
+      '<menu label="submenu">' +
+        '<menuitem label="inner 1"></menuitem>' +
+        '<menuitem label="inner 2" onclick="window.onContextMenuCallbackFired(event)"></menuitem>' +
+      '</menu>' +
+    '</menu>' +
+    '<div id="menu1-trigger" contextmenu="menu1"><a id="inner-link" href="foo.html">Menu 1</a></div>' +
+    '<a href="bar.html" contextmenu="menu2"><img id="menu2-trigger" src="example.png" /></a>' +
+    '<img id="menu3-trigger" src="example.png" />' +
+    '<video id="menu4-trigger" src="' + videoUrl + '"></video>' +
+    '<video id="menu5-trigger" preload="metadata"></video>' +
+    '<audio id="menu6-trigger" src="' + audioUrl + '"></audio>' +
+    '<form action="no_method"><input id="menu7-trigger" name="input1"></input></form>' +
+    '<form action="http://example.com/get_method" method="get"><input id="menu8-trigger" name="input2"></input></form>' +
+    '<form action="post_method" method="post"><input id="menu9-trigger" name="input3"></input></form>' +
+    '</body></html>';
+  document.body.appendChild(iframe);
+
+  // The following code will be included in the child
+  // =========================================================================
+  function iframeScript() {
+    addMessageListener('contextmenu', function onContextMenu(msg) {
+      var document = content.document;
+      var evt = document.createEvent('HTMLEvents');
+      evt.initEvent('contextmenu', true, true);
+      document.querySelector(msg.data.selector).dispatchEvent(evt);
+    });
+
+    addMessageListener('setsrc', function onContextMenu(msg) {
+      var wrappedTarget = content.document.querySelector(msg.data.selector);
+      var target = XPCNativeWrapper.unwrap(wrappedTarget);
+      target.addEventListener('loadedmetadata', function() {
+        sendAsyncMessage('test:srcset');
+      });
+      target.src = msg.data.src;
+    });
+
+    addMessageListener('browser-element-api:call', function onCallback(msg) {
+      if (msg.data.msg_name != 'fire-ctx-callback')
+        return;
+
+      /* Use setTimeout in order to react *after* the platform */
+      content.setTimeout(function() {
+        sendAsyncMessage('test:callbackfired', { label: label });
+        label = null;
+      });
+    });
+
+    var label = null;
+    XPCNativeWrapper.unwrap(content).onContextMenuCallbackFired = function(e) {
+      label = e.target.getAttribute('label');
+    };
+  }
+  // =========================================================================
+
+  iframe.addEventListener('mozbrowserloadend', function onload(e) {
+    iframe.removeEventListener(e.type, onload);
+    mm = SpecialPowers.getBrowserFrameMessageManager(iframe);
+    mm.loadFrameScript('data:,(' + iframeScript.toString() + ')();', false);
+
+    // Now we're ready, let's start testing.
+    callback();
+  });
+}
+
+addEventListener('testready', runTests);
diff --git a/dom/browser-element/mochitest/browserElement_CookiesNotThirdParty.js b/dom/browser-element/mochitest/browserElement_CookiesNotThirdParty.js
new file mode 100644
index 000000000..32f877786
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_CookiesNotThirdParty.js
@@ -0,0 +1,51 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 806127 - Test that cookies set by <iframe mozbrowser> are not considered
+// third-party.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  const innerPage = 'http://example.com/tests/dom/browser-element/mochitest/file_browserElement_CookiesNotThirdParty.html';
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    if (e.detail.message == 'next') {
+      iframe.src = innerPage + '?step=2';
+      return;
+    }
+
+    if (e.detail.message.startsWith('success:')) {
+      ok(true, e.detail.message);
+      return;
+    }
+
+    if (e.detail.message.startsWith('failure:')) {
+      ok(false, e.detail.message);
+      return;
+    }
+
+    if (e.detail.message == 'finish') {
+      SimpleTest.finish();
+    }
+  });
+
+  // innerPage will set a cookie and then alert('next').  We'll load
+  // innerPage?step=2.  That page will check that the cooke exists (despite the
+  // fact that we've disabled third-party cookies) and alert('success:') or
+  // alert('failure:'), as appropriate.  Finally, the page will
+  // alert('finish');
+  iframe.src = innerPage;
+  document.body.appendChild(iframe);
+}
+
+// Disable third-party cookies for this test.
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [['network.cookie.cookieBehavior', 1]]}, runTest);
+});
diff --git a/dom/browser-element/mochitest/browserElement_CopyPaste.js b/dom/browser-element/mochitest/browserElement_CopyPaste.js
new file mode 100644
index 000000000..b23feef59
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_CopyPaste.js
@@ -0,0 +1,339 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that "cut, copy, paste, selectall" and caretstatechanged event works from inside an <iframe mozbrowser>.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("untriaged");
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.setupAccessibleCaretPref();
+browserElementTestHelpers.addPermission();
+const { Services } = SpecialPowers.Cu.import('resource://gre/modules/Services.jsm');
+
+var gTextarea = null;
+var mm;
+var iframeOuter;
+var iframeInner;
+var state = 0;
+var stateMeaning;
+var defaultData;
+var pasteData;
+var focusScript;
+var createEmbededFrame = false;
+var testSelectionChange = false;
+
+function copyToClipboard(str) {
+  gTextarea.value = str;
+  SpecialPowers.wrap(gTextarea).editor.selectAll();
+  SpecialPowers.wrap(gTextarea).editor.copy();
+}
+
+function getScriptForGetContent() {
+  var script = 'data:,\
+    var elt = content.document.getElementById("text"); \
+    var txt = ""; \
+    if (elt) { \
+      if (elt.tagName === "DIV" || elt.tagName === "BODY") { \
+        txt = elt.textContent; \
+      } else { \
+        txt = elt.value; \
+      } \
+    } \
+    sendAsyncMessage("content-text", txt);';
+  return script;
+}
+
+function getScriptForSetFocus() {
+  var script = 'data:,' + focusScript + 'sendAsyncMessage("content-focus")';
+  return script;
+}
+
+function runTest() {
+  iframeOuter = document.createElement('iframe');
+  iframeOuter.setAttribute('mozbrowser', 'true');
+  if (createEmbededFrame) {
+    iframeOuter.src = "file_empty.html";
+  }
+  document.body.appendChild(iframeOuter);
+
+  gTextarea = document.createElement('textarea');
+  document.body.appendChild(gTextarea);
+
+  iframeOuter.addEventListener("mozbrowserloadend", function onloadend(e) {
+    iframeOuter.removeEventListener("mozbrowserloadend", onloadend);
+
+    if (createEmbededFrame) {
+      var contentWin = SpecialPowers.wrap(iframeOuter)
+                             .QueryInterface(SpecialPowers.Ci.nsIFrameLoaderOwner)
+                             .frameLoader.docShell.contentViewer.DOMDocument.defaultView;
+      var contentDoc = contentWin.document;
+      iframeInner = contentDoc.createElement('iframe');
+      iframeInner.setAttribute('mozbrowser', true);
+      iframeInner.setAttribute('remote', 'false');
+      contentDoc.body.appendChild(iframeInner);
+      iframeInner.addEventListener("mozbrowserloadend", function onloadendinner(e) {
+        iframeInner.removeEventListener("mozbrowserloadend", onloadendinner);
+        mm = SpecialPowers.getBrowserFrameMessageManager(iframeInner);
+        dispatchTest(e);
+      });
+    } else {
+      iframeInner = iframeOuter;
+      mm = SpecialPowers.getBrowserFrameMessageManager(iframeInner);
+      dispatchTest(e);
+    }
+  });
+}
+
+function doCommand(cmd) {
+  var COMMAND_MAP = {
+    'cut': 'cmd_cut',
+    'copy': 'cmd_copyAndCollapseToEnd',
+    'paste': 'cmd_paste',
+    'selectall': 'cmd_selectAll'
+  };
+  var script = 'data:,docShell.doCommand("' + COMMAND_MAP[cmd] + '");';
+  mm.loadFrameScript(script, false);
+}
+
+function dispatchTest(e) {
+  iframeInner.addEventListener("mozbrowserloadend", function onloadend2(e) {
+    iframeInner.removeEventListener("mozbrowserloadend", onloadend2);
+    iframeInner.focus();
+    SimpleTest.executeSoon(function() { testSelectAll(e); });
+  });
+
+  switch (state) {
+    case 0: // test for textarea
+      defaultData = "Test for selection change event";
+      pasteData = "from parent ";
+      iframeInner.src = "data:text/html,<html><body>" +
+                   "<textarea id='text'>" + defaultData + "</textarea>" +
+                   "</body>" +
+                   "</html>";
+      stateMeaning = " (test: textarea)";
+      focusScript = "var elt=content.document.getElementById('text');elt.focus();elt.select();";
+      break;
+    case 1: // test for input text
+      defaultData = "Test for selection change event";
+      pasteData = "from parent ";
+      iframeInner.src = "data:text/html,<html><body>" +
+                   "<input type='text' id='text' value='" + defaultData + "'>" +
+                   "</body>" +
+                   "</html>";
+      stateMeaning = " (test: <input type=text>)";
+      focusScript = "var elt=content.document.getElementById('text');elt.focus();elt.select();";
+      break;
+    case 2: // test for input number
+      defaultData = "12345";
+      pasteData = "67890";
+      iframeInner.src = "data:text/html,<html><body>" +
+                   "<input type='number' id='text' value='" + defaultData + "'>" +
+                   "</body>" +
+                   "</html>";
+      stateMeaning = " (test: <input type=number>)";
+      focusScript = "var elt=content.document.getElementById('text');elt.focus();elt.select();";
+      break;
+    case 3: // test for div contenteditable
+      defaultData = "Test for selection change event";
+      pasteData = "from parent ";
+      iframeInner.src = "data:text/html,<html><body>" +
+                   "<div contenteditable='true' id='text'>" + defaultData + "</div>" +
+                   "</body>" +
+                   "</html>";
+      stateMeaning = " (test: content editable div)";
+      focusScript = "var elt=content.document.getElementById('text');elt.focus();";
+      break;
+    case 4: // test for normal div
+      defaultData = "Test for selection change event";
+      pasteData = "from parent ";
+      iframeInner.src = "data:text/html,<html><body>" +
+                   "<div id='text'>" + defaultData + "</div>" +
+                   "</body>" +
+                   "</html>";
+      stateMeaning = " (test: normal div)";
+      focusScript = "var elt=content.document.getElementById('text');elt.focus();";
+      break;
+    case 5: // test for normal div with designMode:on
+      defaultData = "Test for selection change event";
+      pasteData = "from parent ";
+      iframeInner.src = "data:text/html,<html><body id='text'>" +
+                   defaultData +
+                   "</body>" +
+                   "<script>document.designMode='on';</script>" +
+                   "</html>";
+      stateMeaning = " (test: normal div with designMode:on)";
+      focusScript = "var elt=content.document.getElementById('text');elt.focus();";
+      break;
+    default:
+      if (createEmbededFrame || browserElementTestHelpers.getOOPByDefaultPref()) {
+        SimpleTest.finish();
+      } else {
+        createEmbededFrame = true;
+
+        // clean up and run test again.
+        document.body.removeChild(iframeOuter);
+        document.body.removeChild(gTextarea);
+        state = 0;
+        runTest();
+      }
+      break;
+  }
+}
+
+function isChildProcess() {
+  return SpecialPowers.Cc["@mozilla.org/xre/app-info;1"]
+                         .getService(SpecialPowers.Ci.nsIXULRuntime)
+                         .processType != SpecialPowers.Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+}
+
+function testSelectAll(e) {
+  // Skip mozbrowser test if we're at child process.
+  if (!isChildProcess()) {
+    let eventName = "mozbrowsercaretstatechanged";
+    iframeOuter.addEventListener(eventName, function caretchangeforselectall(e) {
+      iframeOuter.removeEventListener(eventName, caretchangeforselectall, true);
+      ok(true, "got mozbrowsercaretstatechanged event." + stateMeaning);
+      ok(e.detail, "event.detail is not null." + stateMeaning);
+      ok(e.detail.width != 0, "event.detail.width is not zero" + stateMeaning);
+      ok(e.detail.height != 0, "event.detail.height is not zero" + stateMeaning);
+      SimpleTest.executeSoon(function() { testCopy1(e); });
+    }, true);
+  }
+
+  mm.addMessageListener('content-focus', function messageforfocus(msg) {
+    mm.removeMessageListener('content-focus', messageforfocus);
+    // test selectall command, after calling this the caretstatechanged event should be fired.
+    doCommand('selectall');
+    if (isChildProcess()) {
+      SimpleTest.executeSoon(function() { testCopy1(e); });
+    }
+  });
+
+  mm.loadFrameScript(getScriptForSetFocus(), false);
+}
+
+function testCopy1(e) {
+  // Right now we're at "selectall" state, so we can test copy commnad by
+  // calling doCommand
+  copyToClipboard("");
+  let setup = function() {
+    doCommand("copy");
+  };
+
+  let nextTest = function(success) {
+    ok(success, "copy command works" + stateMeaning);
+    SimpleTest.executeSoon(function() { testPaste1(e); });
+  };
+
+  let success = function() {
+    nextTest(true);
+  }
+
+  let fail = function() {
+    nextTest(false);
+  }
+
+  let compareData = defaultData;
+  SimpleTest.waitForClipboard(compareData, setup, success, fail);
+}
+
+function testPaste1(e) {
+  // Next test paste command, first we copy to global clipboard in parent side.
+  // Then paste it to child side.
+  copyToClipboard(pasteData);
+
+  doCommand('selectall');
+  doCommand("paste");
+  SimpleTest.executeSoon(function() { testPaste2(e); });
+}
+
+function testPaste2(e) {
+  mm.addMessageListener('content-text', function messageforpaste(msg) {
+    mm.removeMessageListener('content-text', messageforpaste);
+    if (state == 4) {
+      // normal div cannot paste, so the content remain unchange
+      ok(SpecialPowers.wrap(msg).json === defaultData, "paste command works" + stateMeaning);
+    } else if (state == 3 && browserElementTestHelpers.getOOPByDefaultPref()) {
+      // Something weird when we doCommand with content editable element in OOP. Mark this case as todo
+      todo(false, "paste command works" + stateMeaning);
+    } else {
+      ok(SpecialPowers.wrap(msg).json === pasteData, "paste command works" + stateMeaning);
+    }
+    SimpleTest.executeSoon(function() { testCut1(e); });
+  });
+
+  mm.loadFrameScript(getScriptForGetContent(), false);
+}
+
+function testCut1(e) {
+  // Clean clipboard first
+  copyToClipboard("");
+  let setup = function() {
+    doCommand("selectall");
+    doCommand("cut");
+  };
+
+  let nextTest = function(success) {
+    if (state == 3 && browserElementTestHelpers.getOOPByDefaultPref()) {
+      // Something weird when we doCommand with content editable element in OOP.
+      todo(false, "cut function works" + stateMeaning);
+    } else {
+      ok(success, "cut function works" + stateMeaning);
+    }
+    SimpleTest.executeSoon(function() { testCut2(e); });
+  };
+
+  let success = function() {
+    nextTest(true);
+  }
+
+  let fail = function() {
+    nextTest(false);
+  }
+
+  let compareData = pasteData;
+  // Something weird when we doCommand with content editable element in OOP.
+  // Always true in this case
+  // Normal div case cannot cut, always true as well.
+  if ((state == 3 && browserElementTestHelpers.getOOPByDefaultPref()) ||
+      state == 4) {
+    compareData = function() { return true; }
+  }
+
+  SimpleTest.waitForClipboard(compareData, setup, success, fail);
+}
+
+function testCut2(e) {
+  mm.addMessageListener('content-text', function messageforcut(msg) {
+    mm.removeMessageListener('content-text', messageforcut);
+    // normal div cannot cut
+    if (state == 4) {
+      ok(SpecialPowers.wrap(msg).json !== "", "cut command works" + stateMeaning);
+    } else if (state == 3 && browserElementTestHelpers.getOOPByDefaultPref()) {
+      // Something weird when we doCommand with content editable element in OOP. Mark this case as todo
+      todo(false, "cut command works" + stateMeaning);
+    } else {
+      ok(SpecialPowers.wrap(msg).json === "", "cut command works" + stateMeaning);
+    }
+
+    state++;
+    dispatchTest(e);
+  });
+
+  mm.loadFrameScript(getScriptForGetContent(), false);
+}
+
+// Give our origin permission to open browsers, and remove it when the test is complete.
+var principal = SpecialPowers.wrap(document).nodePrincipal;
+var context = { url: SpecialPowers.wrap(principal.URI).spec,
+                originAttributes: {
+                  appId: principal.appId,
+                  inIsolatedMozBrowser: true }};
+
+addEventListener('testready', function() {
+  SpecialPowers.pushPermissions([
+    {type: 'browser', allow: 1, context: context}
+  ], runTest);
+});
+
diff --git a/dom/browser-element/mochitest/browserElement_DOMRequestError.js b/dom/browser-element/mochitest/browserElement_DOMRequestError.js
new file mode 100644
index 000000000..040cb81fd
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_DOMRequestError.js
@@ -0,0 +1,62 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test if DOMRequest returned by an iframe gets an error callback when
+// the iframe is not in the DOM.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  iframe1.src = 'data:text/html,<html>' +
+    '<body style="background:green">hello</body></html>';
+  document.body.appendChild(iframe1);
+
+  function testIframe(beforeRun, isErrorExpected, nextTest) {
+    return function() {
+      var error = false;
+      if (beforeRun)
+        beforeRun();
+      function testEnd() {
+        is(isErrorExpected, error);
+        SimpleTest.executeSoon(nextTest);
+      }
+
+      var domRequest = iframe1.getScreenshot(1000, 1000);
+      domRequest.onsuccess = function(e) {
+        testEnd();
+      }
+      domRequest.onerror = function(e) {
+        error = true;
+        testEnd();
+      }
+    };
+  }
+
+  function iframeLoadedHandler() {
+    iframe1.removeEventListener('mozbrowserloadend', iframeLoadedHandler);
+    // Test 1: iframe is in the DOM.
+    // Test 2: iframe is removed from the DOM.
+    // Test 3: iframe is added back into the DOM.
+    var test3 = testIframe(
+      function() {
+        document.body.appendChild(iframe1);
+      }, false,
+      function() {
+        SimpleTest.finish();
+      })
+    ;
+    var test2 = testIframe(function() {
+      document.body.removeChild(iframe1);
+    }, true, test3);
+    var test1 = testIframe(null, false, test2);
+    SimpleTest.executeSoon(test1);
+  }
+
+  iframe1.addEventListener('mozbrowserloadend', iframeLoadedHandler);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_DataURI.js b/dom/browser-element/mochitest/browserElement_DataURI.js
new file mode 100644
index 000000000..f57f4566a
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_DataURI.js
@@ -0,0 +1,68 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that data: URIs work with mozbrowserlocationchange events.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  iframe1.id = 'iframe1';
+  iframe1.addEventListener('mozbrowserloadend', function if1_loadend() {
+    iframe1.removeEventListener('mozbrowserloadend', if1_loadend);
+    ok(true, 'Got first loadend event.');
+    SimpleTest.executeSoon(runTest2);
+  });
+  iframe1.src = browserElementTestHelpers.emptyPage1;
+  document.body.appendChild(iframe1);
+
+  var iframe2 = document.createElement('iframe');
+  iframe2.id = 'iframe2';
+  document.body.appendChild(iframe2);
+}
+
+function runTest2() {
+  var iframe1 = document.getElementById('iframe1');
+  var iframe2 = document.getElementById('iframe2');
+
+  var sawLoadEnd = false;
+  var sawLocationChange = false;
+
+  iframe1.addEventListener('mozbrowserlocationchange', function(e) {
+    ok(e.isTrusted, 'Event should be trusted.');
+    ok(!sawLocationChange, 'Just one locationchange event.');
+    ok(!sawLoadEnd, 'locationchange before load.');
+    is(e.detail.url, 'data:text/html,1', "event's reported location");
+    sawLocationChange = true;
+  });
+
+  iframe1.addEventListener('mozbrowserloadend', function() {
+    ok(sawLocationChange, 'Loadend after locationchange.');
+    ok(!sawLoadEnd, 'Just one loadend event.');
+    sawLoadEnd = true;
+  });
+
+  function iframe2Load() {
+    if (!sawLoadEnd || !sawLocationChange) {
+      // Spin if iframe1 hasn't loaded yet.
+      SimpleTest.executeSoon(iframe2Load);
+      return;
+    }
+    ok(true, 'Got iframe2 load.');
+    SimpleTest.finish();
+  }
+  iframe2.addEventListener('load', iframe2Load);
+
+
+  iframe1.src = 'data:text/html,1';
+
+  // Load something into iframe2 to check that it doesn't trigger a
+  // locationchange for our iframe1 listener.
+  iframe2.src = browserElementTestHelpers.emptyPage2;
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_DocumentFirstPaint.js b/dom/browser-element/mochitest/browserElement_DocumentFirstPaint.js
new file mode 100644
index 000000000..16618829e
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_DocumentFirstPaint.js
@@ -0,0 +1,69 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 829486 - Add mozdocumentbrowserfirstpaint event.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframe;
+
+function runTestQueue(queue) {
+  if (queue.length == 0) {
+    SimpleTest.finish();
+    return;
+  }
+
+  var gotFirstPaint = false;
+  var gotFirstLocationChange = false;
+  var test = queue.shift();
+
+  function runNext() {
+    iframe.removeEventListener('mozbrowserdocumentfirstpaint', documentfirstpainthandler);
+    iframe.removeEventListener('mozbrowserloadend', loadendhandler);
+    runTestQueue(queue);
+  }
+
+  function documentfirstpainthandler(e) {
+    ok(!gotFirstPaint, "Got firstpaint only once");
+    gotFirstPaint = true;
+    if (gotFirstLocationChange) {
+      runNext();
+    }
+  }
+
+  function loadendhandler(e) {
+    gotFirstLocationChange = true;
+    if (gotFirstPaint) {
+      runNext();
+    }
+  }
+
+  iframe.addEventListener('mozbrowserdocumentfirstpaint', documentfirstpainthandler);
+  iframe.addEventListener('mozbrowserloadend', loadendhandler);
+
+  test();
+}
+
+function testChangeLocation() {
+  iframe.src = browserElementTestHelpers.emptyPage1 + "?2";
+}
+
+function testReload() {
+  iframe.reload();
+}
+
+function testFirstLoad() {
+  document.body.appendChild(iframe);
+  iframe.src = browserElementTestHelpers.emptyPage1;
+}
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  runTestQueue([testFirstLoad, testReload, testChangeLocation]);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Download.js b/dom/browser-element/mochitest/browserElement_Download.js
new file mode 100644
index 000000000..965387657
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Download.js
@@ -0,0 +1,37 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 983747 - Test 'download' method on iframe.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var iframe;
+var downloadURL = 'http://test/tests/dom/browser-element/mochitest/file_download_bin.sjs';
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowserloadend', loadend);
+  iframe.src = 'data:text/html,<html><body>hello</body></html>';
+  iframe.setAttribute('remote', 'true');
+
+  document.body.appendChild(iframe);
+}
+
+function loadend() {
+  var req = iframe.download(downloadURL, { filename: 'test.bin' });
+  req.onsuccess = function() {
+    ok(true, 'Download finished as expected.');
+    SimpleTest.finish();
+  }
+  req.onerror = function() {
+    ok(false, 'Expected no error, got ' + req.error);
+  }
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_ErrorSecurity.js b/dom/browser-element/mochitest/browserElement_ErrorSecurity.js
new file mode 100644
index 000000000..c13a37140
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ErrorSecurity.js
@@ -0,0 +1,58 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 764718 - Test that mozbrowsererror works for a security error.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var iframe = null;
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  checkForDnsError();
+}
+
+function checkForDnsError() {
+  iframe.addEventListener("mozbrowsererror", function onDnsError(e) {
+    iframe.removeEventListener(e.type, onDnsError);
+    ok(true, "Got mozbrowsererror event.");
+    ok(e.detail.type == "dnsNotFound", "Event's detail has a |type| param with the value '" + e.detail.type + "'.");
+
+    checkForExpiredCertificateError();
+  });
+
+  iframe.src = "http://this_is_not_a_domain.example.com";
+}
+
+function checkForExpiredCertificateError() {
+  iframe.addEventListener("mozbrowsererror", function onCertError(e) {
+    iframe.removeEventListener(e.type, onCertError);
+    ok(true, "Got mozbrowsererror event.");
+    ok(e.detail.type == "certerror", "Event's detail has a |type| param with the value '" + e.detail.type + "'.");
+
+    checkForNoCertificateError();
+  });
+
+  iframe.src = "https://expired.example.com";
+}
+
+
+function checkForNoCertificateError() {
+  iframe.addEventListener("mozbrowsererror", function onCertError(e) {
+    iframe.removeEventListener(e.type, onCertError);
+    ok(true, "Got mozbrowsererror event.");
+    ok(e.detail.type == "certerror", "Event's detail has a |type| param with the value '" + e.detail.type + "'.");
+
+    SimpleTest.finish();
+  });
+
+  iframe.src = "https://nocert.example.com";
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_ExecuteScript.js b/dom/browser-element/mochitest/browserElement_ExecuteScript.js
new file mode 100644
index 000000000..901964999
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ExecuteScript.js
@@ -0,0 +1,119 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 1174733 - Browser API: iframe.executeScript
+
+'use strict';
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+
+  const origin = 'http://example.org';
+  const url = 'http://example.org/tests/dom/browser-element/mochitest/file_browserElement_ExecuteScript.html';
+
+  // Test if all key=>value pairs in o1 are present in o2.
+  const c = (o1, o2) => Object.keys(o1).every(k => o1[k] == o2[k]);
+
+  let scriptId = 0;
+
+  const bail = () => {
+    ok(false, `scriptId: ${scriptId++}`);
+  }
+
+  SpecialPowers.pushPermissions([
+    {type: 'browser', allow: 1, context: document},
+    {type: 'browser:universalxss', allow: 1, context: document}
+  ], function() {
+    let iframe = document.createElement('iframe');
+    iframe.setAttribute('mozbrowser', 'true');
+    iframe.addEventListener('mozbrowserloadend', function onload() {
+      iframe.removeEventListener('mozbrowserloadend', onload);
+      onReady(iframe);
+    });
+    iframe.src = url;
+    document.body.appendChild(iframe);
+  });
+
+
+  function onReady(iframe) {
+    iframe.executeScript('4 + 4', {url}).then(rv => {
+      is(rv, 8, `scriptId: ${scriptId++}`);
+      return iframe.executeScript('(() => {return {a:42}})()', {url})
+    }, bail).then(rv => {
+      ok(c(rv, {a:42}), `scriptId: ${scriptId++}`);
+      return iframe.executeScript('(() => {return {a:42}})()', {origin})
+    }, bail).then(rv => {
+      ok(c(rv, {a:42}), `scriptId: ${scriptId++}`);
+      return iframe.executeScript('(() => {return {a:42}})()', {origin, url})
+    }, bail).then(rv => {
+      ok(c(rv, {a:42}), `scriptId: ${scriptId++}`);
+      return iframe.executeScript(`
+          new Promise((resolve, reject) => {
+            resolve(document.body.textContent.trim());
+          });
+      `, {url})
+    }, bail).then(rv => {
+      is(rv, 'foo', `scriptId: ${scriptId++}`);
+      return iframe.executeScript(`
+          new Promise((resolve, reject) => {
+            resolve({a:43,b:34});
+          });
+      `, {url})
+    }, bail).then(rv => {
+      ok(c(rv, {a:43,b:34}), `scriptId: ${scriptId++}`);
+      return iframe.executeScript(`
+        … syntax error
+      `, {url});
+    }, bail).then(bail, (error) => {
+      is(error.name, 'SyntaxError: illegal character', `scriptId: ${scriptId++}`);
+      return iframe.executeScript(`
+        window
+      `, {url});
+    }).then(bail, (error) => {
+      is(error.name, 'Script last expression must be a promise or a JSON object', `scriptId: ${scriptId++}`);
+      return iframe.executeScript(`
+          new Promise((resolve, reject) => {
+            reject('BOOM');
+          });
+      `, {url});
+    }).then(bail, (error) => {
+      is(error.name, 'BOOM', `scriptId: ${scriptId++}`);
+      return iframe.executeScript(`
+          new Promise((resolve, reject) => {
+            resolve(window);
+          });
+      `, {url});
+    }).then(bail, (error) => {
+      is(error.name, 'Value returned (resolve) by promise is not a valid JSON object', `scriptId: ${scriptId++}`);
+      return iframe.executeScript('window.btoa("a")', {url})
+    }, bail).then(rv => {
+      ok(c(rv, 'YQ=='), `scriptId: ${scriptId++}`);
+      return iframe.executeScript('window.wrappedJSObject.btoa("a")', {url})
+    }, bail).then(bail, (error) => {
+      is(error.name, 'TypeError: window.wrappedJSObject is undefined', `scriptId: ${scriptId++}`);
+      return iframe.executeScript('42', {})
+    }).then(bail, error => {
+      is(error.name, 'InvalidAccessError', `scriptId: ${scriptId++}`);
+      return iframe.executeScript('42');
+    }).then(bail, error => {
+      is(error.name, 'InvalidAccessError', `scriptId: ${scriptId++}`);
+      return iframe.executeScript('43', { url: 'http://foo.com' });
+    }).then(bail, (error) => {
+      is(error.name, 'URL mismatches', `scriptId: ${scriptId++}`);
+      return iframe.executeScript('43', { url: '_' });
+    }, bail).then(bail, (error) => {
+      is(error.name, 'Malformed URL', `scriptId: ${scriptId++}`);
+      return iframe.executeScript('43', { origin: 'http://foo.com' });
+    }, bail).then(bail, (error) => {
+      is(error.name, 'Origin mismatches', `scriptId: ${scriptId++}`);
+      return iframe.executeScript('43', { origin: 'https://example.org' });
+    }, bail).then(bail, (error) => {
+      is(error.name, 'Origin mismatches', `scriptId: ${scriptId++}`);
+      SimpleTest.finish();
+    });
+  }
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_ExposableURI.js b/dom/browser-element/mochitest/browserElement_ExposableURI.js
new file mode 100644
index 000000000..435e11a80
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ExposableURI.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 795317: Test that the browser element sanitizes its URIs by removing the
+// "unexposable" parts before sending them in the locationchange event.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var iframe;
+
+function testPassword() {
+  function locationchange(e) {
+    var uri = e.detail.url;
+    is(uri, 'http://mochi.test:8888/tests/dom/browser-element/mochitest/file_empty.html',
+       "Username and password shouldn't be exposed in uri.");
+    SimpleTest.finish();
+  }
+
+  iframe.addEventListener('mozbrowserlocationchange', locationchange);
+  iframe.src = "http://iamuser:iampassword@mochi.test:8888/tests/dom/browser-element/mochitest/file_empty.html";
+}
+
+function testWyciwyg() {
+  var locationChangeCount = 0;
+
+  function locationchange(e) {
+    // locationChangeCount:
+    //  0 - the first load.
+    //  1 - after document.write().
+    if (locationChangeCount == 0) {
+      locationChangeCount ++;
+    } else if (locationChangeCount == 1) {
+      var uri = e.detail.url;
+      is(uri, 'http://mochi.test:8888/tests/dom/browser-element/mochitest/file_wyciwyg.html', "Scheme in string shouldn't be wyciwyg");
+      iframe.removeEventListener('mozbrowserlocationchange', locationchange);
+      SimpleTest.executeSoon(testPassword);
+    }
+  }
+
+  // file_wyciwyg.html calls document.write() to create a wyciwyg channel.
+  iframe.src = 'file_wyciwyg.html';
+  iframe.addEventListener('mozbrowserlocationchange', locationchange);
+}
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+  testWyciwyg();
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Find.js b/dom/browser-element/mochitest/browserElement_Find.js
new file mode 100644
index 000000000..3a4968119
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Find.js
@@ -0,0 +1,145 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 1163961 - Test search API
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+
+  let iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.src = 'data:text/html,foo bar foo XXX Foo BAR foobar foobar';
+
+  const once = (eventName) => {
+    return new Promise((resolve) => {
+      iframe.addEventListener(eventName, function onEvent(...args) {
+        iframe.removeEventListener(eventName, onEvent);
+        resolve(...args);
+      });
+    });
+  }
+
+  // Test if all key=>value pairs in o1 are present in o2.
+  const c = (o1, o2) => Object.keys(o1).every(k => o1[k] == o2[k]);
+
+  let testCount = 0;
+
+  once('mozbrowserloadend').then(() => {
+    iframe.findAll('foo', 'case-insensitive');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'foo',
+      searchLimit: 1000,
+      activeMatchOrdinal: 1,
+      numberOfMatches: 5,
+    }), `test ${testCount++}`);
+    iframe.findNext('forward');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'foo',
+      searchLimit: 1000,
+      activeMatchOrdinal: 2,
+      numberOfMatches: 5,
+    }), `test ${testCount++}`);
+    iframe.findNext('backward');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'foo',
+      searchLimit: 1000,
+      activeMatchOrdinal: 1,
+      numberOfMatches: 5,
+    }), `test ${testCount++}`);
+    iframe.findAll('xxx', 'case-sensitive');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'xxx',
+      searchLimit: 1000,
+      activeMatchOrdinal: 0,
+      numberOfMatches: 0,
+    }), `test ${testCount++}`);
+    iframe.findAll('bar', 'case-insensitive');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'bar',
+      searchLimit: 1000,
+      activeMatchOrdinal: 1,
+      numberOfMatches: 4,
+    }), `test ${testCount++}`);
+    iframe.findNext('forward');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'bar',
+      searchLimit: 1000,
+      activeMatchOrdinal: 2,
+      numberOfMatches: 4,
+    }), `test ${testCount++}`);
+    iframe.findNext('forward');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'bar',
+      searchLimit: 1000,
+      activeMatchOrdinal: 3,
+      numberOfMatches: 4,
+    }), `test ${testCount++}`);
+    iframe.findNext('forward');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'bar',
+      searchLimit: 1000,
+      activeMatchOrdinal: 4,
+      numberOfMatches: 4,
+    }), `test ${testCount++}`);
+    iframe.findNext('forward');
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: true,
+      searchString: 'bar',
+      searchLimit: 1000,
+      activeMatchOrdinal: 1,
+      numberOfMatches: 4,
+    }), `test ${testCount++}`);
+    iframe.clearMatch();
+    return once('mozbrowserfindchange');
+  }).then(({detail}) => {
+    ok(c(detail, {
+      msg_name: "findchange",
+      active: false
+    }), `test ${testCount++}`);
+    SimpleTest.finish();
+  });
+
+  document.body.appendChild(iframe);
+
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_FirstPaint.js b/dom/browser-element/mochitest/browserElement_FirstPaint.js
new file mode 100644
index 000000000..ad67abc3a
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_FirstPaint.js
@@ -0,0 +1,43 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 787378 - Add mozbrowserfirstpaint event.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  var gotFirstPaint = false;
+  var gotFirstLocationChange = false;
+  iframe.addEventListener('mozbrowserfirstpaint', function(e) {
+    ok(!gotFirstPaint, "Got only one first paint.");
+    gotFirstPaint = true;
+
+    if (gotFirstLocationChange) {
+      iframe.src = browserElementTestHelpers.emptyPage1 + '?2';
+    }
+  });
+
+  iframe.addEventListener('mozbrowserlocationchange', function(e) {
+    if (e.detail.url == browserElementTestHelpers.emptyPage1) {
+      gotFirstLocationChange = true;
+      if (gotFirstPaint) {
+        iframe.src = browserElementTestHelpers.emptyPage1 + '?2';
+      }
+    }
+    else if (e.detail.url.endsWith('?2')) {
+      SimpleTest.finish();
+    }
+  });
+
+  document.body.appendChild(iframe);
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_ForwardName.js b/dom/browser-element/mochitest/browserElement_ForwardName.js
new file mode 100644
index 000000000..326c1ef24
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ForwardName.js
@@ -0,0 +1,43 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 781320 - Test that the name in <iframe mozbrowser name="foo"> is
+// forwarded down to remote mozbrowsers.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.setAttribute('name', 'foo');
+
+  iframe.addEventListener("mozbrowseropenwindow", function(e) {
+    ok(false, 'Got mozbrowseropenwindow, but should not have.');
+  });
+
+  iframe.addEventListener('mozbrowserlocationchange', function(e) {
+    ok(true, "Got locationchange to " + e.detail.url);
+    if (e.detail.url.endsWith("ForwardName.html#finish")) {
+      SimpleTest.finish();
+    }
+  });
+
+  // The file sends us messages via alert() that start with "success:" or
+  // "failure:".
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    ok(e.detail.message.startsWith('success:'), e.detail.message);
+  });
+
+  document.body.appendChild(iframe);
+
+  // This file does window.open('file_browserElement_ForwardName.html#finish',
+  // 'foo');  That should open in the curent window, because the window should
+  // be named foo.
+  iframe.src = 'file_browserElement_ForwardName.html';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_FrameWrongURI.js b/dom/browser-element/mochitest/browserElement_FrameWrongURI.js
new file mode 100644
index 000000000..c3f37b4c8
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_FrameWrongURI.js
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 804446 - Test that window.open(javascript:..) works with <iframe mozbrowser>.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframeJS = document.createElement('iframe');
+  iframeJS.setAttribute('mozbrowser', 'true');
+
+  iframeJS.addEventListener('mozbrowserloadstart', function(e) {
+    ok(false, "This should not happen!");
+  });
+
+  iframeJS.addEventListener('mozbrowserloadend', function(e) {
+    ok(false, "This should not happen!");
+  });
+
+  iframeJS.src = 'javascript:alert("Foo");';
+  document.body.appendChild(iframeJS);
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  var gotPopup = false;
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    is(gotPopup, false, 'Should get just one popup.');
+    gotPopup = true;
+
+    document.body.appendChild(e.detail.frameElement);
+  });
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    ok(gotPopup, 'Got mozbrowseropenwindow event before showmodalprompt event.');
+    if (e.detail.message.indexOf("success") == 0) {
+      ok(true, e.detail.message);
+      SimpleTest.finish();
+    }
+    else {
+      ok(false, "Got invalid message: " + e.detail.message);
+    }
+  });
+
+  iframe.src = 'file_browserElement_FrameWrongURI.html';
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_GetContentDimensions.js b/dom/browser-element/mochitest/browserElement_GetContentDimensions.js
new file mode 100644
index 000000000..722c42b77
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_GetContentDimensions.js
@@ -0,0 +1,66 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 757859 - Test the getContentDimensions functionality of mozbrowser
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var resizeContent = function() {
+  var innerBox = content.document.getElementById('abox');
+  innerBox.style.width = '800px';
+  innerBox.style.height = '800px';
+}
+
+function runTest() {
+
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+
+  var iframeWidth = 400;
+  var iframeHeight = 400;
+  var numIframeLoaded = 0;
+  var numResizeEvents = 0;
+  var mm;
+
+  iframe1.src = 'data:text/html,<html><body><div id=\'abox\' ' +
+    'style=\'background:blue;width:200px;height:200px\'>test</div></body></html>';
+  iframe1.style.width = iframeWidth + 'px';
+  iframe1.style.height = iframeHeight + 'px';
+  document.body.appendChild(iframe1);
+
+  function iframeScrollAreaChanged(e) {
+    numResizeEvents++;
+    if (numResizeEvents === 1) {
+      ok(true, 'Resize event when changing content size');
+      ok(e.detail.width > iframeWidth, 'Iframes content is larger than iframe');
+      ok(e.detail.height > iframeHeight, 'Iframes content is larger than iframe');
+      iframe1.src = 'data:text/html,<html><body><div id=\'abox\' ' +
+        'style=\'background:blue;width:200px;height:200px\'>test</div></body></html>';
+    } else if (numResizeEvents === 2) {
+      ok(true, 'Resize event when changing src');
+      iframe1.removeEventListener('mozbrowserresize', iframeScrollAreaChanged);
+      SimpleTest.finish();
+    }
+  }
+
+  function iframeLoadedHandler() {
+    iframe1.removeEventListener('mozbrowserloadend', iframeLoadedHandler);
+    mm = SpecialPowers.getBrowserFrameMessageManager(iframe1);
+    iframe1.getContentDimensions().onsuccess = function(e) {
+      ok(typeof e.target.result.width === 'number', 'Received width');
+      ok(typeof e.target.result.height === 'number', 'Received height');
+      ok(e.target.result.height <= iframeHeight, 'Iframes content is smaller than iframe');
+      ok(e.target.result.width <= iframeWidth, 'Iframes content is smaller than iframe');
+      iframe1.addEventListener('mozbrowserscrollareachanged', iframeScrollAreaChanged);
+      mm.loadFrameScript('data:,(' + resizeContent.toString() + ')();', false);
+    }
+  }
+
+  iframe1.addEventListener('mozbrowserloadend', iframeLoadedHandler);
+}
+
+addEventListener('load', function() {
+  SimpleTest.executeSoon(runTest);
+});
diff --git a/dom/browser-element/mochitest/browserElement_GetScreenshot.js b/dom/browser-element/mochitest/browserElement_GetScreenshot.js
new file mode 100644
index 000000000..75d70f04c
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_GetScreenshot.js
@@ -0,0 +1,117 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test the getScreenshot property for mozbrowser
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+
+  iframe1.src = 'data:text/html,<html>' +
+    '<body style="background:green">hello</body></html>';
+  document.body.appendChild(iframe1);
+
+  var screenshotImageDatas = [];
+
+  function screenshotTaken(aScreenshotImageData) {
+    screenshotImageDatas.push(aScreenshotImageData);
+
+    if (screenshotImageDatas.length === 1) {
+      ok(true, 'Got initial non blank screenshot');
+
+      var view = aScreenshotImageData.data;
+      if (view[3] !== 255) {
+        ok(false, 'The first pixel of initial screenshot is not opaque');
+        SimpleTest.finish();
+        return;
+      }
+      ok(true, 'Verified the first pixel of initial screenshot is opaque');
+
+      iframe1.src = 'data:text/html,<html>' +
+        '<body style="background:transparent">hello</body></html>';
+
+      iframe1.addEventListener('mozbrowserloadend', ()=>takeScreenshot('image/png'));
+
+    }
+    else if (screenshotImageDatas.length === 2) {
+      ok(true, 'Got updated screenshot after source page changed');
+
+      var view = aScreenshotImageData.data;
+      if (view[3] !== 0) {
+        // The case here will always fail when oop'd on Firefox Desktop,
+        // but not on B2G Emulator
+        // See https://bugzil.la/878003#c20
+
+        var isB2G = (navigator.platform === '');
+        info('navigator.platform: ' + navigator.platform);
+        if (!isB2G && browserElementTestHelpers.getOOPByDefaultPref()) {
+          todo(false, 'The first pixel of updated screenshot is not transparent');
+        } else {
+          ok(false, 'The first pixel of updated screenshot is not transparent');
+        }
+        SimpleTest.finish();
+        return;
+      }
+
+      ok(true, 'Verified the first pixel of updated screenshot is transparent');
+      SimpleTest.finish();
+    }
+  }
+
+  // We continually take screenshots until we get one that we are
+  // happy with.
+  function takeScreenshot(mimeType) {
+    function gotImage(e) {
+      // |this| is the Image.
+
+      URL.revokeObjectURL(this.src);
+
+      if (e.type === 'error' || !this.width || !this.height) {
+        ok(false, "load image error");
+        SimpleTest.finish();
+        return;
+      }
+
+      var canvas = document.createElement('canvas');
+      canvas.width = canvas.height = 1000;
+      var ctx = canvas.getContext('2d');
+      ctx.drawImage(this, 0, 0);
+      var imageData = ctx.getImageData(0, 0, 1000, 1000);
+
+      screenshotTaken(imageData);
+    }
+
+    function getScreenshotImageData(e) {
+      var blob = e.target.result;
+      if (blob.type !== mimeType) {
+        ok(false, 'MIME type of screenshot taken incorrect');
+        SimpleTest.finish();
+      }
+
+      if (blob.size === 0) {
+        ok(false, "get screenshot image error");
+        SimpleTest.finish();
+      }
+
+      var img = new Image();
+      img.src = URL.createObjectURL(blob);
+      img.onload = img.onerror = gotImage;
+    }
+
+    iframe1.getScreenshot(1000, 1000, mimeType).onsuccess =
+      getScreenshotImageData;
+  }
+
+  function iframeLoadedHandler(e) {
+    iframe1.removeEventListener('mozbrowserloadend', iframeLoadedHandler);
+    takeScreenshot('image/jpeg');
+  }
+
+  iframe1.addEventListener('mozbrowserloadend', iframeLoadedHandler);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_GetScreenshotDppx.js b/dom/browser-element/mochitest/browserElement_GetScreenshotDppx.js
new file mode 100644
index 000000000..1d61f6afc
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_GetScreenshotDppx.js
@@ -0,0 +1,107 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test the getScreenshot property for mozbrowser
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+  var dppxPref = 'layout.css.devPixelsPerPx';
+  var cssPixelWidth = 600;
+  var cssPixelHeight = 400;
+
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('width', cssPixelWidth);
+  iframe1.setAttribute('height', cssPixelHeight);
+  iframe1.setAttribute('mozbrowser', 'true');
+
+  iframe1.src = 'data:text/html,<html><body>hello</body></html>';
+  document.body.appendChild(iframe1);
+
+  var images = [];
+
+  function screenshotTaken(image) {
+    images.push(image);
+    if (images.length === 1) {
+      ok(true, 'Got initial non blank screenshot');
+
+      if (image.width !== cssPixelWidth || image.height !== cssPixelHeight) {
+        ok(false, 'The pixel width of the image received is not correct');
+        SimpleTest.finish();
+        return;
+      }
+      ok(true, 'The pixel width of the image received is correct');
+
+      SpecialPowers.pushPrefEnv(
+        {'set': [['layout.css.devPixelsPerPx', 2]]}, takeScreenshot);
+    }
+    else if (images.length === 2) {
+      ok(true, 'Got updated screenshot after source page changed');
+
+      if (image.width !== cssPixelWidth * 2 ||
+          image.height !== cssPixelHeight * 2) {
+        ok(false, 'The pixel width of the 2dppx image received is not correct');
+        SimpleTest.finish();
+        return;
+      }
+      ok(true, 'The pixel width of the 2dppx image received is correct');
+      SimpleTest.finish();
+    }
+  }
+
+  function takeScreenshot() {
+    function gotImage(e) {
+      // |this| is the Image.
+
+      URL.revokeObjectURL(this.src);
+
+      if (e.type === 'error' || !this.width || !this.height) {
+        tryAgain();
+
+        return;
+      }
+
+      screenshotTaken(this);
+    }
+
+    function tryAgain() {
+      if (--attempts === 0) {
+        ok(false, 'Timed out waiting for correct screenshot');
+        SimpleTest.finish();
+      } else {
+        setTimeout(function() {
+          iframe1.getScreenshot(cssPixelWidth, cssPixelHeight).onsuccess =
+            getScreenshotImageData;
+        }, 200);
+      }
+    }
+
+    function getScreenshotImageData(e) {
+      var blob = e.target.result;
+      if (blob.size === 0) {
+        tryAgain();
+
+        return;
+      }
+
+      var img = new Image();
+      img.src = URL.createObjectURL(blob);
+      img.onload = img.onerror = gotImage;
+    }
+
+    var attempts = 10;
+    iframe1.getScreenshot(cssPixelWidth, cssPixelHeight).onsuccess =
+      getScreenshotImageData;
+  }
+
+  function iframeLoadedHandler() {
+    SpecialPowers.pushPrefEnv(
+      {'set': [['layout.css.devPixelsPerPx', 1]]}, takeScreenshot);
+  }
+
+  iframe1.addEventListener('mozbrowserloadend', iframeLoadedHandler);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Iconchange.js b/dom/browser-element/mochitest/browserElement_Iconchange.js
new file mode 100644
index 000000000..367a2de15
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Iconchange.js
@@ -0,0 +1,129 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the onmozbrowsericonchange event works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function createHtml(link) {
+  return 'data:text/html,<html><head>' + link + '<body></body></html>';
+}
+
+function createLink(name, sizes, rel) {
+  var s = sizes ? 'sizes="' + sizes + '"' : '';
+  if (!rel) {
+    rel = 'icon';
+  }
+  return '<link rel="' + rel + '" type="image/png" ' + s +
+    ' href="http://example.com/' + name + '.png">';
+}
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe1);
+
+  // iframe2 is a red herring; we modify its favicon but don't listen for
+  // iconchanges; we want to make sure that its iconchange events aren't
+  // picked up by the listener on iframe1.
+  var iframe2 = document.createElement('iframe');
+  iframe2.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe2);
+
+  // iframe3 is another red herring.  It's not a mozbrowser, so we shouldn't
+  // get any iconchange events on it.
+  var iframe3 = document.createElement('iframe');
+  document.body.appendChild(iframe3);
+
+  var numIconChanges = 0;
+
+  iframe1.addEventListener('mozbrowsericonchange', function(e) {
+
+    numIconChanges++;
+
+    if (numIconChanges == 1) {
+      is(e.detail.href, 'http://example.com/myicon.png');
+
+      // We should recieve iconchange events when the user creates new links
+      // to a favicon, but only when we listen for them
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.title='New title';",
+                                    /* allowDelayedLoad = */ false);
+
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=ICON href=http://example.com/newicon.png>')",
+                                    /* allowDelayedLoad = */ false);
+
+      SpecialPowers.getBrowserFrameMessageManager(iframe2)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=ICON href=http://example.com/newicon.png>')",
+                                    /* allowDelayedLoad = */ false);
+    }
+    else if (numIconChanges == 2) {
+      is(e.detail.href, 'http://example.com/newicon.png');
+
+      // Full new pages should trigger iconchange events
+      iframe1.src = createHtml(createLink('3rdicon'));
+    }
+    else if (numIconChanges == 3) {
+      is(e.detail.href, 'http://example.com/3rdicon.png');
+
+      // the rel attribute can have various space seperated values, make
+      // sure we only pick up correct values for 'icon'
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=shortcuticon href=http://example.com/newicon.png>')",
+                                    /* allowDelayedLoad = */ false);
+      // Test setting a page with multiple links elements
+      iframe1.src = createHtml(createLink('another') + createLink('icon'));
+    }
+    else if (numIconChanges == 4) {
+      is(e.detail.href, 'http://example.com/another.png');
+      // 2 events will be triggered by previous test, wait for next
+    }
+    else if (numIconChanges == 5) {
+      is(e.detail.href, 'http://example.com/icon.png');
+
+      // Make sure icon check is case insensitive
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=ICON href=http://example.com/ucaseicon.png>')",
+                                    /* allowDelayedLoad = */ false);
+    }
+    else if (numIconChanges == 6) {
+      is(e.detail.href, 'http://example.com/ucaseicon.png');
+      iframe1.src = createHtml(createLink('testsize', '50x50', 'icon'));
+    }
+    else if (numIconChanges == 7) {
+      is(e.detail.href, 'http://example.com/testsize.png');
+      is(e.detail.sizes, '50x50');
+      iframe1.src = createHtml(createLink('testapple1', '100x100', 'apple-touch-icon'));
+    } else if (numIconChanges == 8) {
+      is(e.detail.href, 'http://example.com/testapple1.png');
+      is(e.detail.rel, 'apple-touch-icon');
+      is(e.detail.sizes, '100x100');
+
+      iframe1.src = createHtml(createLink('testapple2', '100x100', 'apple-touch-icon-precomposed'));
+    } else if (numIconChanges == 9) {
+      is(e.detail.href, 'http://example.com/testapple2.png');
+      is(e.detail.rel, 'apple-touch-icon-precomposed');
+      is(e.detail.sizes, '100x100');
+      SimpleTest.finish();
+    } else {
+      ok(false, 'Too many iconchange events.');
+    }
+  });
+
+  iframe3.addEventListener('mozbrowsericonchange', function(e) {
+    ok(false, 'Should not get a iconchange event for iframe3.');
+  });
+
+
+  iframe1.src = createHtml(createLink('myicon'));
+  // We should not recieve icon change events for either of the below iframes
+  iframe2.src = createHtml(createLink('myicon'));
+  iframe3.src = createHtml(createLink('myicon'));
+
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_LoadEvents.js b/dom/browser-element/mochitest/browserElement_LoadEvents.js
new file mode 100644
index 000000000..8b43d8e75
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_LoadEvents.js
@@ -0,0 +1,120 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that an iframe with the |mozbrowser| attribute emits mozbrowserloadX
+// events when this page is in the whitelist.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  // Load emptypage1 into the iframe, wait for that to finish loading, then
+  // call runTest2.
+  //
+  // This should trigger loadstart, locationchange, and loadend events.
+
+  var seenLoadEnd = false;
+  var seenLoadStart = false;
+  var seenLocationChange = false;
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.id = 'iframe';
+  iframe.src = 'http://example.com/tests/dom/browser-element/mochitest/file_browserElement_LoadEvents.html';
+
+  function loadstart(e) {
+    ok(e.isTrusted, 'Event should be trusted.');
+    ok(!seenLoadEnd, 'loadstart before loadend.');
+    ok(!seenLoadStart, 'Just one loadstart event.');
+    ok(!seenLocationChange, 'loadstart before locationchange.');
+    seenLoadStart = true;
+  }
+
+  function locationchange(e) {
+    ok(e.isTrusted, 'Event should be trusted.');
+    ok(!seenLocationChange, 'Just one locationchange event.');
+    seenLocationChange = true;
+    ok(seenLoadStart, 'Location change after load start.');
+    ok(!seenLoadEnd, 'Location change before load end.');
+    ok(e.detail.url, browserElementTestHelpers.emptyPage1, "event's reported location");
+  }
+
+  function loadend(e) {
+    ok(e.isTrusted, 'Event should be trusted.');
+    ok(seenLoadStart, 'loadend after loadstart.');
+    ok(!seenLoadEnd, 'Just one loadend event.');
+    ok(seenLocationChange, 'loadend after locationchange.');
+    is(e.detail.backgroundColor, 'rgb(0, 128, 0)', 'Expected background color reported')
+    seenLoadEnd = true;
+  }
+
+  iframe.addEventListener('mozbrowserloadstart', loadstart);
+  iframe.addEventListener('mozbrowserlocationchange', locationchange);
+  iframe.addEventListener('mozbrowserloadend', loadend);
+
+  function waitForAllCallbacks() {
+    if (!seenLoadStart || !seenLoadEnd) {
+      SimpleTest.executeSoon(waitForAllCallbacks);
+      return;
+    }
+
+    iframe.removeEventListener('mozbrowserloadstart', loadstart);
+    iframe.removeEventListener('mozbrowserlocationchange', locationchange);
+    iframe.removeEventListener('mozbrowserloadend', loadend);
+    runTest2();
+  }
+
+  document.body.appendChild(iframe);
+  waitForAllCallbacks();
+}
+
+function runTest2() {
+  var seenLoadStart = false;
+  var seenLoadEnd = false;
+  var seenLocationChange = false;
+
+  // Add this event listener to the document; the events should bubble.
+  document.addEventListener('mozbrowserloadstart', function(e) {
+    ok(e.isTrusted, 'Event should be trusted.');
+    ok(!seenLoadStart, 'Just one loadstart event.');
+    seenLoadStart = true;
+    ok(!seenLoadEnd, 'Got mozbrowserloadstart before loadend.');
+    ok(!seenLocationChange, 'Got mozbrowserloadstart before locationchange.');
+  });
+
+  var iframe = document.getElementById('iframe');
+  iframe.addEventListener('mozbrowserlocationchange', function(e) {
+    ok(e.isTrusted, 'Event should be trusted.');
+    ok(!seenLocationChange, 'Just one locationchange event.');
+    seenLocationChange = true;
+    ok(seenLoadStart, 'Location change after load start.');
+    ok(!seenLoadEnd, 'Location change before load end.');
+    ok(e.detail.url, browserElementTestHelpers.emptyPage2, "event's reported location");
+  });
+
+  iframe.addEventListener('mozbrowserloadend', function(e) {
+    ok(e.isTrusted, 'Event should be trusted.');
+    ok(!seenLoadEnd, 'Just one load end event.');
+    seenLoadEnd = true;
+    ok(seenLoadStart, 'Load end after load start.');
+    ok(seenLocationChange, 'Load end after location change.');
+    is(e.detail.backgroundColor, 'transparent', 'Expected background color reported')
+  });
+
+  iframe.src = browserElementTestHelpers.emptyPage2;
+
+  function waitForAllCallbacks() {
+    if (!seenLoadStart || !seenLoadEnd || !seenLocationChange) {
+      SimpleTest.executeSoon(waitForAllCallbacks);
+      return;
+    }
+
+    SimpleTest.finish();
+  }
+
+  waitForAllCallbacks();
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Manifestchange.js b/dom/browser-element/mochitest/browserElement_Manifestchange.js
new file mode 100644
index 000000000..22cf8fe7c
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Manifestchange.js
@@ -0,0 +1,96 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the onmozbrowsermanifestchange event works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function createHtml(manifest) {
+  return 'data:text/html,<html xmlns:xml="http://www.w3.org/XML/1998/namespace"><head>' + manifest + '<body></body></html>';
+}
+
+function createManifest(href) {
+  return '<link rel="manifest" href="' + href + '">';
+}
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe1);
+
+  // iframe2 is a red herring; we modify its manifest link elements but don't
+  // listen for manifestchanges; we want to make sure that its manifestchange
+  // events aren't picked up by the listener on iframe1.
+  var iframe2 = document.createElement('iframe');
+  iframe2.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe2);
+
+  // iframe3 is another red herring.  It's not a mozbrowser, so we shouldn't
+  // get any manifestchange events on it.
+  var iframe3 = document.createElement('iframe');
+  document.body.appendChild(iframe3);
+
+  var numManifestChanges = 0;
+
+  iframe1.addEventListener('mozbrowsermanifestchange', function(e) {
+
+    numManifestChanges++;
+
+    if (numManifestChanges == 1) {
+      is(e.detail.href, 'manifest.1', 'manifest.1 matches');
+
+      // We should receive manifestchange events when the user creates new
+      // manifests
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.title='New title';",
+                                    /* allowDelayedLoad = */ false);
+
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=manifest href=manifest.2>')",
+                                    /* allowDelayedLoad = */ false);
+
+      SpecialPowers.getBrowserFrameMessageManager(iframe2)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=manifest href=manifest.2>')",
+                                    /* allowDelayedLoad = */ false);
+    }
+    else if (numManifestChanges == 2) {
+      is(e.detail.href, 'manifest.2', 'manifest.2 matches');
+
+      // Full new pages should trigger manifestchange events
+      iframe1.src = createHtml(createManifest('manifest.3'));
+    }
+    else if (numManifestChanges == 3) {
+      is(e.detail.href, 'manifest.3', 'manifest.3 matches');
+
+      // Test setting a page with multiple manifest link elements
+      iframe1.src = createHtml(createManifest('manifest.4a') + createManifest('manifest.4b'));
+    }
+    else if (numManifestChanges == 4) {
+      is(e.detail.href, 'manifest.4a', 'manifest.4a matches');
+      // 2 events will be triggered by previous test, wait for next
+    }
+    else if (numManifestChanges == 5) {
+      is(e.detail.href, 'manifest.4b', 'manifest.4b matches');
+      SimpleTest.finish();
+    } else {
+      ok(false, 'Too many manifestchange events.');
+    }
+  });
+
+  iframe3.addEventListener('mozbrowsermanifestchange', function(e) {
+    ok(false, 'Should not get a manifestchange event for iframe3.');
+  });
+
+
+  iframe1.src = createHtml(createManifest('manifest.1'));
+  // We should not receive manifest change events for either of the below iframes
+  iframe2.src = createHtml(createManifest('manifest.1'));
+  iframe3.src = createHtml(createManifest('manifest.1'));
+
+}
+
+addEventListener('testready', runTest);
+
diff --git a/dom/browser-element/mochitest/browserElement_Metachange.js b/dom/browser-element/mochitest/browserElement_Metachange.js
new file mode 100644
index 000000000..7789a3e18
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Metachange.js
@@ -0,0 +1,177 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the onmozbrowsermetachange event works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function createHtml(meta) {
+  return 'data:text/html,<html xmlns:xml="http://www.w3.org/XML/1998/namespace"><head>' + meta + '<body></body></html>';
+}
+
+function createHtmlWithLang(meta, lang) {
+  return 'data:text/html,<html xmlns:xml="http://www.w3.org/XML/1998/namespace" lang="' + lang + '"><head>' + meta + '<body></body></html>';
+}
+
+function createMeta(name, content) {
+  return '<meta name="' + name + '" content="' + content + '">';
+}
+
+function createMetaWithLang(name, content, lang) {
+  return '<meta name="' + name + '" content="' + content + '" lang="' + lang + '">';
+}
+
+function createMetaWithProperty(property, content) {
+  return '<meta property="' + property + '" content="' + content + '">';
+}
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe1);
+
+  // iframe2 is a red herring; we modify its meta elements but don't listen for
+  // metachanges; we want to make sure that its metachange events aren't
+  // picked up by the listener on iframe1.
+  var iframe2 = document.createElement('iframe');
+  iframe2.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe2);
+
+  // iframe3 is another red herring.  It's not a mozbrowser, so we shouldn't
+  // get any metachange events on it.
+  var iframe3 = document.createElement('iframe');
+  document.body.appendChild(iframe3);
+
+  var numMetaChanges = 0;
+
+  iframe1.addEventListener('mozbrowsermetachange', function(e) {
+
+    numMetaChanges++;
+
+    if (numMetaChanges == 1) {
+      is(e.detail.name, 'application-name');
+      is(e.detail.content, 'foobar');
+
+      // We should recieve metachange events when the user creates new metas
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.title='New title';",
+                                    /* allowDelayedLoad = */ false);
+
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<meta name=application-name content=new_foobar>')",
+                                    /* allowDelayedLoad = */ false);
+
+      SpecialPowers.getBrowserFrameMessageManager(iframe2)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<meta name=application-name content=new_foobar>')",
+                                    /* allowDelayedLoad = */ false);
+    }
+    else if (numMetaChanges == 2) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, 'new_foobar', 'content matches');
+      ok(!("lang" in e.detail), 'lang not present');
+
+      // Full new pages should trigger metachange events
+      iframe1.src = createHtml(createMeta('application-name', '3rd_foobar'));
+    }
+    else if (numMetaChanges == 3) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, '3rd_foobar', 'content matches');
+      ok(!("lang" in e.detail), 'lang not present');
+
+      // Test setting a page with multiple meta elements
+      iframe1.src = createHtml(createMeta('application-name', 'foobar_1') + createMeta('application-name', 'foobar_2'));
+    }
+    else if (numMetaChanges == 4) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, 'foobar_1', 'content matches');
+      ok(!("lang" in e.detail), 'lang not present');
+      // 2 events will be triggered by previous test, wait for next
+    }
+    else if (numMetaChanges == 5) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, 'foobar_2', 'content matches');
+      ok(!("lang" in e.detail), 'lang not present');
+
+      // Test the language
+      iframe1.src = createHtml(createMetaWithLang('application-name', 'foobar_lang_1', 'en'));
+    }
+    else if (numMetaChanges == 6) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, 'foobar_lang_1', 'content matches');
+      is(e.detail.lang, 'en', 'language matches');
+
+      // Test the language in the ancestor element
+      iframe1.src = createHtmlWithLang(createMeta('application-name', 'foobar_lang_2'), 'es');
+    }
+    else if (numMetaChanges == 7) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, 'foobar_lang_2', 'content matches');
+      is(e.detail.lang, 'es', 'language matches');
+
+      // Test the language in the ancestor element
+      iframe1.src = createHtmlWithLang(createMetaWithLang('application-name', 'foobar_lang_3', 'it'), 'fi');
+    }
+    else if (numMetaChanges == 8) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, 'foobar_lang_3', 'content matches');
+      is(e.detail.lang, 'it', 'language matches');
+
+      // Test the content-language
+      iframe1.src = "http://test/tests/dom/browser-element/mochitest/file_browserElement_Metachange.sjs?ru";
+    }
+    else if (numMetaChanges == 9) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, 'sjs', 'content matches');
+      is(e.detail.lang, 'ru', 'language matches');
+
+      // Test the content-language
+      iframe1.src = "http://test/tests/dom/browser-element/mochitest/file_browserElement_Metachange.sjs?ru|dk";
+    }
+    else if (numMetaChanges == 10) {
+      is(e.detail.name, 'application-name', 'name matches');
+      is(e.detail.content, 'sjs', 'content matches');
+      is(e.detail.lang, 'dk', 'language matches');
+
+      // Test Open Graph property
+      iframe1.src = createHtml(createMetaWithProperty('og:description', 'Fascinating article'));
+
+      // We should not get event if property doesn't start with 'og:'
+      iframe3.src = createHtml(createMetaWithProperty('go:description', 'Fascinating article'));
+    }
+    else if (numMetaChanges == 11) {
+      is(e.detail.name, 'og:description', 'property name matches');
+      is(e.detail.content, 'Fascinating article', 'content matches');
+
+      // Sometimes 'name' is used instead of 'property'. Verify that works.
+      iframe1.src = createHtml(createMeta('og:title', 'One weird trick!'));
+
+      // We should not get event if property doesn't start with 'og:'
+      iframe3.src = createHtml(createMeta('go:title', 'One weird trick!'));
+    }
+    else if (numMetaChanges == 12) {
+      is(e.detail.name, 'og:title', 'property name matches');
+      is(e.detail.content, 'One weird trick!', 'content matches');
+
+      // Test the language
+      SimpleTest.finish();
+    } else {
+      ok(false, 'Too many metachange events.');
+    }
+  });
+
+  iframe3.addEventListener('mozbrowsermetachange', function(e) {
+    ok(false, 'Should not get a metachange event for iframe3.');
+  });
+
+
+  iframe1.src = createHtml(createMeta('application-name', 'foobar'));
+  // We should not recieve meta change events for either of the below iframes
+  iframe2.src = createHtml(createMeta('application-name', 'foobar'));
+  iframe3.src = createHtml(createMeta('application-name', 'foobar'));
+
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_NextPaint.js b/dom/browser-element/mochitest/browserElement_NextPaint.js
new file mode 100644
index 000000000..749a8efe3
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_NextPaint.js
@@ -0,0 +1,43 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 808231 - Add mozbrowsernextpaint event.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  // Add a first listener that we'll remove shortly after.
+  iframe.addNextPaintListener(wrongListener);
+
+  var gotFirstNextPaintEvent = false;
+  iframe.addNextPaintListener(function () {
+    ok(!gotFirstNextPaintEvent, 'got the first nextpaint event');
+
+    // Make sure we're only called once.
+    gotFirstNextPaintEvent = true;
+
+    iframe.addNextPaintListener(function () {
+      info('got the second nextpaint event');
+      SimpleTest.finish();
+    });
+
+    // Force the iframe to repaint.
+    SimpleTest.executeSoon(() => iframe.src += '#next');
+  });
+
+  // Remove the first listener to make sure it's not called.
+  iframe.removeNextPaintListener(wrongListener);
+  iframe.src = 'file_browserElement_NextPaint.html';
+}
+
+function wrongListener() {
+  ok(false, 'first listener should have been removed');
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_NoAudioTrack.js b/dom/browser-element/mochitest/browserElement_NoAudioTrack.js
new file mode 100644
index 000000000..47f0fd524
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_NoAudioTrack.js
@@ -0,0 +1,96 @@
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var fileURL = 'chrome://mochitests/content/chrome/dom/browser-element/mochitest/file_browserElement_NoAudioTrack.html';
+var generator = runTests();
+var testFrame;
+
+function alertListener(e) {
+  var message = e.detail.message;
+  if (/^OK/.exec(message)) {
+    ok(true, "Message from file : " + message);
+    continueTest();
+  } else if (/^KO/.exec(message)) {
+    error(message);
+  } else {
+    error("Undefined event.");
+  }
+}
+
+function error(aMessage) {
+  ok(false, "Error : " + aMessage);
+  finish();
+}
+
+function continueTest() {
+  try {
+    generator.next();
+  } catch (e if e instanceof StopIteration) {
+    error("Stop test because of exception!");
+  }
+}
+
+function finish() {
+  testFrame.removeEventListener('mozbrowsershowmodalprompt', alertListener);
+  ok(true, "Remove event-listener.");
+  document.body.removeChild(testFrame);
+  ok(true, "Remove test-frame from document.");
+  SimpleTest.finish();
+}
+
+function setCommand(aArg) {
+  info("# Command = " + aArg);
+  testFrame.src = fileURL + '#' + aArg;
+}
+
+function runTests() {
+  setCommand('play');
+  yield undefined;
+
+  // wait a second to make sure that onactivestatechanged isn't dispatched.
+  setCommand('idle');
+  yield undefined;
+
+  finish();
+  yield undefined;
+}
+
+function setupTestFrame() {
+  testFrame = document.createElement('iframe');
+  testFrame.setAttribute('mozbrowser', 'true');
+  testFrame.src = fileURL;
+
+  function loadend() {
+    testFrame.removeEventListener('mozbrowserloadend', loadend);
+    ok("allowedAudioChannels" in testFrame, "allowedAudioChannels exist");
+    var channels = testFrame.allowedAudioChannels;
+    is(channels.length, 9, "9 audio channel by default");
+
+    var ac = channels[0];
+    ok(ac instanceof BrowserElementAudioChannel, "Correct class");
+    ok("onactivestatechanged" in ac, "onactivestatechanged exists");
+
+    ac.onactivestatechanged = () => {
+      ac.onactivestatechanged = null;
+      ok(true, "Should receive onactivestatechanged!");
+    };
+
+    continueTest();
+  }
+
+  testFrame.addEventListener('mozbrowserloadend', loadend);
+  testFrame.addEventListener('mozbrowsershowmodalprompt', alertListener);
+  ok(true, "Add event-listeners.");
+
+  document.body.appendChild(testFrame);
+  ok(true, "Append test-frame to document.");
+}
+
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [["b2g.system_startup_url", window.location.href]]},
+                            function() {
+    SimpleTest.executeSoon(setupTestFrame);
+  });
+});
diff --git a/dom/browser-element/mochitest/browserElement_OpenMixedProcess.js b/dom/browser-element/mochitest/browserElement_OpenMixedProcess.js
new file mode 100644
index 000000000..c5cde7f50
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenMixedProcess.js
@@ -0,0 +1,105 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 776129 - If a window w calls window.open, the resultant window should be
+// remote iff w is remote.
+//
+// <iframe mozbrowser> can be default-OOP or default-in-process.  But we can
+// override this default by setting remote=true or remote=false on the iframe.
+//
+// This bug arises when we are default-in-process and a OOP iframe calls
+// window.open, or when we're default-OOP and an in-process iframe calls
+// window.open.  In either case, if the opened iframe gets the default
+// remotness, it will not match its opener's remoteness, which is bad.
+//
+// Since the name of the test determines the OOP-by-default pref, the "inproc"
+// version of this test opens an OOP frame, and the "oop" version opens an
+// in-process frame.  Enjoy.  :)
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+  // We're going to open a remote frame if OOP off by default.  If OOP is on by
+  // default, we're going to open an in-process frame.
+  var remote = !browserElementTestHelpers.getOOPByDefaultPref();
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.setAttribute('remote', remote);
+
+  // The page we load does window.open, then checks some things and reports
+  // back using alert().  Finally, it calls alert('finish').
+  //
+  // Bug 776129 in particular manifests itself such that the popup frame loads
+  // and the tests in file_browserElement_OpenMixedProcess pass, but the
+  // content of the frame is invisible.  To catch this case, we take a
+  // screenshot after we load the content into the popup, and ensure that it's
+  // not blank.
+  var popup;
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    popup = document.body.appendChild(e.detail.frameElement);
+  });
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    if (e.detail.message.startsWith('pass')) {
+      ok(true, e.detail.message);
+    }
+    else if (e.detail.message.startsWith('fail')) {
+      ok(false, e.detail.message);
+    }
+    else if (e.detail.message == 'finish') {
+      // We assume here that iframe is completely blank, and spin until popup's
+      // screenshot is not the same as iframe.
+      iframe.getScreenshot(1000, 1000).onsuccess = function(e) {
+        var fr = new FileReader();
+        fr.onloadend = function() { test2(popup, fr.result); };
+        fr.readAsArrayBuffer(e.target.result);
+      };
+    }
+    else {
+      ok(false, e.detail.message, "Unexpected message!");
+    }
+  });
+
+  document.body.appendChild(iframe);
+  iframe.src = 'file_browserElement_OpenMixedProcess.html';
+}
+
+function arrayBuffersEqual(a, b) {
+  var x = new Int8Array(a);
+  var y = new Int8Array(b);
+  if (x.length != y.length) {
+    return false;
+  }
+
+  for (var i = 0; i < x.length; i++) {
+    if (x[i] != y[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function test2(popup, blankScreenshotArrayBuffer) {
+  // Take screenshots of popup until it doesn't equal blankScreenshot (or we
+  // time out).
+  popup.getScreenshot(1000, 1000).onsuccess = function(e) {
+    var fr = new FileReader();
+    fr.onloadend = function() {
+      if (!arrayBuffersEqual(blankScreenshotArrayBuffer, fr.result)) {
+        ok(true, "Finally got a non-blank screenshot.");
+        SimpleTest.finish();
+        return;
+      }
+
+      SimpleTest.executeSoon(function() { test2(popup, blankScreenshot) });
+    };
+    fr.readAsArrayBuffer(e.target.result);
+  };
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_OpenNamed.js b/dom/browser-element/mochitest/browserElement_OpenNamed.js
new file mode 100644
index 000000000..aed5617e9
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenNamed.js
@@ -0,0 +1,57 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 742944 - In <iframe mozbrowser>, test that if we call window.open twice
+// with the same name, we get only one mozbrowseropenwindow event.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var iframe;
+var popupFrame;
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  var gotPopup = false;
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    is(gotPopup, false, 'Should get just one popup.');
+    gotPopup = true;
+    popupFrame = e.detail.frameElement;
+    is(popupFrame.getAttribute('name'), 'OpenNamed');
+
+    // Called when file_browserElement_OpenNamed2.html loads into popupFrame.
+    popupFrame.addEventListener('mozbrowsershowmodalprompt', function promptlistener(e) {
+      popupFrame.removeEventListener('mozbrowsershowmodalprompt', promptlistener);
+
+      ok(gotPopup, 'Got openwindow event before showmodalprompt event.');
+      is(e.detail.message, 'success: loaded');
+      SimpleTest.executeSoon(test2);
+    });
+
+    document.body.appendChild(popupFrame);
+  });
+
+  // OpenNamed.html will call
+  //
+  //    window.open('file_browserElement_OpenNamed2.html', 'OpenNamed').
+  //
+  // Once that popup loads, we reload OpenNamed.html.  That will call
+  // window.open again, but we shouldn't get another openwindow event, because
+  // we're opening into the same named window.
+  iframe.src = 'file_browserElement_OpenNamed.html';
+  document.body.appendChild(iframe);
+}
+
+function test2() {
+  popupFrame.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    is(e.detail.message, 'success: loaded');
+    SimpleTest.finish();
+  });
+
+  iframe.src = 'file_browserElement_OpenNamed.html?test2';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_OpenTab.js b/dom/browser-element/mochitest/browserElement_OpenTab.js
new file mode 100644
index 000000000..d01927e9b
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenTab.js
@@ -0,0 +1,69 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 1144015 - test middle/ctrl/cmd-click on a link.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  let iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  let x = 2;
+  let y = 2;
+  // First we force a reflow so that getChildProcessOffset actually returns
+  // meaningful data.
+  iframe.getBoundingClientRect();
+  // We need to make sure the event coordinates are actually inside the iframe,
+  // relative to the chome window.
+  let tabParent = SpecialPowers.wrap(iframe)
+                  .QueryInterface(SpecialPowers.Ci.nsIFrameLoaderOwner)
+                  .frameLoader.tabParent;
+  if (tabParent) {
+    let offsetX = {};
+    let offsetY = {};
+    tabParent.getChildProcessOffset(offsetX, offsetY);
+    x -= offsetX.value;
+    y -= offsetY.value;
+  }
+
+  let sendCtrlClick = () => {
+    let nsIDOMWindowUtils = SpecialPowers.Ci.nsIDOMWindowUtils;
+    let mod = nsIDOMWindowUtils.MODIFIER_META |
+              nsIDOMWindowUtils.MODIFIER_CONTROL;
+    iframe.sendMouseEvent('mousedown', x, y, 0, 1, mod);
+    iframe.sendMouseEvent('mouseup', x, y, 0, 1, mod);
+  }
+
+  let onCtrlClick = e => {
+    is(e.detail.url, 'http://example.com/', 'URL matches');
+    iframe.removeEventListener('mozbrowseropentab', onCtrlClick);
+    iframe.addEventListener('mozbrowseropentab', onMiddleClick);
+    sendMiddleClick();
+  }
+
+  let sendMiddleClick = () => {
+    iframe.sendMouseEvent('mousedown', x, y, 1, 1, 0);
+    iframe.sendMouseEvent('mouseup', x, y, 1, 1, 0);
+  }
+
+  let onMiddleClick = e => {
+    is(e.detail.url, 'http://example.com/', 'URL matches');
+    iframe.removeEventListener('mozbrowseropentab', onMiddleClick);
+    SimpleTest.finish();
+  }
+
+  iframe.addEventListener('mozbrowserloadend', e => {
+    iframe.addEventListener('mozbrowseropentab', onCtrlClick);
+    sendCtrlClick();
+  });
+
+
+  iframe.src = 'data:text/html,<body style="margin:0"><a href="http://example.com"><span>click here</span></a></body>';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_OpenWindow.js b/dom/browser-element/mochitest/browserElement_OpenWindow.js
new file mode 100644
index 000000000..65de11a26
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenWindow.js
@@ -0,0 +1,58 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 742944 - Test that window.open works with <iframe mozbrowser>.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  var gotPopup = false;
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    is(gotPopup, false, 'Should get just one popup.');
+    gotPopup = true;
+
+    document.body.appendChild(e.detail.frameElement);
+
+    ok(/file_browserElement_Open2\.html$/.test(e.detail.url),
+       "Popup's URL (got " + e.detail.url + ")");
+    is(e.detail.name, "name");
+    is(e.detail.features, "dialog=1");
+  });
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    ok(gotPopup, 'Got mozbrowseropenwindow event before showmodalprompt event.');
+    if (e.detail.message.indexOf("success:") == 0) {
+      ok(true, e.detail.message);
+    }
+    else if (e.detail.message.indexOf("failure:") == 0) {
+      ok(false, e.detail.message);
+    }
+    else if (e.detail.message == "finish") {
+      SimpleTest.finish();
+    }
+    else {
+      ok(false, "Got invalid message: " + e.detail.message);
+    }
+  });
+
+  /**
+   * file_browserElementOpen1 does
+   *
+   *   window.open('file_browserElement_Open2.html', 'name', 'dialog=1')
+   *
+   * then adds an event listener to the opened window and waits for onload.
+   *
+   * Onload, we fire a few alerts saying "success:REASON" or "failure:REASON".
+   * Finally, we fire a "finish" alert, which ends the test.
+   */
+  iframe.src = 'file_browserElement_Open1.html';
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_OpenWindowDifferentOrigin.js b/dom/browser-element/mochitest/browserElement_OpenWindowDifferentOrigin.js
new file mode 100644
index 000000000..650ef17f5
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenWindowDifferentOrigin.js
@@ -0,0 +1,41 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 769182 - window.open to a different origin should load the page.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    ok(true, 'Got first window.open call');
+
+    e.detail.frameElement.addEventListener('mozbrowseropenwindow', function(e) {
+      ok(true, 'Got second window.open call');
+      document.body.appendChild(e.detail.frameElement);
+    });
+
+    e.detail.frameElement.addEventListener('mozbrowsershowmodalprompt', function(e) {
+      ok(true, 'Got alert from second window.');
+      SimpleTest.finish();
+    });
+
+    document.body.appendChild(e.detail.frameElement);
+  });
+
+  // DifferentOrigin.html?1 calls
+  //
+  //   window.open('http://example.com/.../DifferentOrigin.html?2'),
+  //
+  // which calls alert().
+
+  iframe.src = 'http://example.org/tests/dom/browser-element/mochitest/file_browserElement_OpenWindowDifferentOrigin.html?1';
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_OpenWindowEmpty.js b/dom/browser-element/mochitest/browserElement_OpenWindowEmpty.js
new file mode 100644
index 000000000..6b8dd0340
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenWindowEmpty.js
@@ -0,0 +1,31 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 1216937 - Test that window.open with null/empty URL should use
+// about:blank as default
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  var gotPopup = false;
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    is(gotPopup, false, 'Should get just one popup.');
+    gotPopup = true;
+
+    is(e.detail.url, 'about:blank', "Popup's has correct URL");
+    e.preventDefault();
+
+    SimpleTest.finish();
+  });
+
+  iframe.src = 'file_browserElement_OpenWindowEmpty.html';
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_OpenWindowInFrame.js b/dom/browser-element/mochitest/browserElement_OpenWindowInFrame.js
new file mode 100644
index 000000000..5559bbcb8
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenWindowInFrame.js
@@ -0,0 +1,65 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 766871 - Test that window.open works from an <iframe> within <iframe mozbrowser>.
+//
+// This is basically the same as browserElement_OpenWindow, except that instead
+// of loading file_browserElement_Open1.html directly inside the <iframe
+// mozbrowser>, we load file_browserElement_OpenWindowInFrame.html into the
+// mozbrowser.  OpenWindowInFrame loads file_browserElement_Open1.html inside
+// an iframe.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  var gotPopup = false;
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    is(gotPopup, false, 'Should get just one popup.');
+    gotPopup = true;
+
+    document.body.appendChild(e.detail.frameElement);
+
+    ok(/file_browserElement_Open2\.html$/.test(e.detail.url),
+       "Popup's URL (got " + e.detail.url + ")");
+    is(e.detail.name, "name");
+    is(e.detail.features, "dialog=1");
+  });
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    ok(gotPopup, 'Got mozbrowseropenwindow event before showmodalprompt event.');
+    if (e.detail.message.indexOf("success:") == 0) {
+      ok(true, e.detail.message);
+    }
+    else if (e.detail.message.indexOf("failure:") == 0) {
+      ok(false, e.detail.message);
+    }
+    else if (e.detail.message == "finish") {
+      SimpleTest.finish();
+    }
+    else {
+      ok(false, "Got invalid message: " + e.detail.message);
+    }
+  });
+
+  /**
+   * file_browserElement_OpenWindowInFrame.html loads
+   * file_browserElement_Open1.html in an iframe.  Open1.html does
+   *
+   *   window.open('file_browserElement_Open2.html', 'name', 'dialog=1')
+   *
+   * then adds an event listener to the opened window and waits for onload.
+   *
+   * Onload, we fire a few alerts saying "success:REASON" or "failure:REASON".
+   * Finally, we fire a "finish" alert, which ends the test.
+   */
+  iframe.src = 'file_browserElement_OpenWindowInFrame.html';
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_OpenWindowRejected.js b/dom/browser-element/mochitest/browserElement_OpenWindowRejected.js
new file mode 100644
index 000000000..f5ef97260
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenWindowRejected.js
@@ -0,0 +1,44 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 742944 - Do window.open from inside <iframe mozbrowser>.  But then
+// reject the call.  This shouldn't cause problems (crashes, leaks).
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    ok(e.detail.url.indexOf('does_not_exist.html') != -1,
+       'Opened URL; got ' + e.detail.url);
+    is(e.detail.name, '');
+    is(e.detail.features, '');
+
+    // Don't add e.detail.frameElement to the DOM, so the window.open is
+    // effectively blocked.
+    e.preventDefault();
+  });
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    var msg = e.detail.message;
+    if (msg.indexOf('success:') == 0) {
+      ok(true, msg);
+    }
+    else if (msg == 'finish') {
+      SimpleTest.finish();
+    }
+    else {
+      ok(false, msg);
+    }
+  });
+
+  iframe.src = 'file_browserElement_OpenWindowRejected.html';
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_OpenWindowRejected2.js b/dom/browser-element/mochitest/browserElement_OpenWindowRejected2.js
new file mode 100644
index 000000000..acea6813e
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_OpenWindowRejected2.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 742944 - Do window.open from inside <iframe mozbrowser>.  But then
+// reject the call.  This shouldn't cause problems (crashes, leaks).
+//
+// This is the same as OpenWindowRejected, except we "reject" the popup by not
+// adding the iframe element to our DOM, instead of by not calling
+// preventDefault() on the event.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    ok(e.detail.url.indexOf('does_not_exist.html') != -1,
+       'Opened URL; got ' + e.detail.url);
+    is(e.detail.name, '');
+    is(e.detail.features, '');
+
+    // Call preventDefault, but don't add the iframe to the DOM.  This still
+    // amounts to rejecting the popup.
+    e.preventDefault();
+  });
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    var msg = e.detail.message;
+    if (msg.indexOf('success:') == 0) {
+      ok(true, msg);
+    }
+    else if (msg == 'finish') {
+      SimpleTest.finish();
+    }
+    else {
+      ok(false, msg);
+    }
+  });
+
+  iframe.src = 'file_browserElement_OpenWindowRejected.html';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Opensearch.js b/dom/browser-element/mochitest/browserElement_Opensearch.js
new file mode 100644
index 000000000..8df44d2a9
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Opensearch.js
@@ -0,0 +1,109 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the onmozbrowseropensearch event works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function createHtml(link) {
+  return 'data:text/html,<html><head>' + link + '<body></body></html>';
+}
+
+function createLink(name) {
+  return '<link rel="search" title="Test OpenSearch" type="application/opensearchdescription+xml" href="http://example.com/' + name + '.xml">';
+}
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe1);
+
+  // iframe2 is a red herring; we modify its link but don't listen for
+  // opensearch; we want to make sure that its opensearch events aren't
+  // picked up by the listener on iframe1.
+  var iframe2 = document.createElement('iframe');
+  iframe2.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe2);
+
+  // iframe3 is another red herring.  It's not a mozbrowser, so we shouldn't
+  // get any opensearch events on it.
+  var iframe3 = document.createElement('iframe');
+  document.body.appendChild(iframe3);
+
+  var numLinkChanges = 0;
+
+  iframe1.addEventListener('mozbrowseropensearch', function(e) {
+
+    numLinkChanges++;
+
+    if (numLinkChanges == 1) {
+      is(e.detail.title, 'Test OpenSearch');
+      is(e.detail.href, 'http://example.com/mysearch.xml');
+
+      // We should recieve opensearch events when the user creates new links
+      // to a search engine, but only when we listen for them
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.title='New title';",
+                                    /* allowDelayedLoad = */ false);
+
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=SEARCH type=application/opensearchdescription+xml href=http://example.com/newsearch.xml>')",
+                                    /* allowDelayedLoad = */ false);
+
+      SpecialPowers.getBrowserFrameMessageManager(iframe2)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=SEARCH type=application/opensearchdescription+xml href=http://example.com/newsearch.xml>')",
+                                    /* allowDelayedLoad = */ false);
+    }
+    else if (numLinkChanges == 2) {
+      is(e.detail.href, 'http://example.com/newsearch.xml');
+
+      // Full new pages should trigger opensearch events
+      iframe1.src = createHtml(createLink('3rdsearch'));
+    }
+    else if (numLinkChanges == 3) {
+      is(e.detail.href, 'http://example.com/3rdsearch.xml');
+
+      // the rel attribute can have various space seperated values, make
+      // sure we only pick up correct values for 'opensearch'
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=someopensearch type=application/opensearchdescription+xml href=http://example.com/newsearch.xml>')",
+                                    /* allowDelayedLoad = */ false);
+      // Test setting a page with multiple links elements
+      iframe1.src = createHtml(createLink('another') + createLink('search'));
+    }
+    else if (numLinkChanges == 4) {
+      is(e.detail.href, 'http://example.com/another.xml');
+      // 2 events will be triggered by previous test, wait for next
+    }
+    else if (numLinkChanges == 5) {
+      is(e.detail.href, 'http://example.com/search.xml');
+
+      // Make sure opensearch check is case insensitive
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.head.insertAdjacentHTML('beforeend', '<link rel=SEARCH type=application/opensearchdescription+xml href=http://example.com/ucasesearch.xml>')",
+                                    /* allowDelayedLoad = */ false);
+    }
+    else if (numLinkChanges == 6) {
+      is(e.detail.href, 'http://example.com/ucasesearch.xml');
+      SimpleTest.finish();
+    } else {
+      ok(false, 'Too many opensearch events.');
+    }
+  });
+
+  iframe3.addEventListener('mozbrowseropensearch', function(e) {
+    ok(false, 'Should not get a opensearch event for iframe3.');
+  });
+
+
+  iframe1.src = createHtml(createLink('mysearch'));
+  // We should not recieve opensearch change events for either of the below iframes
+  iframe2.src = createHtml(createLink('mysearch'));
+  iframe3.src = createHtml(createLink('mysearch'));
+
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_PrivateBrowsing.js b/dom/browser-element/mochitest/browserElement_PrivateBrowsing.js
new file mode 100644
index 000000000..c32edcc37
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_PrivateBrowsing.js
@@ -0,0 +1,49 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the mozprivatebrowsing attribute works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function createFrame(aIsPrivate) {
+  var iframe = document.createElement("iframe");
+  iframe.setAttribute('mozbrowser', 'true');
+  if (aIsPrivate) {
+    iframe.setAttribute("mozprivatebrowsing", "true");
+  }
+  return iframe;
+}
+
+function createTest(aIsPrivate, aExpected, aClearStorage) {
+  info("createTest " + aIsPrivate + " " + aExpected);
+  return new Promise(function(resolve, reject) {
+    var iframe = createFrame(aIsPrivate);
+    document.body.appendChild(iframe);
+
+    iframe.addEventListener("mozbrowsershowmodalprompt", function(e) {
+      is(e.detail.message, aExpected, "Checking localstorage");
+      resolve();
+    });
+
+    var src = "file_browserElement_PrivateBrowsing.html";
+    iframe.src = aClearStorage ? src + "?clear=true" : src;
+
+  });
+}
+
+function runTest() {
+  // We first create a iframe in non private browsing mode, set up some
+  // localstorage, reopen it to check that we get the previously set value.
+  // Finally, open it in private browsing mode and check that localstorage
+  // is clear.
+  createTest(false, "CLEAR", true)
+  .then(() => { return createTest(false, "EMPTY", false); })
+  .then(() => { return createTest(false, "bar", false); })
+  .then(() => { return createTest(true, "EMPTY", false); })
+  .then(SimpleTest.finish);
+}
+
+addEventListener("testready", runTest);
diff --git a/dom/browser-element/mochitest/browserElement_PromptCheck.js b/dom/browser-element/mochitest/browserElement_PromptCheck.js
new file mode 100644
index 000000000..d6edde09f
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_PromptCheck.js
@@ -0,0 +1,59 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that alertCheck (i.e., alert with the opportunity to opt out of future
+// alerts), promptCheck, and confirmCheck work.  We do this by spamming
+// alerts/prompts/confirms from inside an <iframe mozbrowser>.
+//
+// At the moment, we treat alertCheck/promptCheck/confirmCheck just like a
+// normal alert.  But it's different to nsIPrompt!
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest()
+{
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  var numPrompts = 0;
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    is(e.detail.message, String(numPrompts), "prompt message");
+    if (numPrompts / 10 < 1) {
+      is(e.detail.promptType, 'alert');
+    }
+    else if (numPrompts / 10 < 2) {
+      is(e.detail.promptType, 'confirm');
+    }
+    else {
+      is(e.detail.promptType, 'prompt');
+    }
+
+    numPrompts++;
+    if (numPrompts == 30) {
+      SimpleTest.finish();
+    }
+  });
+
+  iframe.src =
+    'data:text/html,<html><body><script>\
+      addEventListener("load", function() { \
+       setTimeout(function() { \
+        var i = 0; \
+        for (; i < 10; i++) { alert(i); } \
+        for (; i < 20; i++) { confirm(i); } \
+        for (; i < 30; i++) { prompt(i); } \
+       }); \
+     }); \
+     </scr' + 'ipt></body></html>';
+}
+
+// The test harness sets dom.successive_dialog_time_limit to 0 for some bizarre
+// reason.  That's not normal usage, and it keeps us from testing alertCheck!
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set': [['dom.successive_dialog_time_limit', 10]]}, runTest);
+});
diff --git a/dom/browser-element/mochitest/browserElement_PromptConfirm.js b/dom/browser-element/mochitest/browserElement_PromptConfirm.js
new file mode 100644
index 000000000..c01836a25
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_PromptConfirm.js
@@ -0,0 +1,87 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that prompt and confirm work.  In particular, we're concerned that we
+// get correct return values out of them.
+//
+// We use alert() to communicate the return values of prompt/confirm back to
+// ourselves.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  var prompts = [
+    {msg: '1', type: 'alert', rv: 42, expected: 'undefined'},
+    {msg: '2', type: 'confirm', rv: true, expected: 'true'},
+    {msg: '3', type: 'confirm', rv: false, expected: 'false'},
+
+    // rv == 42 should be coerced to 'true' for confirm.
+    {msg: '4', type: 'confirm', rv: 42, expected: 'true'},
+    {msg: '5', type: 'prompt', rv: 'worked', expected: 'worked'},
+    {msg: '6', type: 'prompt', rv: null, expected: 'null'},
+    {msg: '7', type: 'prompt', rv: '', expected: ''}
+  ];
+
+  iframe.addEventListener("mozbrowsershowmodalprompt", function(e) {
+    var curPrompt = prompts[0];
+    if (!curPrompt.waitingForResponse) {
+      curPrompt.waitingForResponse = true;
+
+      is(e.detail.message, curPrompt.msg, "prompt message");
+      is(e.detail.promptType, curPrompt.type, "prompt type");
+
+      if (e.detail.promptType == 'prompt') {
+        ok(e.detail.returnValue === null, "prompt's returnValue should be null");
+        is(e.detail.initialValue, "initial", "prompt's initial value.");
+      }
+      else {
+        ok(e.detail.returnValue === undefined,
+           "Other than for prompt, shouldn't have initial value.");
+      }
+
+      // Block the child until we call e.detail.unblock().
+      e.preventDefault();
+
+      SimpleTest.executeSoon(function() {
+        e.detail.returnValue = curPrompt.rv;
+        e.detail.unblock();
+      });
+    }
+    else {
+      prompts.shift();
+
+      // |e| now corresponds to an alert() containing the return value we just
+      // sent for this prompt.
+
+      is(e.detail.message, 'RESULT:' + curPrompt.expected,
+         "expected rv for msg " + curPrompt.msg);
+
+      if (prompts.length == 0) {
+        SimpleTest.finish();
+      }
+    }
+  });
+
+  iframe.src =
+    'data:text/html,<html><body><script>\
+      function sendVal(val) { \
+        alert("RESULT:" + val); \
+      } \
+      sendVal(alert("1")); \
+      sendVal(confirm("2")); \
+      sendVal(confirm("3")); \
+      sendVal(confirm("4")); \
+      sendVal(prompt("5", "initial")); \
+      sendVal(prompt("6", "initial")); \
+      sendVal(prompt("7", "initial")); \
+    </scr' + 'ipt></body></html>';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Proxy.js b/dom/browser-element/mochitest/browserElement_Proxy.js
new file mode 100644
index 000000000..227b40c5f
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Proxy.js
@@ -0,0 +1,163 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  let frameUrl = SimpleTest.getTestFileURL('/file_empty.html');
+  SpecialPowers.pushPermissions([{
+    type: 'browser:embedded-system-app',
+    allow: true,
+    context: {
+      url: frameUrl,
+      originAttributes: {
+        inIsolatedMozBrowser: true
+      }
+    }
+  },{
+    type: 'browser',
+    allow: true,
+    context: {
+      url: frameUrl,
+      originAttributes: {
+        inIsolatedMozBrowser: true
+      }
+    }
+  }], createFrame);
+}
+
+var frame;
+var mm;
+
+function createFrame() {
+  let loadEnd = function() {
+    // The frame script running in the frame where the input is hosted.
+    let appFrameScript = function appFrameScript() {
+      let i = 1;
+
+      addMessageListener('test:next', function() {
+        try {
+          switch (i) {
+            case 1:
+              content.document.addEventListener(
+                'visibilitychange', function fn() {
+                content.document.removeEventListener('visibilitychange', fn);
+                sendAsyncMessage('test:done', {
+                  ok: true,
+                  msg: 'setVisible()'
+                });
+              });
+
+              // Test a no return method
+              content.navigator.mozBrowserElementProxy.setVisible(false);
+
+              break;
+            case 2:
+              // Test a DOMRequest method
+              var req = content.navigator.mozBrowserElementProxy.getVisible();
+              req.onsuccess = function() {
+                sendAsyncMessage('test:done', {
+                  ok: true,
+                  msg: 'getVisible()'
+                });
+              };
+
+              req.onerror = function() {
+                sendAsyncMessage('test:done', {
+                  ok: false,
+                  msg: 'getVisible() DOMRequest return error.'
+                });
+              };
+
+              break;
+            case 3:
+              // Test an unimplemented method
+              try {
+                content.navigator.mozBrowserElementProxy.getActive();
+                sendAsyncMessage('test:done', {
+                  ok: false,
+                  msg: 'getActive() should throw.'
+                });
+
+              } catch (e) {
+                sendAsyncMessage('test:done', {
+                  ok: true,
+                  msg: 'getActive() throws.'
+                });
+              }
+
+              break;
+            case 4:
+              content.navigator.mozBrowserElementProxy
+              .addEventListener(
+                'mozbrowserlocationchange',
+                function() {
+                  content.navigator.mozBrowserElementProxy
+                    .onmozbrowserlocationchange = null;
+
+                  sendAsyncMessage('test:done', {
+                    ok: true,
+                    msg: 'mozbrowserlocationchange'
+                  });
+              });
+
+              // Test event
+              content.location.hash = '#foo';
+
+              break;
+          }
+        } catch (e) {
+          sendAsyncMessage('test:done', {
+            ok: false, msg: 'thrown: ' + e.toString() });
+        }
+
+        i++;
+      });
+
+      sendAsyncMessage('test:done', {});
+    }
+
+    mm = SpecialPowers.getBrowserFrameMessageManager(frame);
+    mm.loadFrameScript('data:,(' + encodeURIComponent(appFrameScript.toString()) + ')();', false);
+    mm.addMessageListener("test:done", next);
+  };
+
+  frame = document.createElement('iframe');
+  frame.setAttribute('mozbrowser', 'true');
+  frame.src = 'file_empty.html';
+  document.body.appendChild(frame);
+  frame.addEventListener('mozbrowserloadend', loadEnd);
+}
+
+var i = 0;
+function next(msg) {
+  let wrappedMsg = SpecialPowers.wrap(msg);
+  let isOK = wrappedMsg.data.ok;
+  let msgString = wrappedMsg.data.msg;
+
+  switch (i) {
+    case 0:
+      mm.sendAsyncMessage('test:next');
+      break;
+
+    case 1:
+    case 2:
+    case 3:
+      ok(isOK, msgString);
+      mm.sendAsyncMessage('test:next');
+      break;
+
+    case 4:
+      ok(isOK, msgString);
+      SimpleTest.finish();
+      break;
+  }
+
+  i++;
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_PurgeHistory.js b/dom/browser-element/mochitest/browserElement_PurgeHistory.js
new file mode 100644
index 000000000..4815f03e7
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_PurgeHistory.js
@@ -0,0 +1,87 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 807056 - [Browser] Clear History doesn't clear back/forward history in open tabs
+// <iframe mozbrowser>.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframe;
+function addOneShotIframeEventListener(event, fn) {
+  function wrapper(e) {
+    iframe.removeEventListener(event, wrapper);
+    fn(e);
+  };
+
+  iframe.addEventListener(event, wrapper);
+}
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  // FIXME: Bug 1270790
+  iframe.setAttribute('remote', 'true');
+
+  addOneShotIframeEventListener('mozbrowserloadend', function() {
+    SimpleTest.executeSoon(test2);
+  });
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+  document.body.appendChild(iframe);
+}
+
+function purgeHistory(nextTest) {
+  var seenCanGoBackResult = false;
+  var seenCanGoForwardResult = false;
+
+  iframe.purgeHistory().onsuccess = function(e) {
+    ok(true, "The history has been purged");
+
+    iframe.getCanGoBack().onsuccess = function(e) {
+      is(e.target.result, false, "Iframe cannot go back");
+      seenCanGoBackResult = true;
+      maybeRunNextTest();
+    };
+
+    iframe.getCanGoForward().onsuccess = function(e) {
+      is(e.target.result, false, "Iframe cannot go forward");
+      seenCanGoForwardResult = true;
+      maybeRunNextTest();
+    };
+  };
+
+  function maybeRunNextTest() {
+    if (seenCanGoBackResult && seenCanGoForwardResult) {
+      nextTest();
+    }
+  }
+}
+
+function test2() {
+  purgeHistory(test3);
+}
+
+function test3() {
+  addOneShotIframeEventListener('mozbrowserloadend', function() {
+    purgeHistory(test4);
+  });
+
+  SimpleTest.executeSoon(function() {
+    iframe.src = browserElementTestHelpers.emptyPage2;
+  });
+}
+
+function test4() {
+  addOneShotIframeEventListener('mozbrowserlocationchange', function(e) {
+    is(e.detail.url, browserElementTestHelpers.emptyPage3);
+    purgeHistory(SimpleTest.finish);
+  });
+
+  SimpleTest.executeSoon(function() {
+    iframe.src = browserElementTestHelpers.emptyPage3;
+  });
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Reload.js b/dom/browser-element/mochitest/browserElement_Reload.js
new file mode 100644
index 000000000..9ef6d8e7e
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Reload.js
@@ -0,0 +1,59 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 741717 - Test the reload ability of <iframe mozbrowser>.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var iframeScript = function() {
+  sendAsyncMessage('test:innerHTML', {
+    data: XPCNativeWrapper.unwrap(content).document.body.innerHTML
+  });
+}
+
+var mm;
+var iframe;
+var loadedEvents = 0;
+var countAcc;
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowserloadend', mozbrowserLoaded);
+
+  iframe.src = 'file_bug741717.sjs';
+  document.body.appendChild(iframe);
+}
+
+function iframeBodyRecv(data) {
+  data = SpecialPowers.wrap(data);
+  var previousCount = countAcc;
+  var currentCount = parseInt(data.json.data, 10);
+  countAcc = currentCount;
+  switch (loadedEvents) {
+  case 1:
+    iframe.reload();
+    break;
+  case 2:
+    ok(true, 'reload was triggered');
+    ok(previousCount === currentCount, 'reload was a soft reload');
+    iframe.reload(true);
+    break;
+  case 3:
+    ok(currentCount > previousCount, 'reload was a hard reload');
+    SimpleTest.finish();
+  }
+}
+
+function mozbrowserLoaded() {
+  loadedEvents++;
+  mm = SpecialPowers.getBrowserFrameMessageManager(iframe);
+  mm.addMessageListener('test:innerHTML', iframeBodyRecv);
+  mm.loadFrameScript('data:,(' + iframeScript.toString() + ')();', false);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_ReloadPostRequest.js b/dom/browser-element/mochitest/browserElement_ReloadPostRequest.js
new file mode 100644
index 000000000..614ed7c49
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ReloadPostRequest.js
@@ -0,0 +1,116 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 793644, fire an event when attempting to reloads browser element after
+// POST respest.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("untriaged");
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframe;
+var gotConfirmRepost = false;
+var doRepost = true;
+var timer;
+var isPostRequestSubmitted;
+
+function getExpectedStrings() {
+  let result = {};
+  let bundleService = SpecialPowers.Cc['@mozilla.org/intl/stringbundle;1'].
+    getService(SpecialPowers.Ci.nsIStringBundleService);
+  let appBundle = bundleService.createBundle("chrome://global/locale/appstrings.properties");
+  let brandBundle = bundleService.createBundle("chrome://branding/locale/brand.properties");
+  try {
+    let brandName = brandBundle.GetStringFromName("brandShortName");
+    result.message = appBundle.formatStringFromName("confirmRepostPrompt",
+                                                    [brandName], 1);
+  } catch (e) {
+    // for the case that we don't have brandShortName
+    result.message = appBundle.GetStringFromName("confirmRepostPrompt");
+  }
+  result.resend = appBundle.GetStringFromName("resendButton.label");
+
+  return result;
+}
+
+function failBecauseReloaded() {
+  window.clearTimeout(timer);
+  timer = null;
+  iframe.removeEventListener('mozbrowserloadend', failBecauseReloaded);
+  ok(false, "We don't expect browser element to reload, but it did");
+  SimpleTest.finish();
+};
+
+function reloadDone() {
+  iframe.removeEventListener('mozbrowserloadend', reloadDone);
+  ok(gotConfirmRepost, "Didn't get confirmEx prompt before reload");
+
+  // Run again, with repost disallowed.
+  doRepost = false;
+  isPostRequestSubmitted = false;
+  iframe.src = 'file_post_request.html';
+  iframe.addEventListener('mozbrowserloadend', pageLoadDone);
+}
+
+function pageLoadDone() {
+  if (!isPostRequestSubmitted) {
+    // This loadend is done by setting url in address bar, so we don't need to
+    // do anything. The test page will submit a POST request.
+    isPostRequestSubmitted = true;
+    return;
+  }
+
+  gotConfirmRepost = false;
+  iframe.removeEventListener('mozbrowserloadend', pageLoadDone);
+  if (doRepost) {
+    iframe.addEventListener('mozbrowserloadend', reloadDone);
+  } else {
+    // We don't expect browserelement to reload; use a timer to make sure
+    // it is not reloaded.
+    iframe.addEventListener('mozbrowserloadend', failBecauseReloaded);
+  }
+  iframe.reload();
+}
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  isPostRequestSubmitted = false;
+  iframe.src = 'file_post_request.html';
+  document.body.appendChild(iframe);
+
+  iframe.addEventListener('mozbrowserloadend', pageLoadDone);
+
+  let expectedMessage = getExpectedStrings();
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    if (e.detail.promptType == 'custom-prompt') {
+      gotConfirmRepost = true;
+      e.preventDefault();
+      e.detail.returnValue = {
+        selectedButton: doRepost ? 0 : 1,
+      };
+      is(e.detail.returnValue.checked, undefined);
+      is(e.detail.buttons[0].messageType, 'custom');
+      is(e.detail.buttons[0].message, expectedMessage.resend);
+      is(e.detail.buttons[1].messageType, 'builtin');
+      is(e.detail.buttons[1].message, 'cancel');
+      is(e.detail.message, expectedMessage.message);
+      is(e.detail.buttons.length, 2);
+      is(e.detail.showCheckbox, false);
+      is(e.detail.checkboxMessage, null);
+      e.detail.unblock();
+
+      if (!doRepost) {
+        // To make sure the page doesn't reload in 1 sec.
+        timer = window.setTimeout(function() {
+          iframe.removeEventListener('mozbrowserloadend', failBecauseReloaded);
+          SimpleTest.finish();
+        }, 1000);
+      }
+    }
+  });
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_RemoveBrowserElement.js b/dom/browser-element/mochitest/browserElement_RemoveBrowserElement.js
new file mode 100644
index 000000000..583d58734
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_RemoveBrowserElement.js
@@ -0,0 +1,30 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 787517: Remove iframe in the handler of showmodalprompt. This shouldn't
+// cause an exception to be thrown.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  iframe.addEventListener("mozbrowsershowmodalprompt", function(e) {
+    document.body.removeChild(iframe);
+    SimpleTest.executeSoon(function() {
+      ok(true);
+      SimpleTest.finish();
+    });
+  });
+
+  iframe.src = "data:text/html,<html><body><script>alert(\"test\")</script>" +
+               "</body></html>";
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_ScrollEvent.js b/dom/browser-element/mochitest/browserElement_ScrollEvent.js
new file mode 100644
index 000000000..5c4b4dcf9
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ScrollEvent.js
@@ -0,0 +1,27 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that scroll event bubbles up.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  iframe.addEventListener("mozbrowserscroll", function(e) {
+    ok(true, "got mozbrowserscroll event.");
+    ok(e.detail, "event.detail is not null.");
+    ok(e.detail.top === 4000, "top position is correct.");
+    ok(e.detail.left === 4000, "left position is correct.");
+    SimpleTest.finish();
+  });
+
+  iframe.src = "data:text/html,<html><body style='min-height: 5000px; min-width: 5000px;'></body><script>window.scrollTo(4000, 4000);</script></html>";
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_SecurityChange.js b/dom/browser-element/mochitest/browserElement_SecurityChange.js
new file mode 100644
index 000000000..0ef64b3fa
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_SecurityChange.js
@@ -0,0 +1,82 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 763694 - Test that <iframe mozbrowser> delivers proper
+// mozbrowsersecuritychange events.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+const { Services } = SpecialPowers.Cu.import('resource://gre/modules/Services.jsm');
+const { UrlClassifierTestUtils } = SpecialPowers.Cu.import('resource://testing-common/UrlClassifierTestUtils.jsm', {});
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  var lastSecurityState;
+  iframe.addEventListener('mozbrowsersecuritychange', function(e) {
+    lastSecurityState = e.detail;
+  });
+
+  var filepath = 'tests/dom/browser-element/mochitest/file_browserElement_SecurityChange.html';
+
+  var count = 0;
+  iframe.addEventListener('mozbrowserloadend', function(e) {
+    count++;
+    switch (count) {
+    case 1:
+      is(lastSecurityState.state, 'secure');
+      is(lastSecurityState.extendedValidation, false);
+      is(lastSecurityState.trackingContent, false);
+      is(lastSecurityState.mixedContent, false);
+      iframe.src = "http://example.com/" + filepath;
+      break;
+    case 2:
+      is(lastSecurityState.state, 'insecure');
+      is(lastSecurityState.extendedValidation, false);
+      is(lastSecurityState.trackingContent, false);
+      is(lastSecurityState.mixedContent, false);
+      iframe.src = 'https://example.com:443/' + filepath + '?broken';
+      break;
+    case 3:
+      is(lastSecurityState.state, 'broken');
+      is(lastSecurityState.extendedValidation, false);
+      is(lastSecurityState.trackingContent, false);
+      is(lastSecurityState.mixedContent, true);
+      iframe.src = "http://example.com/" + filepath + '?tracking';
+      break;
+    case 4:
+      is(lastSecurityState.state, 'insecure');
+      is(lastSecurityState.extendedValidation, false);
+      // TODO: I'm having trouble getting the tracking protection
+      // test changes to be enabled in the child process, so this
+      // isn't currently blocked in tests, but it works when
+      // manually testing.
+      // is(lastSecurityState.trackingContent, true);
+      is(lastSecurityState.mixedContent, false);
+      SimpleTest.finish();
+    }
+  });
+
+  iframe.src = "https://example.com/" + filepath;
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', function() {
+  SimpleTest.registerCleanupFunction(UrlClassifierTestUtils.cleanupTestTrackers);
+  SpecialPowers.pushPrefEnv({"set" : [
+    ["privacy.trackingprotection.enabled", true],
+    ["privacy.trackingprotection.pbmode.enabled", false],
+    ["browser.safebrowsing.phishing.enabled", false],
+    ["browser.safebrowsing.malware.enabled", false],
+  ]}, () => {
+     SimpleTest.registerCleanupFunction(UrlClassifierTestUtils.cleanupTestTrackers);
+     UrlClassifierTestUtils.addTestTrackers().then(() => {
+       runTest();
+     });
+  });
+});
+
diff --git a/dom/browser-element/mochitest/browserElement_SendEvent.js b/dom/browser-element/mochitest/browserElement_SendEvent.js
new file mode 100644
index 000000000..a65d6f24f
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_SendEvent.js
@@ -0,0 +1,85 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that sendMouseEvent dispatch events.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+  var iframe = document.createElement("iframe");
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+  var x = 10;
+  var y = 10;
+  // First we force a reflow so that getChildProcessOffset actually returns
+  // meaningful data.
+  iframe.getBoundingClientRect();
+  // We need to make sure the event coordinates are actually inside the iframe,
+  // relative to the chome window.
+  var tabParent = SpecialPowers.wrap(iframe)
+                  .QueryInterface(SpecialPowers.Ci.nsIFrameLoaderOwner)
+                  .frameLoader.tabParent;
+  if (tabParent) {
+    let offsetX = {};
+    let offsetY = {};
+    tabParent.getChildProcessOffset(offsetX, offsetY);
+    x -= offsetX.value;
+    y -= offsetY.value;
+  }
+
+  iframe.addEventListener("mozbrowserloadend", function onloadend(e) {
+    iframe.sendMouseEvent("mousedown", x, y, 0, 1, 0);
+  });
+
+  iframe.addEventListener("mozbrowserlocationchange", function onlocchange(e) {
+    var a = document.createElement("a");
+    a.href = e.detail.url;
+
+    switch (a.hash) {
+      case "#mousedown":
+        ok(true, "Receive a mousedown event.");
+        iframe.sendMouseEvent("mousemove", x, y, 0, 0, 0);
+        break;
+      case "#mousemove":
+        ok(true, "Receive a mousemove event.");
+        iframe.sendMouseEvent("mouseup", x, y, 0, 1, 0);
+        break;
+      case "#mouseup":
+        ok(true, "Receive a mouseup event.");
+        break;
+      case "#click":
+        ok(true, "Receive a click event.");
+        if (SpecialPowers.getIntPref("dom.w3c_touch_events.enabled") != 0) {
+          iframe.sendTouchEvent("touchstart", [1], [x], [y], [2], [2],
+                                [20], [0.5], 1, 0);
+        } else {
+          iframe.removeEventListener('mozbrowserlocationchange', onlocchange);
+          SimpleTest.finish();
+        }
+        break;
+      case "#touchstart":
+        ok(true, "Receive a touchstart event.");
+        iframe.sendTouchEvent("touchmove", [1], [x], [y], [2], [2],
+                              [20], [0.5], 1, 0);
+      case "#touchmove":
+        ok(true, "Receive a touchmove event.");
+        iframe.sendTouchEvent("touchend", [1], [x], [y], [2], [2],
+                              [20], [0.5], 1, 0);
+        break;
+      case "#touchend":
+        ok(true, "Receive a touchend event.");
+        iframe.sendTouchEvent("touchcancel", [1], [x], [y], [2], [2],
+                              [20], [0.5], 1, 0);
+        iframe.removeEventListener('mozbrowserlocationchange', onlocchange);
+        SimpleTest.finish();
+        break;
+    }
+  });
+
+  iframe.src = "file_browserElement_SendEvent.html";
+
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_SetInputMethodActive.js b/dom/browser-element/mochitest/browserElement_SetInputMethodActive.js
new file mode 100644
index 000000000..2b94f5cda
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_SetInputMethodActive.js
@@ -0,0 +1,323 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 905573 - Add setInputMethodActive to browser elements to allow gaia
+// system set the active IME app.
+'use strict';
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+// We'll need to get the appId from the current document,
+// it's either SpecialPowers.Ci.nsIScriptSecurityManager.NO_APP_ID when
+// we are not running inside an app (e.g. Firefox Desktop),
+// or the appId of Mochitest app when we are running inside that app
+// (e.g. Emulator).
+var currentAppId = SpecialPowers.wrap(document).nodePrincipal.appId;
+var inApp =
+  currentAppId !== SpecialPowers.Ci.nsIScriptSecurityManager.NO_APP_ID;
+// We will also need the manifest URL and set it on iframes.
+var currentAppManifestURL;
+
+if (inApp) {
+  let appsService = SpecialPowers.Cc["@mozilla.org/AppsService;1"]
+                      .getService(SpecialPowers.Ci.nsIAppsService);
+
+  currentAppManifestURL = appsService.getManifestURLByLocalId(currentAppId);
+};
+
+info('appId=' + currentAppId);
+info('manifestURL=' + currentAppManifestURL);
+
+function setup() {
+  let appInfo = SpecialPowers.Cc['@mozilla.org/xre/app-info;1']
+                .getService(SpecialPowers.Ci.nsIXULAppInfo);
+  if (appInfo.name != 'B2G') {
+    SpecialPowers.Cu.import("resource://gre/modules/Keyboard.jsm", window);
+  }
+
+  SpecialPowers.setBoolPref("dom.mozInputMethod.enabled", true);
+  SpecialPowers.addPermission('input-manage', true, document);
+}
+
+function tearDown() {
+  SpecialPowers.setBoolPref("dom.mozInputMethod.enabled", false);
+  SpecialPowers.removePermission('input-manage', document);
+  SimpleTest.finish();
+}
+
+function runTest() {
+  createFrames();
+}
+
+var gInputMethodFrames = [];
+var gInputFrame;
+
+function createFrames() {
+  // Create two input method iframes.
+  let loadendCount = 0;
+  let countLoadend = function() {
+    loadendCount++;
+    if (loadendCount === 3) {
+      setPermissions();
+     }
+   };
+
+   // Create an input field to receive string from input method iframes.
+   gInputFrame = document.createElement('iframe');
+   gInputFrame.setAttribute('mozbrowser', 'true');
+   gInputFrame.src = 'file_browserElement_SetInputMethodActive.html';
+   document.body.appendChild(gInputFrame);
+   gInputFrame.addEventListener('mozbrowserloadend', countLoadend);
+
+   for (let i = 0; i < 2; i++) {
+     let frame = gInputMethodFrames[i] = document.createElement('iframe');
+     frame.setAttribute('mozbrowser', 'true');
+     if (currentAppManifestURL) {
+       frame.setAttribute('mozapp', currentAppManifestURL);
+     }
+     frame.addEventListener('mozbrowserloadend', countLoadend);
+     frame.src = 'file_empty.html#' + i;
+     document.body.appendChild(frame);
+   }
+ }
+
+function setPermissions() {
+  let permissions = [{
+    type: 'input',
+    allow: true,
+    context: {
+      url: SimpleTest.getTestFileURL('/file_empty.html'),
+      originAttributes: {
+        appId: currentAppId,
+        inIsolatedMozBrowser: true
+      }
+    }
+  }];
+
+  if (inApp) {
+    // The current document would also need to be given access for IPC to
+    // recognize our permission (why)?
+    permissions.push({
+      type: 'input', allow: true, context: document });
+  }
+
+  SpecialPowers.pushPermissions(permissions,
+    SimpleTest.waitForFocus.bind(SimpleTest, startTest));
+}
+
+ function startTest() {
+  // The frame script running in the frame where the input is hosted.
+  let appFrameScript = function appFrameScript() {
+    let input = content.document.body.firstElementChild;
+    input.oninput = function() {
+      sendAsyncMessage('test:InputMethod:oninput', {
+        from: 'input',
+        value: this.value
+      });
+    };
+
+    input.onblur = function() {
+      // "Expected" lost of focus since the test is finished.
+      if (input.value === 'hello#0#1') {
+        return;
+      }
+
+      sendAsyncMessage('test:InputMethod:oninput', {
+        from: 'input',
+        error: true,
+        value: 'Unexpected lost of focus on the input frame!'
+      });
+    };
+
+    input.focus();
+  };
+
+  // Inject frame script to receive input.
+  let mm = SpecialPowers.getBrowserFrameMessageManager(gInputFrame);
+  mm.loadFrameScript('data:,(' + encodeURIComponent(appFrameScript.toString()) + ')();', false);
+  mm.addMessageListener("test:InputMethod:oninput", next);
+
+  gInputMethodFrames.forEach((frame) => {
+    ok(frame.setInputMethodActive, 'Can access setInputMethodActive.');
+
+    // The frame script running in the input method frames.
+    let appFrameScript = function appFrameScript() {
+      let im = content.navigator.mozInputMethod;
+      im.oninputcontextchange = function() {
+        let ctx = im.inputcontext;
+        // Report back to parent frame on status of ctx gotten.
+        // (A setTimeout() here to ensure this always happens after
+        //  DOMRequest succeed.)
+        content.setTimeout(() => {
+          sendAsyncMessage('test:InputMethod:imFrameMessage', {
+            from: 'im',
+            value: content.location.hash + !!ctx
+          });
+        });
+
+        // If there is a context, send out the hash.
+        if (ctx) {
+          ctx.replaceSurroundingText(content.location.hash);
+        }
+      };
+    };
+
+    // Inject frame script to receive message.
+    let mm = SpecialPowers.getBrowserFrameMessageManager(frame);
+    mm.loadFrameScript('data:,(' + encodeURIComponent(appFrameScript.toString()) + ')();', false);
+    mm.addMessageListener("test:InputMethod:imFrameMessage", next);
+  });
+
+   // Set focus to the input field and wait for input methods' inputting.
+   SpecialPowers.DOMWindowUtils.focus(gInputFrame);
+
+  let req0 = gInputMethodFrames[0].setInputMethodActive(true);
+  req0.onsuccess = function() {
+    ok(true, 'setInputMethodActive succeeded (0).');
+  };
+
+  req0.onerror = function() {
+    ok(false, 'setInputMethodActive failed (0): ' + this.error.name);
+  };
+}
+
+var gCount = 0;
+
+var gFrameMsgCounts = {
+  'input': 0,
+  'im0': 0,
+  'im1': 0
+};
+
+function next(msg) {
+  let wrappedMsg = SpecialPowers.wrap(msg);
+  let from = wrappedMsg.data.from;
+  let value = wrappedMsg.data.value;
+
+  if (wrappedMsg.data.error) {
+    ok(false, wrappedMsg.data.value);
+
+    return;
+  }
+
+  let fromId = from;
+  if (from === 'im') {
+    fromId += value[1];
+  }
+  gFrameMsgCounts[fromId]++;
+
+  // The texts sent from the first and the second input method are '#0' and
+  // '#1' respectively.
+  switch (gCount) {
+    case 0:
+      switch (fromId) {
+        case 'im0':
+          if (gFrameMsgCounts.im0 === 1) {
+            is(value, '#0true', 'First frame should get the context first.');
+          } else {
+            ok(false, 'Unexpected multiple messages from im0.')
+          }
+
+          break;
+
+        case 'im1':
+          is(false, 'Shouldn\'t be hearing anything from second frame.');
+
+          break;
+
+        case 'input':
+          if (gFrameMsgCounts.input === 1) {
+            is(value, '#0hello',
+              'Failed to get correct input from the first iframe.');
+          } else {
+            ok(false, 'Unexpected multiple messages from input.')
+          }
+
+          break;
+      }
+
+      if (gFrameMsgCounts.input !== 1 ||
+          gFrameMsgCounts.im0 !== 1 ||
+          gFrameMsgCounts.im1 !== 0) {
+        return;
+      }
+
+      gCount++;
+
+      let req0 = gInputMethodFrames[0].setInputMethodActive(false);
+      req0.onsuccess = function() {
+        ok(true, 'setInputMethodActive succeeded (0).');
+      };
+      req0.onerror = function() {
+        ok(false, 'setInputMethodActive failed (0): ' + this.error.name);
+      };
+      let req1 = gInputMethodFrames[1].setInputMethodActive(true);
+      req1.onsuccess = function() {
+        ok(true, 'setInputMethodActive succeeded (1).');
+      };
+      req1.onerror = function() {
+        ok(false, 'setInputMethodActive failed (1): ' + this.error.name);
+      };
+
+      break;
+
+    case 1:
+      switch (fromId) {
+        case 'im0':
+          if (gFrameMsgCounts.im0 === 2) {
+            is(value, '#0false', 'First frame should have the context removed.');
+          } else {
+            ok(false, 'Unexpected multiple messages from im0.')
+          }
+          break;
+
+        case 'im1':
+          if (gFrameMsgCounts.im1 === 1) {
+            is(value, '#1true', 'Second frame should get the context.');
+          } else {
+            ok(false, 'Unexpected multiple messages from im0.')
+          }
+
+          break;
+
+        case 'input':
+          if (gFrameMsgCounts.input === 2) {
+            is(value, '#0#1hello',
+               'Failed to get correct input from the second iframe.');
+          } else {
+            ok(false, 'Unexpected multiple messages from input.')
+          }
+          break;
+      }
+
+      if (gFrameMsgCounts.input !== 2 ||
+          gFrameMsgCounts.im0 !== 2 ||
+          gFrameMsgCounts.im1 !== 1) {
+        return;
+      }
+
+      gCount++;
+
+      // Receive the second input from the second iframe.
+      // Deactive the second iframe.
+      let req3 = gInputMethodFrames[1].setInputMethodActive(false);
+      req3.onsuccess = function() {
+        ok(true, 'setInputMethodActive(false) succeeded (2).');
+      };
+      req3.onerror = function() {
+        ok(false, 'setInputMethodActive(false) failed (2): ' + this.error.name);
+      };
+      break;
+
+    case 2:
+      is(fromId, 'im1', 'Message sequence unexpected (3).');
+      is(value, '#1false', 'Second frame should have the context removed.');
+
+      tearDown();
+      break;
+  }
+}
+
+setup();
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_SetVisible.js b/dom/browser-element/mochitest/browserElement_SetVisible.js
new file mode 100644
index 000000000..dac8d7e42
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_SetVisible.js
@@ -0,0 +1,75 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test the setVisible property for mozbrowser
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("untriaged");
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframeScript = function() {
+  content.document.addEventListener("visibilitychange", function() {
+    sendAsyncMessage('test:visibilitychange', {
+      hidden: content.document.hidden
+    });
+  }, false);
+}
+
+function runTest() {
+  var mm;
+  var numEvents = 0;
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  iframe1.src = 'data:text/html,1';
+
+  document.body.appendChild(iframe1);
+
+  function recvVisibilityChanged(msg) {
+    msg = SpecialPowers.wrap(msg);
+    numEvents++;
+    if (numEvents === 1) {
+      ok(true, 'iframe recieved visibility changed');
+      ok(msg.json.hidden === true, 'hidden attribute correctly set');
+      iframe1.setVisible(false);
+      iframe1.setVisible(true);
+    } else if (numEvents === 2) {
+      ok(msg.json.hidden === false, 'hidden attribute correctly set');
+      // Allow some time in case we generate too many events
+      setTimeout(function() {
+        mm.removeMessageListener('test:visibilitychange', recvVisibilityChanged);
+        SimpleTest.finish();
+      }, 100);
+    } else {
+      ok(false, 'Too many visibilitychange events');
+    }
+  }
+
+  function iframeLoaded() {
+    testGetVisible();
+  }
+
+  function testGetVisible() {
+    iframe1.setVisible(false);
+    iframe1.getVisible().onsuccess = function(evt) {
+      ok(evt.target.result === false, 'getVisible() responds false after setVisible(false)');
+
+      iframe1.setVisible(true);
+      iframe1.getVisible().onsuccess = function(evt) {
+        ok(evt.target.result === true, 'getVisible() responds true after setVisible(true)');
+        testVisibilityChanges();
+      };
+    };
+  }
+
+  function testVisibilityChanges() {
+    mm = SpecialPowers.getBrowserFrameMessageManager(iframe1);
+    mm.addMessageListener('test:visibilitychange', recvVisibilityChanged);
+    mm.loadFrameScript('data:,(' + iframeScript.toString() + ')();', false);
+    iframe1.setVisible(false);
+  }
+
+  iframe1.addEventListener('mozbrowserloadend', iframeLoaded);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_SetVisibleFrames.js b/dom/browser-element/mochitest/browserElement_SetVisibleFrames.js
new file mode 100644
index 000000000..721248ab9
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_SetVisibleFrames.js
@@ -0,0 +1,89 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 762939 - Test that visibility propagates down properly through
+// hierarchies of <iframe mozbrowser>.
+//
+// In this test, we modify the parent's visibility and check that the child's
+// visibility is changed as appopriate.  We test modifying the child's
+// visibility in a separate testcase.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframe;
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  // Our test involves three <iframe mozbrowser>'s, parent, child1, and child2.
+  // child1 and child2 are contained inside parent.  child1 is visibile, and
+  // child2 is not.
+  //
+  // For the purposes of this test, we want there to be a process barrier
+  // between child{1,2} and parent.  Therefore parent must be a non-remote
+  // <iframe mozbrowser>, until bug 761935 is resolved and we can have nested
+  // content processes.
+  iframe.remote = false;
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', checkMessage);
+  expectMessage('parent:ready', test1);
+
+  document.body.appendChild(iframe);
+  iframe.src = 'file_browserElement_SetVisibleFrames_Outer.html';
+}
+
+function test1() {
+  expectMessage('child1:hidden', getVisibleTest1);
+  iframe.setVisible(false);
+}
+
+function getVisibleTest1() {
+  iframe.getVisible().onsuccess = function(evt) {
+    ok(evt.target.result === false, 'getVisible shows a hidden frame');
+    test2();
+  };
+}
+
+function test2() {
+  expectMessage('child1:visible', getVisibleTest2);
+  iframe.setVisible(true);
+}
+
+function getVisibleTest2() {
+  iframe.getVisible().onsuccess = function(evt) {
+    ok(evt.target.result === true, 'getVisible shows a displayed frame');
+    finish();
+  };
+}
+
+function finish() {
+  // We need to remove this listener because when this test finishes and the
+  // iframe containing this document is navigated, we'll fire a
+  // visibilitychange(false) event on all child iframes.  That's OK and
+  // expected, but if we don't remove our listener, then we'll end up causing
+  // the /next/ test to fail!
+  iframe.removeEventListener('mozbrowsershowmodalprompt', checkMessage);
+  SimpleTest.finish();
+}
+
+var expectedMsg = null;
+var expectedMsgCallback = null;
+function expectMessage(msg, next) {
+  expectedMsg = msg;
+  expectedMsgCallback = next;
+}
+
+function checkMessage(e) {
+  var msg = e.detail.message;
+  is(msg, expectedMsg);
+  if (msg == expectedMsg) {
+    expectedMsg = null;
+    SimpleTest.executeSoon(function() { expectedMsgCallback() });
+  }
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_SetVisibleFrames2.js b/dom/browser-element/mochitest/browserElement_SetVisibleFrames2.js
new file mode 100644
index 000000000..cf841a470
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_SetVisibleFrames2.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 762939 - Test that setting a <iframe mozbrowser> to invisible / visible
+// inside an invisible <iframe mozbrowser> doesn't trigger any events.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  // We need remote = false here until bug 761935 is fixed; see
+  // SetVisibleFrames.js for an explanation.
+  iframe.remote = false;
+
+  iframe.addEventListener('mozbrowserloadend', function loadEnd(e) {
+    iframe.removeEventListener('mozbrowserloadend', loadEnd);
+    iframe.setVisible(false);
+    iframe.src = 'file_browserElement_SetVisibleFrames2_Outer.html';
+  });
+
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    if (e.detail.message == 'parent:finish') {
+      ok(true, "Got parent:finish");
+
+      // Give any extra events a chance to fire, then end the test.
+      SimpleTest.executeSoon(function() {
+        SimpleTest.executeSoon(function() {
+          SimpleTest.executeSoon(function() {
+            SimpleTest.executeSoon(function() {
+              SimpleTest.executeSoon(function() {
+                finish();
+              });
+            });
+          });
+        });
+      });
+    }
+    else {
+      ok(false, "Got unexpected message: " + e.detail.message);
+    }
+  });
+
+  document.body.appendChild(iframe);
+}
+
+function finish() {
+  SimpleTest.finish();
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Stop.js b/dom/browser-element/mochitest/browserElement_Stop.js
new file mode 100644
index 000000000..67720c148
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Stop.js
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 709759 - Test the stop ability of <iframe mozbrowser>.
+
+// The img that is loaded will never be returned and will block
+// the page from loading, the timeout ensures that the page is
+// actually blocked from loading, once stop is called the
+// image load will be cancaelled and mozbrowserloadend should be called.
+
+"use strict";
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("untriaged");
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframe;
+var stopped = false;
+var imgSrc = 'http://test/tests/dom/browser-element/mochitest/file_bug709759.sjs';
+
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  // FIXME: Bug 1270790
+  iframe.setAttribute('remote', 'true');
+  iframe.addEventListener('mozbrowserloadend', loadend);
+  iframe.src = 'data:text/html,<html>' +
+    '<body><img src="' + imgSrc + '" /></body></html>';
+
+  document.body.appendChild(iframe);
+
+  setTimeout(function() {
+    stopped = true;
+    iframe.stop();
+  }, 200);
+}
+
+function loadend() {
+  ok(stopped, 'Iframes network connections were stopped');
+
+  // Wait 1 second and make sure there isn't a mozbrowsererror after stop();
+  iframe.addEventListener('mozbrowsererror', handleError);
+  window.setTimeout(function() {
+    iframe.removeEventListener('mozbrowsererror', handleError);
+    SimpleTest.finish();
+  }, 1000);
+}
+
+function handleError() {
+  ok(false, "mozbrowsererror should not be fired");
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_TargetBlank.js b/dom/browser-element/mochitest/browserElement_TargetBlank.js
new file mode 100644
index 000000000..89c2f33c1
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_TargetBlank.js
@@ -0,0 +1,26 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 764718 - Test that clicking a link with _target=blank works.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    is(e.detail.url, 'http://example.com/');
+    e.preventDefault();
+    SimpleTest.finish();
+  });
+
+  iframe.src = "file_browserElement_TargetBlank.html";
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_TargetTop.js b/dom/browser-element/mochitest/browserElement_TargetTop.js
new file mode 100644
index 000000000..54bad9c42
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_TargetTop.js
@@ -0,0 +1,31 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 771273 - Check that window.open(url, '_top') works properly with <iframe
+// mozbrowser>.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  iframe.addEventListener('mozbrowseropenwindow', function(e) {
+    ok(false, 'Not expecting an openwindow event.');
+  });
+
+  iframe.addEventListener('mozbrowserlocationchange', function(e) {
+    if (/file_browserElement_TargetTop.html\?2$/.test(e.detail.url)) {
+      ok(true, 'Got the locationchange we were looking for.');
+      SimpleTest.finish();
+    }
+  });
+
+  document.body.appendChild(iframe);
+  iframe.src = 'file_browserElement_TargetTop.html';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_ThemeColor.js b/dom/browser-element/mochitest/browserElement_ThemeColor.js
new file mode 100644
index 000000000..01e9c5c36
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_ThemeColor.js
@@ -0,0 +1,85 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the onmozbrowsermetachange event for theme-color works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  function loadFrameScript(script) {
+    SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                 .loadFrameScript("data:," + script,
+                                  /* allowDelayedLoad = */ false);
+  }
+
+  let iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  iframe1.src = "http://test/tests/dom/browser-element/mochitest/file_browserElement_ThemeColor.html";
+  iframe1.addEventListener('mozbrowsermetachange', tests);
+  document.body.appendChild(iframe1);
+
+  let numMetaChanges = 0;
+  function tests(e) {
+    let detail = e.detail;
+
+    switch (numMetaChanges++) {
+      case 0: {
+        is(detail.name, 'theme-color', 'name matches');
+        is(detail.content, 'pink', 'content matches');
+        is(detail.type, 'added', 'type matches');
+
+        let script =
+          "var meta = content.document.head.querySelector('meta');" +
+          "meta.content = 'green';";
+        loadFrameScript(script);
+        break;
+      }
+
+      case 1: {
+        is(detail.name, 'theme-color', 'name matches');
+        is(detail.content, 'green', 'content matches');
+        is(detail.type, 'changed', 'type matches');
+
+        let script =
+          "var meta = content.document.createElement('meta');" +
+          "meta.name = 'theme-group';" +
+          "meta.content = 'theme-productivity';" +
+          "content.document.head.appendChild(meta)";
+        loadFrameScript(script);
+        break;
+      }
+
+      case 2: {
+        is(detail.name, 'theme-group', 'name matches');
+        is(detail.content, 'theme-productivity', 'content matches');
+        is(detail.type, 'added', 'type matches');
+
+        let script =
+          "var meta = content.document.head.querySelector('meta');" +
+          "meta.parentNode.removeChild(meta);";
+        loadFrameScript(script);
+        break;
+      }
+
+      case 3: {
+        is(detail.name, 'theme-color', 'name matches');
+        is(detail.content, 'green', 'content matches');
+        is(detail.type, 'removed', 'type matches');
+
+        SimpleTest.finish();
+        break;
+      }
+
+      default: {
+        ok(false, 'Too many metachange events.');
+        break;
+      }
+    }
+  };
+}
+
+window.addEventListener('testready', runTest);
+
diff --git a/dom/browser-element/mochitest/browserElement_Titlechange.js b/dom/browser-element/mochitest/browserElement_Titlechange.js
new file mode 100644
index 000000000..78c939ad8
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Titlechange.js
@@ -0,0 +1,68 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the onmozbrowsertitlechange event works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe1);
+
+  // iframe2 is a red herring; we modify its title but don't listen for
+  // titlechanges; we want to make sure that its titlechange events aren't
+  // picked up by the listener on iframe1.
+  var iframe2 = document.createElement('iframe');
+  iframe2.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe2);
+
+  // iframe3 is another red herring.  It's not a mozbrowser, so we shouldn't
+  // get any titlechange events on it.
+  var iframe3 = document.createElement('iframe');
+  document.body.appendChild(iframe3);
+
+  var numTitleChanges = 0;
+
+  iframe1.addEventListener('mozbrowsertitlechange', function(e) {
+    // Ignore empty titles; these come from about:blank.
+    if (e.detail == '')
+      return;
+
+    numTitleChanges++;
+
+    if (numTitleChanges == 1) {
+      is(e.detail, 'Title');
+      SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                   .loadFrameScript("data:,content.document.title='New title';",
+                                    /* allowDelayedLoad = */ false);
+      SpecialPowers.getBrowserFrameMessageManager(iframe2)
+                   .loadFrameScript("data:,content.document.title='BAD TITLE 2';",
+                                    /* allowDelayedLoad = */ false);
+    }
+    else if (numTitleChanges == 2) {
+      is(e.detail, 'New title');
+      iframe1.src = 'data:text/html,<html><head><title>Title 3</title></head><body></body></html>';
+    }
+    else if (numTitleChanges == 3) {
+      is(e.detail, 'Title 3');
+      SimpleTest.finish();
+    }
+    else {
+      ok(false, 'Too many titlechange events.');
+    }
+  });
+
+  iframe3.addEventListener('mozbrowsertitlechange', function(e) {
+    ok(false, 'Should not get a titlechange event for iframe3.');
+  });
+
+  iframe1.src = 'data:text/html,<html><head><title>Title</title></head><body></body></html>';
+  iframe2.src = 'data:text/html,<html><head><title>BAD TITLE</title></head><body></body></html>';
+  iframe3.src = 'data:text/html,<html><head><title>SHOULD NOT GET EVENT</title></head><body></body></html>';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_TopBarrier.js b/dom/browser-element/mochitest/browserElement_TopBarrier.js
new file mode 100644
index 000000000..3bd68854c
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_TopBarrier.js
@@ -0,0 +1,81 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that an <iframe mozbrowser> is a window.{top,parent,frameElement} barrier.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var iframe;
+function runTest() {
+  iframe = document.createElement('iframe');
+  iframe.addEventListener('mozbrowserloadend', function() {
+    try {
+      outerIframeLoaded();
+    } catch(e) {
+      dump("Got error: " + e + '\n');
+    }
+  });
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.src = 'data:text/html,Outer iframe <iframe id="inner-iframe"></iframe>';
+  // For kicks, this test uses a display:none iframe.  This shouldn't make a
+  // difference in anything.
+  iframe.style.display = 'none';
+  document.body.appendChild(iframe);
+}
+
+var numMsgReceived = 0;
+function outerIframeLoaded() {
+  // If you're changing the amount of is() calls in injectedScript,
+  // also change the number in waitForMessages accordingly
+  var injectedScript =
+    "data:,function is(a, b, desc) {                                     \
+      if (a == b) {                                                      \
+        sendAsyncMessage('test:test-pass', desc);                        \
+      } else {                                                           \
+        sendAsyncMessage('test:test-fail', desc + ' ' + a + ' != ' + b); \
+      }                                                                  \
+    }                                                                    \
+    is(content.window.top, content.window, 'top');                       \
+    is(content.window.content, content.window, 'content');               \
+    is(content.window.parent, content.window, 'parent');                 \
+    is(content.window.frameElement, null, 'frameElement');               \
+    var innerIframe = content.document.getElementById('inner-iframe');   \
+    var innerWindow = innerIframe.contentWindow;                         \
+    is(innerWindow.top, content.window, 'inner top');                    \
+    is(innerWindow.content, content.window, 'inner content');            \
+    is(innerWindow.parent, content.window, 'inner parent');              \
+    is(innerWindow.frameElement, innerIframe, 'inner frameElement');"
+
+  var mm = SpecialPowers.getBrowserFrameMessageManager(iframe);
+
+  function onRecvTestPass(msg) {
+    numMsgReceived++;
+    ok(true, msg.json);
+  }
+  mm.addMessageListener('test:test-pass', onRecvTestPass);
+
+  function onRecvTestFail(msg) {
+    numMsgReceived++;
+    ok(false, msg.json);
+  }
+  mm.addMessageListener('test:test-fail', onRecvTestFail);
+
+  mm.loadFrameScript(injectedScript, /* allowDelayedLoad = */ false);
+
+  // 8 is the number of is() calls in injectedScript
+  waitForMessages(8);
+}
+
+function waitForMessages(num) {
+  if (numMsgReceived < num) {
+    SimpleTest.executeSoon(function() { waitForMessages(num); });
+    return;
+  }
+
+  SimpleTest.finish();
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_Viewmode.js b/dom/browser-element/mochitest/browserElement_Viewmode.js
new file mode 100644
index 000000000..51627d9a8
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_Viewmode.js
@@ -0,0 +1,71 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the onmozbrowsermetachange event for viewmode works.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  function loadFrameScript(script) {
+    SpecialPowers.getBrowserFrameMessageManager(iframe1)
+                 .loadFrameScript('data:,' + script,
+                                  /* allowDelayedLoad = */ false);
+  }
+
+  let iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  iframe1.src = "http://test/tests/dom/browser-element/mochitest/file_browserElement_Viewmode.html";
+  iframe1.addEventListener('mozbrowsermetachange', tests);
+  document.body.appendChild(iframe1);
+
+  let numMetaChanges = 0;
+  function tests(e) {
+    let detail = e.detail;
+
+    switch (numMetaChanges++) {
+      case 0: {
+        is(detail.name, 'viewmode', 'name matches');
+        is(detail.content, 'projection=stereo', 'content matches');
+        is(detail.type, 'added', 'type matches');
+
+        let script =
+          "var meta = content.document.head.querySelector('meta');" +
+          "meta.content = 'projection=mono';";
+        loadFrameScript(script);
+        break;
+      }
+
+      case 1: {
+        is(detail.name, 'viewmode', 'name matches');
+        is(detail.content, 'projection=mono', 'content matches');
+        is(detail.type, 'changed', 'type matches');
+
+        let script =
+          "var meta = content.document.head.querySelector('meta');" +
+          "meta.parentNode.removeChild(meta);";
+        loadFrameScript(script);
+        break;
+      }
+
+      case 2: {
+        is(detail.name, 'viewmode', 'name matches');
+        is(detail.content, 'projection=mono', 'content matches');
+        is(detail.type, 'removed', 'type matches');
+
+        SimpleTest.finish();
+        break;
+      }
+
+      default: {
+        ok(false, 'Too many metachange events.');
+        break;
+      }
+    }
+  };
+}
+
+window.addEventListener('testready', runTest);
+
diff --git a/dom/browser-element/mochitest/browserElement_VisibilityChange.js b/dom/browser-element/mochitest/browserElement_VisibilityChange.js
new file mode 100644
index 000000000..d7db5f45d
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_VisibilityChange.js
@@ -0,0 +1,42 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test that the onmozbrowservisibilitychange event works.
+'use strict';
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+var iframe1 = null;
+function runTest() {
+  iframe1 = document.createElement('iframe');
+  iframe1.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe1);
+
+  iframe1.src = 'data:text/html,<html><head><title>Title</title></head><body></body></html>';
+  checkVisibilityFalse();
+}
+
+function checkVisibilityFalse() {
+  iframe1.addEventListener('mozbrowservisibilitychange', function onvisibilitychange(e) {
+    iframe1.removeEventListener(e.type, onvisibilitychange);
+
+    is(e.detail.visible, false, 'Visibility should be false');
+    checkVisibilityTrue();
+  });
+
+  iframe1.setVisible(false);
+}
+
+function checkVisibilityTrue() {
+  iframe1.addEventListener('mozbrowservisibilitychange', function onvisibilitychange(e) {
+    iframe1.removeEventListener(e.type, onvisibilitychange);
+
+    is(e.detail.visible, true, 'Visibility should be true');
+    SimpleTest.finish();
+  });
+
+  iframe1.setVisible(true);
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_XFrameOptions.js b/dom/browser-element/mochitest/browserElement_XFrameOptions.js
new file mode 100644
index 000000000..391c2cb95
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_XFrameOptions.js
@@ -0,0 +1,26 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 770239 - Test that we can load pages with X-Frame-Options: Deny inside
+// <iframe mozbrowser>.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  // The page we load will fire an alert when it successfully loads.
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    ok(true, "Got alert");
+    SimpleTest.finish();
+  });
+
+  document.body.appendChild(iframe);
+  iframe.src = 'file_browserElement_XFrameOptions.sjs?DENY';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_XFrameOptionsAllowFrom.js b/dom/browser-element/mochitest/browserElement_XFrameOptionsAllowFrom.js
new file mode 100644
index 000000000..3657d9732
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_XFrameOptionsAllowFrom.js
@@ -0,0 +1,60 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 690168 - Support Allow-From notation for X-Frame-Options header.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var initialScreenshotArrayBuffer = null;
+
+function arrayBuffersEqual(a, b) {
+  var x = new Int8Array(a);
+  var y = new Int8Array(b);
+  if (x.length != y.length) {
+    return false;
+  }
+
+  for (var i = 0; i < x.length; i++) {
+    if (x[i] != y[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function runTest() {
+  var count = 0;
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.height = '1000px';
+
+  var step1, stepfinish;
+  // The innermost page we load will fire an alert when it successfully loads.
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    switch (e.detail.message) {
+    case 'step 1':
+      step1 = SpecialPowers.snapshotWindow(iframe.contentWindow);
+      break;
+    case 'step 2':
+      ok(false, 'cross origin page loaded');
+      break;
+    case 'finish':
+      // The page has now attempted to load the X-Frame-Options page; take
+      // another screenshot.
+      stepfinish = SpecialPowers.snapshotWindow(iframe.contentWindow);
+      ok(step1.toDataURL() == stepfinish.toDataURL(), "Screenshots should be identical");
+      SimpleTest.finish();
+    }
+  });
+
+  document.body.appendChild(iframe);
+
+  iframe.src = 'http://example.com/tests/dom/browser-element/mochitest/file_browserElement_XFrameOptionsAllowFrom.html';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_XFrameOptionsDeny.js b/dom/browser-element/mochitest/browserElement_XFrameOptionsDeny.js
new file mode 100644
index 000000000..bf307cc19
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_XFrameOptionsDeny.js
@@ -0,0 +1,63 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 770239 - Test that X-Frame-Options will correctly block a page inside a
+// subframe of <iframe mozbrowser>.
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+var initialScreenshotArrayBuffer;
+
+function arrayBuffersEqual(a, b) {
+  var x = new Int8Array(a);
+  var y = new Int8Array(b);
+  if (x.length != y.length) {
+    return false;
+  }
+
+  for (var i = 0; i < x.length; i++) {
+    if (x[i] != y[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  // Our child will create two iframes, so make sure this iframe is big enough
+  // to show both of them without scrolling, so taking a screenshot gets both
+  // frames.
+  iframe.height = '1000px';
+
+  var step1, stepfinish;
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    switch (e.detail.message) {
+    case 'step 1':
+      step1 = SpecialPowers.snapshotWindow(iframe.contentWindow);
+      break;
+    case 'step 2':
+      // The page has now attempted to load the X-Frame-Options page; take
+      // another screenshot.
+      stepfinish = SpecialPowers.snapshotWindow(iframe.contentWindow);
+      ok(step1.toDataURL() == stepfinish.toDataURL(), "Screenshots should be identical");
+      SimpleTest.finish();
+      break;
+    }
+  });
+
+  document.body.appendChild(iframe);
+
+  // Load this page from a different origin than ourselves.  This page will, in
+  // turn, load a child from mochi.test:8888, our origin, with X-Frame-Options:
+  // SAMEORIGIN.  That load should be denied.
+  iframe.src = 'http://example.com/tests/dom/browser-element/mochitest/file_browserElement_XFrameOptionsDeny.html';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_XFrameOptionsSameOrigin.js b/dom/browser-element/mochitest/browserElement_XFrameOptionsSameOrigin.js
new file mode 100644
index 000000000..35e4ca8f0
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_XFrameOptionsSameOrigin.js
@@ -0,0 +1,28 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Bug 770239 - Load an X-Frame-Options: SAMEORIGIN page inside an <iframe>
+// inside <iframe mozbrowser>.  The two iframes will have the same origin, but
+// this page will be of a different origin.  The load should succeed.
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+
+  // The innermost page we load will fire an alert when it successfully loads.
+  iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+    ok(true, "Got alert");
+    SimpleTest.finish();
+  });
+
+  document.body.appendChild(iframe);
+  iframe.src = 'http://example.com/tests/dom/browser-element/mochitest/file_browserElement_XFrameOptionsSameOrigin.html';
+}
+
+addEventListener('testready', runTest);
diff --git a/dom/browser-element/mochitest/browserElement_getWebManifest.js b/dom/browser-element/mochitest/browserElement_getWebManifest.js
new file mode 100644
index 000000000..c2b8f96f3
--- /dev/null
+++ b/dom/browser-element/mochitest/browserElement_getWebManifest.js
@@ -0,0 +1,64 @@
+/* Any copyright is dedicated to the public domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+/*globals async, ok, is, SimpleTest, browserElementTestHelpers*/
+
+// Bug 1169633 - getWebManifest tests
+'use strict';
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+
+// request to load a manifest from a page that doesn't have a manifest.
+// The expected result to be null.
+var test1 = async(function* () {
+  var manifest = yield requestManifest('file_empty.html');
+  is(manifest, null, 'it should be null.');
+});
+
+// request to load a manifest from a page that has a manifest.
+// The expected manifest to have a property name whose value is 'pass'.
+var test2 = async(function* () {
+  var manifest = yield requestManifest('file_web_manifest.html');
+  is(manifest && manifest.name, 'pass', 'it should return a manifest with name pass.');
+});
+
+// Cause an exception by attempting to fetch a file URL,
+// expect onerror to be called.
+var test3 = async(function* () {
+  var gotError = false;
+  try {
+    yield requestManifest('file_illegal_web_manifest.html');
+  } catch (err) {
+    gotError = true;
+  }
+  ok(gotError, 'onerror was called on the DOMRequest.');
+});
+
+// Run the tests
+addEventListener('testready', () => {
+  Promise
+    .all([test1(), test2(), test3()])
+    .then(SimpleTest.finish);
+});
+
+function requestManifest(url) {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  iframe.src = url;
+  document.body.appendChild(iframe);
+  return new Promise((resolve, reject) => {
+    iframe.addEventListener('mozbrowserloadend', function loadend() {
+      iframe.removeEventListener('mozbrowserloadend', loadend);
+      SimpleTest.executeSoon(() => {
+        var req = iframe.getWebManifest();
+        req.onsuccess = () => {
+          document.body.removeChild(iframe);
+          resolve(req.result);
+        };
+        req.onerror = () => {
+          document.body.removeChild(iframe);
+          reject(new Error(req.error));
+        };
+      });
+    });
+  });
+}
diff --git a/dom/browser-element/mochitest/chrome.ini b/dom/browser-element/mochitest/chrome.ini
new file mode 100644
index 000000000..2b0561df8
--- /dev/null
+++ b/dom/browser-element/mochitest/chrome.ini
@@ -0,0 +1,92 @@
+[DEFAULT]
+skip-if = e10s || toolkit == 'android' # Bug 1287720: takes too long on android
+
+support-files =
+  audio.ogg
+  async.js
+  browserElementTestHelpers.js
+  browserElement_ActiveStateChange.js
+  browserElement_AudioChannelSeeking.js
+  browserElement_AudioChannelMutedByDefault.js
+  browserElement_AudioPlayback.js
+  browserElement_AudioChannel.js
+  browserElement_AudioChannel_nested.js
+  browserElement_BackForward.js
+  browserElement_BadScreenshot.js
+  browserElement_DocumentFirstPaint.js
+  browserElement_DOMRequestError.js
+  browserElement_ExecuteScript.js
+  browserElement_Find.js
+  browserElement_GetContentDimensions.js
+  browserElement_GetScreenshot.js
+  browserElement_GetScreenshotDppx.js
+  browserElement_getWebManifest.js
+  browserElement_NextPaint.js
+  browserElement_NoAudioTrack.js
+  browserElement_PurgeHistory.js
+  browserElement_ReloadPostRequest.js
+  browserElement_SendEvent.js
+  browserElement_SetInputMethodActive.js
+  browserElement_SetVisible.js
+  browserElement_SetVisibleFrames.js
+  browserElement_SetVisibleFrames2.js
+  browserElement_Stop.js
+  browserElement_VisibilityChange.js
+  file_audio.html
+  file_browserElement_ActiveStateChange.html
+  file_browserElement_AudioChannelSeeking.html
+  file_browserElement_AudioChannel_nested.html
+  file_browserElement_AudioChannelMutedByDefault.html
+  file_browserElement_ExecuteScript.html
+  file_browserElement_NextPaint.html
+  file_browserElement_NoAudioTrack.html
+  file_browserElement_SendEvent.html
+  file_browserElement_SetInputMethodActive.html
+  file_browserElement_SetVisibleFrames2_Outer.html
+  file_browserElement_SetVisibleFrames_Inner.html
+  file_browserElement_SetVisibleFrames_Outer.html
+  file_bug709759.sjs
+  file_empty.html
+  file_post_request.html
+  file_web_manifest.html
+  file_web_manifest.json
+  file_illegal_web_manifest.html
+  iframe_file_audio.html
+
+[test_browserElement_inproc_ActiveStateChange.html]
+tags = audiochannel
+[test_browserElement_inproc_AudioChannelMutedByDefault.html]
+tags = audiochannel
+skip-if = toolkit == 'android'
+[test_browserElement_inproc_AudioChannelSeeking.html]
+tags = audiochannel
+[test_browserElement_inproc_AudioPlayback.html]
+[test_browserElement_inproc_AudioChannel.html]
+tags = audiochannel
+[test_browserElement_inproc_AudioChannel_nested.html]
+tags = audiochannel
+[test_browserElement_inproc_BackForward.html]
+[test_browserElement_inproc_BadScreenshot.html]
+[test_browserElement_inproc_DocumentFirstPaint.html]
+[test_browserElement_inproc_DOMRequestError.html]
+[test_browserElement_inproc_ExecuteScript.html]
+[test_browserElement_inproc_Find.html]
+[test_browserElement_inproc_GetContentDimensions.html]
+[test_browserElement_inproc_GetScreenshot.html]
+[test_browserElement_inproc_GetScreenshotDppx.html]
+[test_browserElement_inproc_getWebManifest.html]
+[test_browserElement_inproc_NextPaint.html]
+[test_browserElement_inproc_NoAudioTrack.html]
+tags = audiochannel
+[test_browserElement_inproc_PurgeHistory.html]
+[test_browserElement_inproc_ReloadPostRequest.html]
+disabled = no modal prompt on POST reload for chrome window
+[test_browserElement_inproc_SendEvent.html]
+# The setInputMethodActive() tests will timed out on Android
+[test_browserElement_inproc_SetInputMethodActive.html]
+skip-if = true
+[test_browserElement_inproc_SetVisible.html]
+[test_browserElement_inproc_SetVisibleFrames.html]
+[test_browserElement_inproc_SetVisibleFrames2.html]
+[test_browserElement_inproc_Stop.html]
+[test_browserElement_inproc_VisibilityChange.html]
diff --git a/dom/browser-element/mochitest/createNewTest.py b/dom/browser-element/mochitest/createNewTest.py
new file mode 100644
index 000000000..309ff9534
--- /dev/null
+++ b/dom/browser-element/mochitest/createNewTest.py
@@ -0,0 +1,126 @@
+"""A script to generate the browser-element test boilerplate.
+
+This script requires Python 2.7."""
+
+from __future__ import print_function
+
+import sys
+import os
+import stat
+import argparse
+import textwrap
+import subprocess
+
+html_template = textwrap.dedent("""\
+    <!DOCTYPE HTML>
+    <html>
+    <head>
+      <title>Test for Bug {bug}</title>
+      <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+      <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+      <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+    </head>
+    <body>
+    <script type="application/javascript;version=1.7" src="browserElement_{test}.js">
+    </script>
+    </body>
+    </html>""")
+
+# Note: Curly braces are escaped as "{{".
+js_template = textwrap.dedent("""\
+    /* Any copyright is dedicated to the public domain.
+       http://creativecommons.org/publicdomain/zero/1.0/ */
+
+    // Bug {bug} - FILL IN TEST DESCRIPTION
+    "use strict";
+
+    SimpleTest.waitForExplicitFinish();
+    browserElementTestHelpers.setEnabledPref(true);
+    browserElementTestHelpers.addPermission();
+
+    function runTest() {{
+      var iframe = document.createElement('iframe');
+      iframe.setAttribute('mozbrowser', 'true');
+
+      // FILL IN TEST
+
+      document.body.appendChild(iframe);
+    }}
+
+    addEventListener('testready', runTest);
+    """)
+
+def print_fill(s):
+    print(textwrap.fill(textwrap.dedent(s)))
+
+def add_to_ini(filename, test, support_file=None):
+    """Add test to mochitest config {filename}, then open
+    $EDITOR and let the user move the filenames to their appropriate
+    places in the file.
+
+    """
+    lines_to_write = ['[{0}]'.format(test)]
+    if support_file:
+        lines_to_write += ['support-files = {0}'.format(support_file)]
+    lines_to_write += ['']
+    with open(filename, 'a') as f:
+        f.write('\n'.join(lines_to_write))
+
+    if 'EDITOR' not in os.environ or not os.environ['EDITOR']:
+        print_fill("""\
+            Now open {filename} and move the filenames to their correct places.")
+            (Define $EDITOR and I'll open your editor for you next time.)""".format(filename=filename))
+        return
+
+    # Count the number of lines in the file
+    with open(filename, 'r') as f:
+        num_lines = len(f.readlines())
+
+    try:
+        subprocess.call([os.environ['EDITOR'],
+                         '+%d' % (num_lines - len(lines_to_write) + 2),
+                         filename])
+    except Exception as e:
+        print_fill("Error opening $EDITOR: {0}.".format(e))
+        print()
+        print_fill("""\
+            Please open {filename} and move the filenames at the bottom of the
+            file to their correct places.""".format(filename=filename))
+
+def main(test_name, bug_number):
+    global html_template, js_template
+
+    def format(str):
+        return str.format(bug=bug_number, test=test_name)
+
+    def create_file(filename, template):
+        path = os.path.join(os.path.dirname(sys.argv[0]), format(filename))
+        # Create a new file, bailing with an error if the file exists.
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL)
+
+        try:
+            # This file has 777 permission when created, for whatever reason.  Make it rw-rw-r---.
+            os.fchmod(fd, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH)
+        except:
+            # fchmod doesn't work on Windows.
+            pass
+
+        with os.fdopen(fd, 'w') as file:
+            file.write(format(template))
+
+    create_file('browserElement_{test}.js', js_template)
+    create_file('test_browserElement_inproc_{test}.html', html_template)
+    create_file('test_browserElement_oop_{test}.html', html_template)
+
+    add_to_ini('mochitest.ini',
+               format('test_browserElement_inproc_{test}.html'),
+               format('browserElement_{test}.js'))
+    add_to_ini('mochitest-oop.ini',
+               format('test_browserElement_oop_{test}.html'))
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Create a new browser-element testcase.")
+    parser.add_argument('test_name')
+    parser.add_argument('bug_number', type=int)
+    args = parser.parse_args()
+    main(args.test_name, args.bug_number)
diff --git a/dom/browser-element/mochitest/file_audio.html b/dom/browser-element/mochitest/file_audio.html
new file mode 100644
index 000000000..0e4a8d7c6
--- /dev/null
+++ b/dom/browser-element/mochitest/file_audio.html
@@ -0,0 +1,15 @@
+<html>
+<body>
+<audio src="chrome://mochitests/content/chrome/dom/browser-element/mochitest/audio.ogg" id="audio" />
+<script>
+var audio = document.getElementById('audio');
+audio.play();
+audio.onended = function() {
+  setTimeout(function() {
+    audio.play();
+  }, 0);
+}
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_ActiveStateChange.html b/dom/browser-element/mochitest/file_browserElement_ActiveStateChange.html
new file mode 100644
index 000000000..5228d67bf
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_ActiveStateChange.html
@@ -0,0 +1,25 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+<script type="application/javascript;version=1.7">
+var audio = new Audio();
+audio.src = "audio.ogg";
+audio.loop = true;
+
+function runCommands()
+{
+  switch(location.hash) {
+    case '#play':
+      audio.play();
+      break;
+    case '#pause':
+      audio.pause();
+      break;
+    default :
+      alert("Undefined command!");
+  }
+}
+window.addEventListener('hashchange', runCommands);
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/file_browserElement_AlertInFrame.html b/dom/browser-element/mochitest/file_browserElement_AlertInFrame.html
new file mode 100644
index 000000000..8bdac1d25
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_AlertInFrame.html
@@ -0,0 +1,6 @@
+<html>
+<body>
+I'm file_browserElement_AlertInFrame.html.
+<iframe src='file_browserElement_AlertInFrame_Inner.html'></iframe>
+<body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_AlertInFrame_Inner.html b/dom/browser-element/mochitest/file_browserElement_AlertInFrame_Inner.html
new file mode 100644
index 000000000..958413f2d
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_AlertInFrame_Inner.html
@@ -0,0 +1,12 @@
+<html>
+<body>
+I'm file_browserElement_AlertInFrame_Inner.html.
+
+<script>
+addEventListener('load', function() {
+  alert("Hello");
+});
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_AudioChannelMutedByDefault.html b/dom/browser-element/mochitest/file_browserElement_AudioChannelMutedByDefault.html
new file mode 100644
index 000000000..ea4f3bde1
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_AudioChannelMutedByDefault.html
@@ -0,0 +1,65 @@
+<html>
+<body>
+<script>
+var audio = new Audio("audio.ogg");
+var context = new AudioContext();
+var node = context.createMediaElementSource(audio);
+var sp = context.createScriptProcessor(2048, 1);
+node.connect(sp);
+var expectedSamplesCount;
+var nonzeroSamplesCount = 0;
+var isStarted = false;
+
+function ok(aVal, aMsg) {
+  alert((!!aVal ? "OK" : "KO") + ", " + aMsg);
+}
+
+function finish() {
+  audio.onended = null;
+  audio.pause();
+  alert("DONE");
+}
+
+function processSamples(e) {
+  var buf = e.inputBuffer.getChannelData(0);
+  for (var i = 0; i < buf.length; ++i) {
+    if (buf[i] != 0) {
+      if (!isStarted) {
+        isStarted = true;
+        ok(true, "Start process audio sample.");
+      }
+      nonzeroSamplesCount++;
+    }
+  }
+
+  if (nonzeroSamplesCount >= expectedSamplesCount) {
+    finish();
+  }
+}
+
+audio.oncanplaythrough = function() {
+  var testDuration = audio.duration > 1.0 ? 1.0 : audio.duration * 0.5;
+  expectedSamplesCount = Math.floor(testDuration * context.sampleRate);
+  sp.onaudioprocess = processSamples;
+};
+
+function runCommands()
+{
+  switch(location.hash) {
+    case '#play':
+      ok(true, "Audio starts playing.")
+      audio.play();
+      audio.onended = () => {
+        audio.onended = null;
+        ok(false, "Audio shouldn't go ended in this test!")
+      };
+      break;
+    default :
+      ok(false, "Undefined command!");
+  }
+}
+
+window.addEventListener('hashchange', runCommands);
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_AudioChannelSeeking.html b/dom/browser-element/mochitest/file_browserElement_AudioChannelSeeking.html
new file mode 100644
index 000000000..293f6cadc
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_AudioChannelSeeking.html
@@ -0,0 +1,62 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+<script type="application/javascript;version=1.7">
+var audio = new Audio();
+audio.src = "audio.ogg";
+audio.loop = true;
+
+function assert(aVal, aMessage) {
+  return (!aVal) ? ok(false, aMessage) : 0;
+}
+
+function ok(aVal, aMsg) {
+  alert((!!aVal ? "OK" : "KO") + ", " + aMsg);
+}
+
+function info(aMsg) {
+  alert("INFO" + ", " + aMsg);
+}
+
+function randomSeeking() {
+  var seekingPosition = Math.random() * audio.duration;
+  assert(seekingPosition < audio.duration, "Seeking position out of range!")
+  audio.currentTime = seekingPosition;
+  audio.onseeked = () => {
+    audio.onseeked = null;
+    location.hash = '#idle';
+    ok(true, "Seeking complete, position = " + seekingPosition);
+  };
+}
+
+function runCommands()
+{
+  switch(location.hash) {
+    case '#play':
+      audio.play();
+      audio.onplay = () => {
+        audio.onplay = null;
+        info("Start playing, duration = " + audio.duration);
+      };
+      break;
+    case '#seeking':
+      randomSeeking();
+      break;
+    case '#pause':
+      audio.pause();
+      audio.onpause = () => {
+        audio.onpause = null;
+        ok(true, "Stop playing.");
+      };
+      break;
+    case '#idle':
+      break;
+    default :
+      ok(false, "Undefined command!");
+  }
+}
+
+window.addEventListener('hashchange', runCommands);
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/file_browserElement_AudioChannel_nested.html b/dom/browser-element/mochitest/file_browserElement_AudioChannel_nested.html
new file mode 100644
index 000000000..c37a642e2
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_AudioChannel_nested.html
@@ -0,0 +1,63 @@
+<html>
+<head>
+<script type="text/javascript">
+
+  function ok(a, msg) {
+    alert((!!a ? "OK" : "KO") + " " + msg);
+  }
+
+  function is(a, b, msg) {
+    ok(a === b, msg);
+  }
+
+  function finish(a, b, msg) {
+    alert("DONE");
+  }
+
+  addEventListener('load', function(e) {
+    var iframe = document.createElement('iframe');
+    iframe.setAttribute('mozbrowser', 'true');
+    // set 'remote' to true here will make the the iframe remote in _inproc_
+    // test and in-process in _oop_  test.
+    iframe.setAttribute('remote', 'true');
+    iframe.setAttribute('mozapp', 'http://example.org/manifest.webapp');
+
+    iframe.addEventListener('mozbrowserloadend', function(e) {
+      ok("mute" in iframe, "iframe.mute exists");
+      ok("unmute" in iframe, "iframe.unmute exists");
+      ok("getMuted" in iframe, "iframe.getMuted exists");
+      ok("getVolume" in iframe, "iframe.getVolume exists");
+      ok("setVolume" in iframe, "iframe.setVolume exists");
+
+      ok("allowedAudioChannels" in iframe, "allowedAudioChannels exist");
+      var channels = iframe.allowedAudioChannels;
+      is(channels.length, 9, "9 audio channel by default");
+
+      var ac = channels[0];
+
+      ok(ac instanceof BrowserElementAudioChannel, "Correct class");
+      ok("getVolume" in ac, "ac.getVolume exists");
+      ok("setVolume" in ac, "ac.setVolume exists");
+      ok("getMuted" in ac, "ac.getMuted exists");
+      ok("setMuted" in ac, "ac.setMuted exists");
+      ok("isActive" in ac, "ac.isActive exists");
+
+      ac.onactivestatechanged = function() {
+        ok(true, "activestatechanged event received.");
+
+        ac.getVolume().onsuccess = function(e) {
+          ok(e.target.result, 1, "Default volume is 1");
+        };
+
+        finish();
+      }
+    });
+
+    document.body.appendChild(iframe);
+    iframe.src = 'chrome://mochitests/content/chrome/dom/browser-element/mochitest/file_audio.html';
+  });
+</script>
+</head>
+<body>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_BrowserWindowNamespace.html b/dom/browser-element/mochitest/file_browserElement_BrowserWindowNamespace.html
new file mode 100644
index 000000000..7903a63b8
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_BrowserWindowNamespace.html
@@ -0,0 +1,9 @@
+<html>
+<body>
+<script>
+addEventListener('load', function() {
+  window.open("http://example.com/" + location.hash, "foo");
+});
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_CloseFromOpener.html b/dom/browser-element/mochitest/file_browserElement_CloseFromOpener.html
new file mode 100644
index 000000000..4a08c2792
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_CloseFromOpener.html
@@ -0,0 +1,8 @@
+<html>
+<body>
+<script>
+var win = window.open('file_empty.html');
+win.close();
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_CookiesNotThirdParty.html b/dom/browser-element/mochitest/file_browserElement_CookiesNotThirdParty.html
new file mode 100644
index 000000000..62f39d8ff
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_CookiesNotThirdParty.html
@@ -0,0 +1,25 @@
+<html>
+<body>
+file_browserElement_CookiesNotThirdParty.html
+
+<script type='text/javascript;version=1.7'>
+if (location.search != '?step=2') {
+  // Step 1: Set a cookie.
+  document.cookie = 'file_browserElement_CookiesNotThirdParty';
+  alert('next');
+}
+else {
+  // Step 2: Read the cookie.
+  if (document.cookie == 'file_browserElement_CookiesNotThirdParty') {
+    alert('success: got the correct cookie');
+  }
+  else {
+    alert('failure: got unexpected cookie: "' + document.cookie + '"');
+  }
+
+  alert('finish');
+}
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_ExecuteScript.html b/dom/browser-element/mochitest/file_browserElement_ExecuteScript.html
new file mode 100644
index 000000000..d2c364aeb
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_ExecuteScript.html
@@ -0,0 +1,8 @@
+<html>
+<head>
+  <script>
+window.btoa = () => "fake btoa";
+  </script>
+</head>
+<body>foo</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_ForwardName.html b/dom/browser-element/mochitest/file_browserElement_ForwardName.html
new file mode 100644
index 000000000..60b41bbc6
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_ForwardName.html
@@ -0,0 +1,15 @@
+<html>
+<body>
+<script>
+
+if (window.name == 'foo') {
+  alert("success:window.name == 'foo'");
+}
+else {
+  alert("failure:window.name == '" + window.name + "', expected 'foo'");
+}
+
+window.open('file_browserElement_ForwardName.html#finish', 'foo');
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_FrameWrongURI.html b/dom/browser-element/mochitest/file_browserElement_FrameWrongURI.html
new file mode 100644
index 000000000..1a6cfde0a
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_FrameWrongURI.html
@@ -0,0 +1,5 @@
+<script>
+  function testSucceeded() { alert("success"); }
+  function callback() { return "<script>opener.testSucceeded()</" + "script>"; }
+  var w = window.open("javascript:opener.callback();");
+</script>
diff --git a/dom/browser-element/mochitest/file_browserElement_LoadEvents.html b/dom/browser-element/mochitest/file_browserElement_LoadEvents.html
new file mode 100644
index 000000000..7e0705e9d
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_LoadEvents.html
@@ -0,0 +1,14 @@
+<html>
+<body style="background-color:green;">
+
+<!-- Tests rely on the fact that there's an element in here called 'url' and
+     that there's visible text on the page. -->
+
+Aloha!  My URL is <span id='url'></span>.
+
+<script>
+document.getElementById('url').innerHTML = window.location;
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_Metachange.sjs b/dom/browser-element/mochitest/file_browserElement_Metachange.sjs
new file mode 100644
index 000000000..c63a047f7
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_Metachange.sjs
@@ -0,0 +1,7 @@
+function handleRequest(request, response)
+{
+  var p = request.queryString.split('|');
+  response.setHeader('Content-Language', p[0], false);
+  response.write('<html><head><meta name="application-name" content="sjs"' +
+                  (p.length > 1 ? (' lang="' + p[1] + '"') : '') + '></head><body></body></html>');
+}
diff --git a/dom/browser-element/mochitest/file_browserElement_NextPaint.html b/dom/browser-element/mochitest/file_browserElement_NextPaint.html
new file mode 100644
index 000000000..d460fc5b9
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_NextPaint.html
@@ -0,0 +1,9 @@
+<html>
+<body>
+<script>
+addEventListener("hashchange", function () {
+  document.body.style.backgroundColor = "red";
+});
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_NoAudioTrack.html b/dom/browser-element/mochitest/file_browserElement_NoAudioTrack.html
new file mode 100644
index 000000000..14304e469
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_NoAudioTrack.html
@@ -0,0 +1,32 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+<script type="application/javascript;version=1.7">
+var audio = new Audio();
+audio.src = "noaudio.webm";
+audio.preload = "none";
+audio.loop = true;
+
+function ok(aVal, aMsg) {
+  alert((!!aVal ? "OK" : "KO") + ", " + aMsg);
+}
+
+function runCommands()
+{
+  switch(location.hash) {
+    case '#play':
+      audio.play();
+      ok(true, "Start playing a video without audio track!");
+      break;
+    case '#idle':
+      ok(!audio.paused, "Video is still playing!");
+      break;
+    default :
+      ok(false, "Undefined command!");
+  }
+}
+
+window.addEventListener('hashchange', runCommands);
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/file_browserElement_Open1.html b/dom/browser-element/mochitest/file_browserElement_Open1.html
new file mode 100644
index 000000000..c74415e2e
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_Open1.html
@@ -0,0 +1,34 @@
+<html>
+<body>
+<script>
+
+// Because this file is inside <iframe mozbrowser>, the alert() calls below
+// don't trigger actual dialogs.  Instead, the document which contans the
+// iframe receives mozbrowsershowmodalprompt events, which the document uses
+// to determine test success/failure.
+
+function is(x, y, reason) {
+  if (x === y)  {
+    alert("success: " + x + " === " + y + ", " + reason);
+  }
+  else {
+    alert("failure: " + x + " !== " + y + ", " + reason);
+  }
+}
+
+function ok(bool, reason) {
+  alert((bool ? "success: " : "failure: ") + reason);
+}
+
+// Send "dialog=1" as a test for bug 783644.  It shouldn't have any effect.
+var w = window.open("file_browserElement_Open2.html", "name", "dialog=1");
+w.addEventListener("load", function() {
+  ok(true, "got load");
+  is(w.opener, window, 'opener property');
+  is(w.location.href, location.href.replace('Open1', 'Open2'), 'correct location');
+  is(w.document.getElementById('testElem').innerHTML, 'test', 'elem innerHTML');
+  alert("finish");
+});
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_Open2.html b/dom/browser-element/mochitest/file_browserElement_Open2.html
new file mode 100644
index 000000000..af9d2b6cd
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_Open2.html
@@ -0,0 +1,5 @@
+<html>
+<body>
+<div id='testElem'>test</div>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_OpenMixedProcess.html b/dom/browser-element/mochitest/file_browserElement_OpenMixedProcess.html
new file mode 100644
index 000000000..873a99f1a
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_OpenMixedProcess.html
@@ -0,0 +1,22 @@
+<html>
+<body>
+
+<!-- The test relies on the fact that this file is completely empty. -->
+
+<script>
+
+function ok(b, msg)
+{
+  alert((b ? 'pass:' : 'fail:') + msg);
+}
+
+var w = window.open("file_empty.html");
+w.addEventListener('load', function() {
+  ok(true, 'Got load.');
+  ok(w.document.getElementById('url'), 'Found element with id "url"');
+  alert('finish');
+});
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_OpenNamed.html b/dom/browser-element/mochitest/file_browserElement_OpenNamed.html
new file mode 100644
index 000000000..7d2a7661c
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_OpenNamed.html
@@ -0,0 +1,7 @@
+<html>
+<body>
+<script>
+window.open('file_browserElement_OpenNamed2.html', 'OpenNamed');
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_OpenNamed2.html b/dom/browser-element/mochitest/file_browserElement_OpenNamed2.html
new file mode 100644
index 000000000..6bf37bb53
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_OpenNamed2.html
@@ -0,0 +1,7 @@
+<html>
+<body>
+<script>
+alert('success: loaded');
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_OpenWindowDifferentOrigin.html b/dom/browser-element/mochitest/file_browserElement_OpenWindowDifferentOrigin.html
new file mode 100644
index 000000000..dc08f341c
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_OpenWindowDifferentOrigin.html
@@ -0,0 +1,18 @@
+<html>
+<body>
+
+<div id='name'></div>
+
+<script>
+if (location.search == "?1") {
+  open("http://example.com/tests/dom/browser-element/mochitest/file_browserElement_OpenWindowDifferentOrigin.html?2");
+}
+else if (location.search == "?2") {
+  alert("finish");
+}
+
+document.getElementById('name').innerHTML = location.search;
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_OpenWindowEmpty.html b/dom/browser-element/mochitest/file_browserElement_OpenWindowEmpty.html
new file mode 100644
index 000000000..fefd6f6ca
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_OpenWindowEmpty.html
@@ -0,0 +1,7 @@
+<html>
+<body>
+<script>
+window.open();
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_OpenWindowInFrame.html b/dom/browser-element/mochitest/file_browserElement_OpenWindowInFrame.html
new file mode 100644
index 000000000..c1c1cecd3
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_OpenWindowInFrame.html
@@ -0,0 +1,6 @@
+<html>
+<body>
+I'm file_browserElement_OpenInFrame.html.
+<iframe src='file_browserElement_Open1.html'></iframe>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_OpenWindowRejected.html b/dom/browser-element/mochitest/file_browserElement_OpenWindowRejected.html
new file mode 100644
index 000000000..eb6786979
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_OpenWindowRejected.html
@@ -0,0 +1,16 @@
+<html>
+<body>
+
+<script>
+var w = window.open('does_not_exist.html');
+if (!w) {
+  alert("success:w is null");
+}
+else {
+  alert("failure:w is not null -- " + w);
+}
+alert("finish");
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_PrivateBrowsing.html b/dom/browser-element/mochitest/file_browserElement_PrivateBrowsing.html
new file mode 100644
index 000000000..40ff9d8af
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_PrivateBrowsing.html
@@ -0,0 +1,15 @@
+<html>
+<body>
+<script>
+
+if (location.href.indexOf("clear=true") != -1) {
+  localStorage.removeItem("foo");
+  alert("CLEAR");
+} else {
+  var initialValue = localStorage.getItem("foo") || "EMPTY";
+  localStorage.setItem("foo", "bar");
+  alert(initialValue);
+}
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_SecurityChange.html b/dom/browser-element/mochitest/file_browserElement_SecurityChange.html
new file mode 100644
index 000000000..09c006e7c
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_SecurityChange.html
@@ -0,0 +1,21 @@
+<html>
+<head>
+
+<script>
+if (location.search === '?broken') {
+  // Load something non-https.
+  var s = document.createElement('script');
+  s.src = 'http://example.com/dom/browser-element/mochitest/file_empty_script.js';
+  document.head.appendChild(s);
+} else if (location.search === '?tracking') {
+  var img = document.createElement('img');
+  img.src = 'http://tracking.example.com/tests/toolkit/components/url-classifier/tests/mochitest/raptor.jpg';
+  document.body.appendChild(img);
+}
+</script>
+</head>
+
+<body>
+file_browserElement_SecurityChange.html.
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_SendEvent.html b/dom/browser-element/mochitest/file_browserElement_SendEvent.html
new file mode 100644
index 000000000..3c510180d
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_SendEvent.html
@@ -0,0 +1,15 @@
+<html><body>
+<button>send[Mouse|Touch]Event</button>
+</body><script>
+function changeHash(e) {
+  document.location.hash = e.type;
+};
+window.addEventListener('mousedown', changeHash);
+window.addEventListener('mousemove', changeHash);
+window.addEventListener('mouseup', changeHash);
+window.addEventListener('click', changeHash, true);
+window.addEventListener('touchstart', changeHash);
+window.addEventListener('touchmove', changeHash);
+window.addEventListener('touchend', changeHash);
+window.addEventListener('touchcancel', changeHash);
+</script></html>
diff --git a/dom/browser-element/mochitest/file_browserElement_SetInputMethodActive.html b/dom/browser-element/mochitest/file_browserElement_SetInputMethodActive.html
new file mode 100644
index 000000000..5eb17e5f1
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_SetInputMethodActive.html
@@ -0,0 +1,2 @@
+<input autofocus value="hello" />
+<p>This is targetted mozbrowser frame.</p>
diff --git a/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames2_Outer.html b/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames2_Outer.html
new file mode 100644
index 000000000..c4fa25d26
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames2_Outer.html
@@ -0,0 +1,25 @@
+<html>
+<body>
+<script>
+
+var iframe = document.createElement('iframe');
+iframe.setAttribute("mozbrowser", "true");
+
+iframe.addEventListener('mozbrowsershowmodalprompt', function(e) {
+  if (e.detail.message == 'child:ready') {
+    setTimeout(function() {
+      iframe.setVisible(false);
+      iframe.setVisible(true);
+      setTimeout(function() {
+        alert('parent:finish');
+      }, 0);
+    }, 0);
+  }
+});
+
+document.body.appendChild(iframe);
+iframe.src = 'file_browserElement_SetVisibleFrames_Inner.html?child';
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames_Inner.html b/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames_Inner.html
new file mode 100644
index 000000000..8f9b871d6
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames_Inner.html
@@ -0,0 +1,18 @@
+<html>
+<body>
+<script>
+
+var name = location.search.substring(1);
+addEventListener('load', function() {
+  setTimeout(function() {
+    alert(name + ':ready');
+  }, 0);
+});
+
+addEventListener('visibilitychange', function() {
+  alert(name + ':' + (document.hidden ? 'hidden' : 'visible'));
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames_Outer.html b/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames_Outer.html
new file mode 100644
index 000000000..6abcc6b0c
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_SetVisibleFrames_Outer.html
@@ -0,0 +1,45 @@
+<html>
+<body>
+
+<script>
+
+var numPrompts = 0;
+function handlePrompt(e) {
+  numPrompts++;
+
+  // The first two prompts should be "child1:ready" and "child2:ready".  Once
+  // we get both of these, forward the child's prompt up to our parent.
+  if (numPrompts == 2) {
+    // This has to happen here, because setVisibile doesn't exist on the iframe
+    // until BrowserElementChild.js is loaded in it.  (That's pretty broken...)
+    iframe2.setVisible(false);
+  }
+  else if (numPrompts == 3) {
+    if (e.detail.message != 'child2:hidden') {
+      alert("parent:fail Didn't get expected 'child2:hidden'.");
+    }
+
+    alert('parent:ready');
+  }
+  else if (numPrompts == 4 || numPrompts == 5) {
+    alert(e.detail.message);
+  }
+}
+
+var iframe1 = document.createElement('iframe');
+iframe1.setAttribute("mozbrowser", "true");
+iframe1.addEventListener('mozbrowsershowmodalprompt', handlePrompt);
+
+var iframe2 = document.createElement('iframe');
+iframe2.setAttribute("mozbrowser", "true");
+iframe2.addEventListener('mozbrowsershowmodalprompt', handlePrompt);
+
+iframe1.src = 'file_browserElement_SetVisibleFrames_Inner.html?child1';
+iframe2.src = 'file_browserElement_SetVisibleFrames_Inner.html?child2';
+document.body.appendChild(iframe1);
+document.body.appendChild(iframe2);
+
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_TargetBlank.html b/dom/browser-element/mochitest/file_browserElement_TargetBlank.html
new file mode 100644
index 000000000..860573a3e
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_TargetBlank.html
@@ -0,0 +1,18 @@
+<html>
+<body>
+<a id='link' target='_blank' href="http://example.com">Click me</a>
+
+<script>
+function clickLink() {
+  // See testcase in bug 666604.
+  var e = document.createEvent("MouseEvent");
+  e.initMouseEvent("click", true, true, window, 0, 0, 0, 0, 0,
+                   false, false, false, false, 0, null);
+  document.getElementById('link').dispatchEvent(e);
+}
+
+addEventListener('load', function() { setTimeout(clickLink, 0) });
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_TargetTop.html b/dom/browser-element/mochitest/file_browserElement_TargetTop.html
new file mode 100644
index 000000000..aad06361d
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_TargetTop.html
@@ -0,0 +1,12 @@
+<html>
+<body>
+<div id='url'></div>
+
+<script>
+if (location.search == '') {
+  window.open('file_browserElement_TargetTop.html?2', '_top');
+}
+document.getElementById('url').innerHTML = document.location.href;
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_ThemeColor.html b/dom/browser-element/mochitest/file_browserElement_ThemeColor.html
new file mode 100644
index 000000000..f8fb9f116
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_ThemeColor.html
@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <meta name="theme-color" content="pink">
+  </head>
+
+  <body>
+  </body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_Viewmode.html b/dom/browser-element/mochitest/file_browserElement_Viewmode.html
new file mode 100644
index 000000000..422279e0a
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_Viewmode.html
@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <meta name="viewmode" content="projection=stereo">
+  </head>
+
+  <body>
+  </body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_XFrameOptions.sjs b/dom/browser-element/mochitest/file_browserElement_XFrameOptions.sjs
new file mode 100644
index 000000000..7e2375680
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_XFrameOptions.sjs
@@ -0,0 +1,9 @@
+function handleRequest(request, response)
+{
+  response.setHeader("X-Frame-Options", request.queryString, false);
+  response.setHeader("Content-Type", "text/html", false);
+
+  // Tests rely on this page not being entirely blank, because they take
+  // screenshots to determine whether this page was loaded.
+  response.write("<html><body>XFrameOptions test<script>alert('finish')</script></body></html>");
+}
diff --git a/dom/browser-element/mochitest/file_browserElement_XFrameOptionsAllowFrom.html b/dom/browser-element/mochitest/file_browserElement_XFrameOptionsAllowFrom.html
new file mode 100644
index 000000000..12a6fd31e
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_XFrameOptionsAllowFrom.html
@@ -0,0 +1,43 @@
+<html>
+<body>
+
+  <!-- Try to load in a frame a cross-origin page which sends:
+     "X-Frame-Options: Allow-From http://mochi.test:8888/",
+       and a cross-origin page which sends
+     "X-Frame-Options: Allow-From http://example.com/". -->
+
+<script>
+
+// Make sure these iframes aren't too tall; they both need to fit inside the
+// iframe this page is contained in, without scrolling, in order for the test's
+// screenshots to work properly.
+
+var frame_src = 'http://example.com/tests/dom/browser-element/mochitest/file_browserElement_XFrameOptionsAllowFrom.sjs';
+
+var iframe1 = document.createElement('iframe');
+iframe1.height = '300px';
+var iframe2 = document.createElement('iframe');
+iframe2.height = '300px';
+document.body.appendChild(iframe1);
+
+iframe1.addEventListener('load', function iframe1Load() {
+  iframe1.removeEventListener('load', iframe1Load);
+  // This causes our embedder to take a screenshot (and blocks until the
+  // screenshot is completed).
+  var iframe2Loaded = false;
+  iframe2.addEventListener('load', function iframe2Load() {
+    iframe2.removeEventListener('load', iframe2Load);
+    iframe2Loaded = true;
+    alert('finish');
+  });
+
+  document.body.appendChild(iframe2);
+  iframe2.src = frame_src;
+});
+
+
+iframe1.src = frame_src + '?iframe1';
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_XFrameOptionsAllowFrom.sjs b/dom/browser-element/mochitest/file_browserElement_XFrameOptionsAllowFrom.sjs
new file mode 100644
index 000000000..4a5dbaace
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_XFrameOptionsAllowFrom.sjs
@@ -0,0 +1,16 @@
+function handleRequest(request, response)
+{
+  var content = 'step 1';
+  if (request.queryString == "iframe1") {
+      response.setHeader("X-Frame-Options", "Allow-From http://mochi.test:8888/")
+      content = 'finish';
+  } else {
+      response.setHeader("X-Frame-Options", "Allow-From http://example.com")
+  }
+
+  response.setHeader("Content-Type", "text/html", false);
+
+  // Tests rely on this page not being entirely blank, because they take
+  // screenshots to determine whether this page was loaded.
+  response.write("<html><body>XFrameOptions test<script>alert('" + content + "')</script></body></html>");
+}
diff --git a/dom/browser-element/mochitest/file_browserElement_XFrameOptionsDeny.html b/dom/browser-element/mochitest/file_browserElement_XFrameOptionsDeny.html
new file mode 100644
index 000000000..338275aa3
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_XFrameOptionsDeny.html
@@ -0,0 +1,57 @@
+<html>
+<body>
+
+<!-- Try to load in a frame a page which sends "X-Frame-Options: DENY", and a
+     cross-origin page which sends "X-Frame-Options: SAMEORIGIN". -->
+
+<script>
+
+// Make sure these iframes aren't too tall; they both need to fit inside the
+// iframe this page is contained in, without scrolling, in order for the test's
+// screenshots to work properly.
+
+var iframe1 = document.createElement('iframe');
+iframe1.height = '300px';
+var iframe2 = document.createElement('iframe');
+iframe2.height = '300px';
+document.body.appendChild(iframe1);
+document.body.appendChild(iframe2);
+
+// This causes our embedder to take a screenshot (and blocks until the
+// screenshot is completed).
+alert('step 1');
+
+// Wait for both iframes to load.
+
+var iframe1Loaded = false;
+iframe1.addEventListener('load', function iframe1Load() {
+  iframe1.removeEventListener('load', iframe1Load);
+  iframe1Loaded = true;
+  waitForBothLoads();
+});
+
+var iframe2Loaded = false;
+iframe2.addEventListener('load', function iframe2Load() {
+  iframe2.removeEventListener('load', iframe2Load);
+  iframe2Loaded = true;
+  waitForBothLoads();
+});
+
+function waitForBothLoads() {
+  if (iframe1Loaded && iframe2Loaded) {
+    setTimeout(function() {
+      // This causes our embedder to take another screenshot.
+      alert('step 2');
+    }, 0);
+  }
+}
+
+iframe1.src = 'file_browserElement_XFrameOptions.sjs?DENY';
+
+// Load iframe2 with the origin of our parent.  Since we have a different
+// origin and are inside <iframe mozbrowser>, this should not load.
+iframe2.src = 'http://mochi.test:8888/tests/dom/browser-element/mochitest/file_browserElement_XFrameOptions.sjs?SAMEORIGIN';
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_browserElement_XFrameOptionsSameOrigin.html b/dom/browser-element/mochitest/file_browserElement_XFrameOptionsSameOrigin.html
new file mode 100644
index 000000000..11e75f141
--- /dev/null
+++ b/dom/browser-element/mochitest/file_browserElement_XFrameOptionsSameOrigin.html
@@ -0,0 +1,5 @@
+<html>
+<body>
+<iframe src='file_browserElement_XFrameOptions.sjs?SAMEORIGIN'></iframe>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_bug709759.sjs b/dom/browser-element/mochitest/file_bug709759.sjs
new file mode 100644
index 000000000..ce78b188b
--- /dev/null
+++ b/dom/browser-element/mochitest/file_bug709759.sjs
@@ -0,0 +1,5 @@
+function handleRequest(request, response)
+{
+  response.processAsync();
+  response.setHeader("Content-Type", "image/jpeg", false);
+}
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/file_bug741717.sjs b/dom/browser-element/mochitest/file_bug741717.sjs
new file mode 100644
index 000000000..bde9ddfae
--- /dev/null
+++ b/dom/browser-element/mochitest/file_bug741717.sjs
@@ -0,0 +1,27 @@
+function handleRequest(request, response)
+{
+  function etag(count) {
+    return '"anetag' + count + '"';
+  }
+
+  var count = parseInt(getState('count'));
+  if (!count)
+    count = 0;
+
+  // reload(false) will make a request with If-None-Match headers
+  var ifNoneMatch = request.hasHeader("If-None-Match") ?
+    request.getHeader("If-None-Match") : "";
+
+  if (ifNoneMatch === etag(count)) {
+    response.setStatusLine(request.httpVersion, "304", "Not Modified");
+    return;
+  }
+
+  count++;
+  setState('count', count + '');
+
+  response.setHeader('Content-Type', 'text/html', false);
+  response.setHeader('Cache-Control', 'public, max-age=3600', false);
+  response.setHeader("ETag", etag(count), false);
+  response.write('<html><body>' + count + '</body></html>');
+}
diff --git a/dom/browser-element/mochitest/file_download_bin.sjs b/dom/browser-element/mochitest/file_download_bin.sjs
new file mode 100644
index 000000000..fd394ea0a
--- /dev/null
+++ b/dom/browser-element/mochitest/file_download_bin.sjs
@@ -0,0 +1,4 @@
+function handleRequest(request, response) {
+  response.setHeader("Content-Type", "application/octet-stream", false);
+  response.write("BIN");
+}
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/file_empty.html b/dom/browser-element/mochitest/file_empty.html
new file mode 100644
index 000000000..ed21305b9
--- /dev/null
+++ b/dom/browser-element/mochitest/file_empty.html
@@ -0,0 +1,14 @@
+<html>
+<body>
+
+<!-- Tests rely on the fact that there's an element in here called 'url' and
+     that there's visible text on the page. -->
+
+Aloha!  My URL is <span id='url'></span>.
+
+<script>
+document.getElementById('url').innerHTML = window.location;
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_empty_script.js b/dom/browser-element/mochitest/file_empty_script.js
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/dom/browser-element/mochitest/file_empty_script.js
diff --git a/dom/browser-element/mochitest/file_focus.html b/dom/browser-element/mochitest/file_focus.html
new file mode 100644
index 000000000..0bd3f7aa4
--- /dev/null
+++ b/dom/browser-element/mochitest/file_focus.html
@@ -0,0 +1,24 @@
+<html>
+<body>
+
+Aloha!  My URL is <span id='url'></span>.
+<script>
+document.getElementById('url').innerHTML = window.location;
+</script>
+
+<script>
+  // The input element is getting synthesized key events and will prevent
+  // default on the first ESC keydown event.
+
+  var alreadyBlocked = false;
+
+  addEventListener('keydown', function(e) {
+    if (e.keyCode == SpecialPowers.Ci.nsIDOMKeyEvent.DOM_VK_ESCAPE &&
+        alreadyBlocked == false) {
+      alreadyBlocked = true;
+      e.preventDefault();
+    }
+  });
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_http_401_response.sjs b/dom/browser-element/mochitest/file_http_401_response.sjs
new file mode 100644
index 000000000..c40a252c3
--- /dev/null
+++ b/dom/browser-element/mochitest/file_http_401_response.sjs
@@ -0,0 +1,16 @@
+function handleRequest(request, response)
+{
+  var auth = "";
+  try {
+    auth = request.getHeader("Authorization");
+  } catch(e) {}
+
+  if (auth == "Basic aHR0cHVzZXI6aHR0cHBhc3M=") {
+    response.setStatusLine("1.1", 200, "OK");
+    response.write("<html><head><title>http auth success</title></head><html>");
+  } else {
+    response.setStatusLine("1.1", 401, "Http authentication required");
+    response.setHeader("WWW-Authenticate", "Basic realm=\"http_realm\"");
+    response.write("<html><head><title>http auth failed</title></head><html>");
+  }
+}
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/file_http_407_response.sjs b/dom/browser-element/mochitest/file_http_407_response.sjs
new file mode 100644
index 000000000..da2f27620
--- /dev/null
+++ b/dom/browser-element/mochitest/file_http_407_response.sjs
@@ -0,0 +1,16 @@
+function handleRequest(request, response)
+{
+  var auth = "";
+  try {
+    auth = request.getHeader("Proxy-Authorization");
+  } catch(e) {}
+
+  if (auth == "Basic cHJveHl1c2VyOnByb3h5cGFzcw==") {
+    response.setStatusLine("1.1", 200, "OK");
+    response.write("<html><head><title>http auth success</title></head><html>");
+  } else {
+    response.setStatusLine("1.1", 407, "Proxy Authentication Required");
+    response.setHeader("Proxy-Authenticate", "Basic realm=\"http_realm\"");
+    response.write("<html><head><title>http auth failed</title></head><html>");
+  }
+}
diff --git a/dom/browser-element/mochitest/file_illegal_web_manifest.html b/dom/browser-element/mochitest/file_illegal_web_manifest.html
new file mode 100644
index 000000000..d9075b3fc
--- /dev/null
+++ b/dom/browser-element/mochitest/file_illegal_web_manifest.html
@@ -0,0 +1,7 @@
+<!doctype html>
+<meta charset=utf-8>
+<head>
+<!-- FIXME: we should keep file:// here ... -->
+<link rel="manifest" href="sshfs://this_is_not_allowed!">
+</head>
+<h1>Support Page for Web Manifest Tests</h1>
diff --git a/dom/browser-element/mochitest/file_post_request.html b/dom/browser-element/mochitest/file_post_request.html
new file mode 100644
index 000000000..773193067
--- /dev/null
+++ b/dom/browser-element/mochitest/file_post_request.html
@@ -0,0 +1,15 @@
+<html>
+<head>
+  <script>
+  addEventListener('load', function() {
+    document.getElementsByTagName('form')[0].submit();
+  });
+  </script>
+</head>
+<body>
+  <form action="file_empty.html" method="POST">
+    <input type="text" name="postvalue" value="I am a test string!!" />
+    <input type="submit" />
+  </form>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/file_web_manifest.html b/dom/browser-element/mochitest/file_web_manifest.html
new file mode 100644
index 000000000..783da0f47
--- /dev/null
+++ b/dom/browser-element/mochitest/file_web_manifest.html
@@ -0,0 +1,6 @@
+<!doctype html>
+<meta charset=utf-8>
+<head>
+<link rel="manifest" href="file_web_manifest.json">
+</head>
+<h1>Support Page for Web Manifest Tests</h1>
diff --git a/dom/browser-element/mochitest/file_web_manifest.json b/dom/browser-element/mochitest/file_web_manifest.json
new file mode 100644
index 000000000..57d0c3d42
--- /dev/null
+++ b/dom/browser-element/mochitest/file_web_manifest.json
@@ -0,0 +1 @@
+{"name": "pass"}
diff --git a/dom/browser-element/mochitest/file_wyciwyg.html b/dom/browser-element/mochitest/file_wyciwyg.html
new file mode 100644
index 000000000..f53216144
--- /dev/null
+++ b/dom/browser-element/mochitest/file_wyciwyg.html
@@ -0,0 +1,14 @@
+<html>
+<head>
+<title>test</title>
+<script type="text/javascript">
+addEventListener('load', function() {
+  window.setTimeout(function() {
+    document.write("test");
+  }, 0);
+});
+</script>
+</head>
+<body>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/iframe_file_audio.html b/dom/browser-element/mochitest/iframe_file_audio.html
new file mode 100644
index 000000000..605ce2870
--- /dev/null
+++ b/dom/browser-element/mochitest/iframe_file_audio.html
@@ -0,0 +1,5 @@
+<html>
+<body>
+<iframe src="file_audio.html"></iframe>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/mochitest-oop.ini b/dom/browser-element/mochitest/mochitest-oop.ini
new file mode 100644
index 000000000..70d38c532
--- /dev/null
+++ b/dom/browser-element/mochitest/mochitest-oop.ini
@@ -0,0 +1,135 @@
+[DEFAULT]
+# Both the "inproc" and "oop" versions of OpenMixedProcess open remote frames,
+# so we don't run that test on platforms which don't support OOP tests.
+skip-if = os == "android" || e10s
+support-files =
+  browserElement_OpenMixedProcess.js
+  file_browserElement_ExecuteScript.html
+  file_browserElement_OpenMixedProcess.html
+  browserElement_ExecuteScript.js
+  browserElement_Find.js
+  browserElement_OpenTab.js
+
+[test_browserElement_oop_AudioChannelSeeking.html]
+tags = audiochannel
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_Viewmode.html]
+[test_browserElement_oop_ThemeColor.html]
+[test_browserElement_inproc_ErrorSecurity.html]
+[test_browserElement_inproc_OpenMixedProcess.html]
+disabled = disabled for bug 1266035
+[test_browserElement_oop_Alert.html]
+[test_browserElement_oop_AlertInFrame.html]
+[test_browserElement_oop_AudioChannelMutedByDefault.html]
+tags = audiochannel
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_Auth.html]
+[test_browserElement_oop_BackForward.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_BadScreenshot.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_BrowserWindowResize.html]
+[test_browserElement_oop_Close.html]
+[test_browserElement_oop_CookiesNotThirdParty.html]
+[test_browserElement_oop_CopyPaste.html]
+subsuite = clipboard
+[test_browserElement_oop_DOMRequestError.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_DataURI.html]
+[test_browserElement_oop_DocumentFirstPaint.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_Download.html]
+disabled = bug 1022281
+[test_browserElement_oop_ErrorSecurity.html]
+[test_browserElement_oop_ExecuteScript.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_Find.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_FirstPaint.html]
+[test_browserElement_oop_ForwardName.html]
+[test_browserElement_oop_FrameWrongURI.html]
+[test_browserElement_oop_GetScreenshot.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_GetScreenshotDppx.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_Iconchange.html]
+[test_browserElement_oop_LoadEvents.html]
+[test_browserElement_oop_Manifestchange.html]
+[test_browserElement_oop_Metachange.html]
+[test_browserElement_oop_NoAudioTrack.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_AudioPlayback.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_OpenMixedProcess.html]
+disabled = disabled for bug 1266035
+[test_browserElement_oop_OpenNamed.html]
+[test_browserElement_oop_OpenWindow.html]
+[test_browserElement_oop_OpenWindowDifferentOrigin.html]
+[test_browserElement_oop_OpenWindowInFrame.html]
+[test_browserElement_oop_OpenWindowRejected.html]
+[test_browserElement_oop_Opensearch.html]
+[test_browserElement_oop_OpenTab.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_PrivateBrowsing.html]
+[test_browserElement_oop_PromptCheck.html]
+[test_browserElement_oop_PromptConfirm.html]
+[test_browserElement_oop_Proxy.html]
+[test_browserElement_oop_PurgeHistory.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_Reload.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_ReloadPostRequest.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_RemoveBrowserElement.html]
+[test_browserElement_oop_ScrollEvent.html]
+[test_browserElement_oop_SecurityChange.html]
+skip-if = toolkit == 'android' #TIMED_OUT, bug 766586
+[test_browserElement_oop_SendEvent.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_SetInputMethodActive.html]
+# skip-if = (os == "android")
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_SetVisible.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_SetVisibleFrames.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_SetVisibleFrames2.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_Stop.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_TargetBlank.html]
+[test_browserElement_oop_TargetTop.html]
+[test_browserElement_oop_Titlechange.html]
+[test_browserElement_oop_TopBarrier.html]
+[test_browserElement_oop_VisibilityChange.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_XFrameOptions.html]
+[test_browserElement_oop_XFrameOptionsAllowFrom.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+# bug 1189592
+skip-if = asan
+[test_browserElement_oop_XFrameOptionsDeny.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_XFrameOptionsSameOrigin.html]
+# Disabled until bug 930449 makes it stop timing out
+[test_browserElement_oop_ContextmenuEvents.html]
+disabled = bug 930449
+# Disabled until bug 924771 makes them stop timing out
+[test_browserElement_oop_CloseFromOpener.html]
+disabled = bug 924771
+[test_browserElement_oop_ExposableURI.html]
+disabled = bug 924771
+[test_browserElement_oop_GetContentDimensions.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_AudioChannel.html]
+tags = audiochannel
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_AudioChannel_nested.html]
+tags = audiochannel
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_getWebManifest.html]
+disabled = Disabling some OOP tests for WebIDL scope changes
+[test_browserElement_oop_OpenWindowEmpty.html]
+[test_browserElement_oop_ActiveStateChange.html]
+tags = audiochannel
+disabled = Disabling some OOP tests for WebIDL scope changes
diff --git a/dom/browser-element/mochitest/mochitest.ini b/dom/browser-element/mochitest/mochitest.ini
new file mode 100644
index 000000000..e1799f93f
--- /dev/null
+++ b/dom/browser-element/mochitest/mochitest.ini
@@ -0,0 +1,159 @@
+[DEFAULT]
+skip-if = e10s
+support-files =
+  audio.ogg
+  ../../../dom/media/test/short-video.ogv
+  async.js
+  browserElementTestHelpers.js
+  browserElement_Alert.js
+  browserElement_AlertInFrame.js
+  browserElement_Auth.js
+  browserElement_Viewmode.js
+  browserElement_ThemeColor.js
+  browserElement_BrowserWindowNamespace.js
+  browserElement_BrowserWindowResize.js
+  browserElement_Close.js
+  browserElement_CloseFromOpener.js
+  browserElement_ContextmenuEvents.js
+  browserElement_CookiesNotThirdParty.js
+  browserElement_CopyPaste.js
+  browserElement_DataURI.js
+  browserElement_Download.js
+  browserElement_ErrorSecurity.js
+  browserElement_ExposableURI.js
+  browserElement_FirstPaint.js
+  browserElement_ForwardName.js
+  browserElement_FrameWrongURI.js
+  browserElement_Iconchange.js
+  browserElement_LoadEvents.js
+  browserElement_Manifestchange.js
+  browserElement_Metachange.js
+  browserElement_NextPaint.js
+  browserElement_OpenNamed.js
+  browserElement_OpenTab.js
+  browserElement_OpenWindow.js
+  browserElement_OpenWindowDifferentOrigin.js
+  browserElement_OpenWindowEmpty.js
+  browserElement_OpenWindowInFrame.js
+  browserElement_OpenWindowRejected.js
+  browserElement_Opensearch.js
+  browserElement_PrivateBrowsing.js
+  browserElement_PromptCheck.js
+  browserElement_PromptConfirm.js
+  browserElement_Proxy.js
+  browserElement_Reload.js
+  browserElement_RemoveBrowserElement.js
+  browserElement_ScrollEvent.js
+  browserElement_SecurityChange.js
+  browserElement_TargetBlank.js
+  browserElement_TargetTop.js
+  browserElement_Titlechange.js
+  browserElement_TopBarrier.js
+  browserElement_XFrameOptions.js
+  browserElement_XFrameOptionsAllowFrom.js
+  browserElement_XFrameOptionsDeny.js
+  browserElement_XFrameOptionsSameOrigin.js
+  file_browserElement_AlertInFrame.html
+  file_browserElement_AlertInFrame_Inner.html
+  file_browserElement_Viewmode.html
+  file_browserElement_ThemeColor.html
+  file_browserElement_BrowserWindowNamespace.html
+  file_browserElement_CloseFromOpener.html
+  file_browserElement_CookiesNotThirdParty.html
+  file_browserElement_ForwardName.html
+  file_browserElement_FrameWrongURI.html
+  file_browserElement_LoadEvents.html
+  file_browserElement_Metachange.sjs
+  file_browserElement_NextPaint.html
+  file_browserElement_Open1.html
+  file_browserElement_Open2.html
+  file_browserElement_OpenNamed.html
+  file_browserElement_OpenNamed2.html
+  file_browserElement_OpenWindowDifferentOrigin.html
+  file_browserElement_OpenWindowEmpty.html
+  file_browserElement_OpenWindowInFrame.html
+  file_browserElement_OpenWindowRejected.html
+  file_browserElement_PrivateBrowsing.html
+  file_browserElement_SecurityChange.html
+  file_browserElement_TargetBlank.html
+  file_browserElement_TargetTop.html
+  file_browserElement_XFrameOptions.sjs
+  file_browserElement_XFrameOptionsAllowFrom.html
+  file_browserElement_XFrameOptionsAllowFrom.sjs
+  file_browserElement_XFrameOptionsDeny.html
+  file_browserElement_XFrameOptionsSameOrigin.html
+  file_bug741717.sjs
+  file_download_bin.sjs
+  file_empty.html
+  file_empty_script.js
+  file_focus.html
+  file_http_401_response.sjs
+  file_http_407_response.sjs
+  file_wyciwyg.html
+  file_audio.html
+  iframe_file_audio.html
+  file_web_manifest.html
+  file_web_manifest.json
+  file_illegal_web_manifest.html
+  noaudio.webm
+
+# Note: browserElementTestHelpers.js looks at the test's filename to determine
+# whether the test should be OOP.  "_oop_" signals OOP, "_inproc_" signals in
+# process.  Default is OOP.
+[test_browserElement_NoAttr.html]
+[test_browserElement_NoPref.html]
+[test_browserElement_NoPermission.html]
+[test_browserElement_inproc_Alert.html]
+[test_browserElement_inproc_Viewmode.html]
+[test_browserElement_inproc_ThemeColor.html]
+[test_browserElement_inproc_AlertInFrame.html]
+[test_browserElement_inproc_Auth.html]
+[test_browserElement_inproc_BrowserWindowNamespace.html]
+[test_browserElement_inproc_BrowserWindowResize.html]
+[test_browserElement_inproc_Close.html]
+[test_browserElement_inproc_CloseFromOpener.html]
+[test_browserElement_inproc_ContextmenuEvents.html]
+[test_browserElement_inproc_CookiesNotThirdParty.html]
+[test_browserElement_inproc_CopyPaste.html]
+subsuite = clipboard
+skip-if = (os == "android") # Disabled on Android, see bug 1230421
+[test_browserElement_inproc_DataURI.html]
+[test_browserElement_inproc_Download.html]
+disabled = bug 1022281
+[test_browserElement_inproc_ExposableURI.html]
+[test_browserElement_inproc_FirstPaint.html]
+[test_browserElement_inproc_ForwardName.html]
+[test_browserElement_inproc_FrameWrongURI.html]
+[test_browserElement_inproc_Iconchange.html]
+[test_browserElement_inproc_LoadEvents.html]
+[test_browserElement_inproc_Manifestchange.html]
+[test_browserElement_inproc_Metachange.html]
+[test_browserElement_inproc_OpenNamed.html]
+[test_browserElement_inproc_OpenTab.html]
+disabled = won't work as Firefox desktop will intercept ctrl-click
+[test_browserElement_inproc_OpenWindow.html]
+[test_browserElement_inproc_OpenWindowDifferentOrigin.html]
+[test_browserElement_inproc_OpenWindowInFrame.html]
+[test_browserElement_inproc_OpenWindowRejected.html]
+[test_browserElement_inproc_Opensearch.html]
+[test_browserElement_inproc_PrivateBrowsing.html]
+[test_browserElement_inproc_PromptCheck.html]
+[test_browserElement_inproc_PromptConfirm.html]
+[test_browserElement_inproc_Proxy.html]
+[test_browserElement_inproc_RemoveBrowserElement.html]
+[test_browserElement_inproc_ScrollEvent.html]
+[test_browserElement_inproc_SecurityChange.html]
+[test_browserElement_inproc_TargetBlank.html]
+[test_browserElement_inproc_TargetTop.html]
+[test_browserElement_inproc_Titlechange.html]
+[test_browserElement_inproc_TopBarrier.html]
+[test_browserElement_inproc_XFrameOptions.html]
+[test_browserElement_inproc_XFrameOptionsAllowFrom.html]
+[test_browserElement_inproc_XFrameOptionsDeny.html]
+[test_browserElement_inproc_XFrameOptionsSameOrigin.html]
+[test_browserElement_oop_NextPaint.html]
+# Disabled due to https://bugzilla.mozilla.org/show_bug.cgi?id=774100
+disabled = temp disabling some OOP tests for WebIDL scope changes
+[test_browserElement_inproc_Reload.html]
+disabled = bug 774100
+[test_browserElement_inproc_OpenWindowEmpty.html]
diff --git a/dom/browser-element/mochitest/noaudio.webm b/dom/browser-element/mochitest/noaudio.webm
new file mode 100644
index 000000000..9207017fb
--- /dev/null
+++ b/dom/browser-element/mochitest/noaudio.webm
diff --git a/dom/browser-element/mochitest/priority/chrome.ini b/dom/browser-element/mochitest/priority/chrome.ini
new file mode 100644
index 000000000..e1852f6ff
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/chrome.ini
@@ -0,0 +1,19 @@
+[DEFAULT]
+# Good luck running these tests on anything but desktop Linux.
+run-if = os == 'linux' && buildapp == 'browser' && !e10s
+support-files =
+  file_Audio.html
+  file_MultipleFrames.html
+  file_NestedFramesOuter.html
+  file_WebGLContextLost.html
+  silence.ogg
+  !/dom/browser-element/mochitest/browserElementTestHelpers.js
+  !/dom/browser-element/mochitest/file_empty.html
+
+[test_Activity.html]
+[test_Audio.html]
+[test_Background.html]
+[test_Keyboard.html]
+[test_MultipleFrames.html]
+[test_NestedFrames.html]
+[test_Visibility.html]
diff --git a/dom/browser-element/mochitest/priority/file_Audio.html b/dom/browser-element/mochitest/priority/file_Audio.html
new file mode 100644
index 000000000..97f4dc64d
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/file_Audio.html
@@ -0,0 +1,19 @@
+<html>
+<body>
+
+<script>
+addEventListener('load', function() {
+  setTimeout(function() {
+    var a = document.getElementById('audio');
+    a.onplay = function() {
+      alert('onplay');
+    };
+    a.play();
+  }, 0);
+});
+</script>
+
+<audio id='audio' loop src='silence.ogg'>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/file_HighPriority.html b/dom/browser-element/mochitest/priority/file_HighPriority.html
new file mode 100644
index 000000000..dc7197bba
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/file_HighPriority.html
@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+
+<script>
+var lock = navigator.requestWakeLock('high-priority');
+alert('step0');
+
+lock.unlock();
+alert('step1');
+
+lock = navigator.requestWakeLock('cpu');
+alert('step2');
+
+lock.unlock();
+alert('step3');
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/file_MultipleFrames.html b/dom/browser-element/mochitest/priority/file_MultipleFrames.html
new file mode 100644
index 000000000..b3b56f560
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/file_MultipleFrames.html
@@ -0,0 +1,14 @@
+<html>
+<body>
+<p>file_MultipleFrames.html</p>
+
+<script>
+addEventListener('load', function() {
+  setTimeout(function() {
+    window.open('../file_empty.html');
+  }, 0);
+});
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/file_NestedFramesOuter.html b/dom/browser-element/mochitest/priority/file_NestedFramesOuter.html
new file mode 100644
index 000000000..e4378935f
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/file_NestedFramesOuter.html
@@ -0,0 +1,20 @@
+<html>
+<body>
+<p>file_NestedFramesOuter.html</p>
+<script>
+
+addEventListener('load', function() {
+  setTimeout(createIframe, 0);
+});
+
+function createIframe()
+{
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = location.hash.substr(1);
+  document.body.appendChild(iframe);
+}
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/file_WebGLContextLost.html b/dom/browser-element/mochitest/priority/file_WebGLContextLost.html
new file mode 100644
index 000000000..bd5c84f11
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/file_WebGLContextLost.html
@@ -0,0 +1,22 @@
+<html>
+<body>
+file_WebGLContextLost.html
+<canvas id='canvas'></canvas>
+
+<script>
+function runTest()
+{
+  var canvas = document.getElementById('canvas');
+  canvas.addEventListener('webglcontextlost', function() {
+    alert('webglcontextlost');
+  });
+
+  var context = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+  context.viewport(0, 0, 10, 10);
+  alert('ready');
+}
+
+addEventListener('load', function() { setTimeout(runTest, 0) });
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/mochitest.ini b/dom/browser-element/mochitest/priority/mochitest.ini
new file mode 100644
index 000000000..8118aedd7
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/mochitest.ini
@@ -0,0 +1,19 @@
+[DEFAULT]
+# Good luck running these tests on anything but desktop Linux.
+run-if = os == 'linux' && buildapp == 'browser' && !e10s
+support-files =
+  file_HighPriority.html
+  silence.ogg
+  !/dom/browser-element/mochitest/browserElementTestHelpers.js
+  !/dom/browser-element/mochitest/file_empty.html
+
+# Note: ../browserElementTestHelpers.js makes all tests in this directory OOP,
+# because testing the process-priority manager without OOP frames does not make
+# much sense.
+
+[test_Simple.html]
+[test_HighPriority.html]
+[test_Preallocated.html]
+disabled = bug 968604, bug 987164
+[test_WebGLContextLost.html]
+disabled = bug 865844
diff --git a/dom/browser-element/mochitest/priority/silence.ogg b/dom/browser-element/mochitest/priority/silence.ogg
new file mode 100644
index 000000000..6e0b352a3
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/silence.ogg
diff --git a/dom/browser-element/mochitest/priority/test_Activity.html b/dom/browser-element/mochitest/priority/test_Activity.html
new file mode 100644
index 000000000..ae4049d96
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Activity.html
@@ -0,0 +1,62 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that calling setVisible("false") on an iframe that has an open activity
+causes its priority to change.
+-->
+<head>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  var os = SpecialPowers.Cc["@mozilla.org/observer-service;1"]
+                        .getService(SpecialPowers.Ci.nsIObserverService);
+  var iframe = document.createElement("iframe");
+  iframe.setAttribute("mozbrowser", true);
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  var childID = null;
+  Promise.all([
+    expectOnlyOneProcessCreated("FOREGROUND").then(function(chid) {
+      childID = chid;
+    }),
+    expectMozbrowserEvent(iframe, "loadend")
+  ]).then(function() {
+    var p = expectPriorityChange(childID, "BACKGROUND_PERCEIVABLE");
+
+    // We simulate opening an activity
+    os.notifyObservers(null, "activity-opened", childID);
+
+    // We wait until mozbrowserloadend before calling setVisible, because
+    // setVisible isn't available until mozbrowser has loaded.  In practice, that
+    // means we can call setVisible once we've gotten /any/ mozbrowser event.
+    iframe.setVisible(false);
+    return p;
+  }).then(function() {
+    var p = expectPriorityChange(childID, "BACKGROUND");
+
+    // Now we simulate closing an activity
+    os.notifyObservers(null, "activity-closed", childID);
+
+    return p;
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener("testready", runTest);
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_Audio.html b/dom/browser-element/mochitest/priority/test_Audio.html
new file mode 100644
index 000000000..d39b1c9f3
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Audio.html
@@ -0,0 +1,53 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that frames playing audio get BACKGROUND_PERCEIVABLE priority.
+-->
+<head>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = 'file_Audio.html';
+
+  var childID = null;
+  Promise.all([
+    expectOnlyOneProcessCreated("FOREGROUND").then(function(chid) {
+      childID = chid;
+    }),
+    expectMozbrowserEvent(iframe, 'loadend'),
+    expectMozbrowserEvent(iframe, 'showmodalprompt').then(function(e) {
+      is(e.detail.message, 'onplay', 'showmodalprompt message');
+    })
+  ]).then(function() {
+    // Send the child process into the background.  Because it's playing audio,
+    // it should get priority BACKGROUND_PERCEIVABLE, not vanilla BACKGROUND.
+    var p = expectPriorityChange(childID, 'BACKGROUND_PERCEIVABLE');
+    iframe.setVisible(false);
+    return p;
+  }).then(function() {
+    var p = expectPriorityChange(childID, 'FOREGROUND');
+    iframe.setVisible(true);
+    return p;
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_Background.html b/dom/browser-element/mochitest/priority/test_Background.html
new file mode 100644
index 000000000..59eb16863
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Background.html
@@ -0,0 +1,53 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that calling setVisible('false') on an iframe causes its visibility to
+change.
+-->
+<head>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  var childID = null;
+  Promise.all([
+    expectOnlyOneProcessCreated('FOREGROUND').then(function(chid) {
+      childID = chid;
+    }),
+    expectMozbrowserEvent(iframe, 'loadend')
+  ]).then(function() {
+    var p = expectPriorityChange(childID, 'BACKGROUND');
+
+    // We wait until mozbrowserloadend before calling setVisible, because
+    // setVisible isn't available until mozbrowser has loaded.  In practice, that
+    // means we can call setVisible once we've gotten /any/ mozbrowser event.
+    iframe.setVisible(false);
+    return p;
+  }).then(function() {
+    var p = expectPriorityChange(childID, 'FOREGROUND');
+    iframe.setVisible(true);
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_HighPriority.html b/dom/browser-element/mochitest/priority/test_HighPriority.html
new file mode 100644
index 000000000..d3396d65b
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_HighPriority.html
@@ -0,0 +1,133 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that frames with mozapptype=critical which hold the "high-priority" or
+"cpu" wake locks get elevated process priority.
+-->
+<head>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  // To test bug 870480, run this test while holding the CPU and high-priority
+  // wake locks.  Without the fix for bug 870480, we won't set the priority of
+  // the child process if the main process holds these wake locks and the test
+  // will hang.
+  navigator.requestWakeLock('cpu');
+  navigator.requestWakeLock('high-priority');
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.setAttribute('mozapptype', 'critical');
+  iframe.src = 'file_HighPriority.html';
+
+  // We expect the following to happen:
+  //
+  // - Process is created.
+  // - Its priority is set to FOREGROUND (when the process starts).
+  // - wait_alert('step0', FOREGROUND_HIGH)
+  // - wait_alert('step1', FOREGROUND)
+  // - wait_alert('step2', FOREGROUND_HIGH)
+  //
+  // Where wait_alert(M, P) means that we expect the subprocess to
+  //   * do alert(M) and
+  //   * be set to priority P
+  // in some order.  If the alert occurs before the priority change, we block
+  // the alert until we observe the priority change.  So the subprocess only
+  // has to do
+  //
+  //   // set priority to FOREGROUND_HIGH
+  //   alert('step0');
+  //   // set priority to FOREGROUND
+  //   alert('step1');
+  //
+  // etc.
+
+  var childID = null;
+  var alertTimes = [];
+
+  // Return a promise that's resolved once the child process calls alert() and
+  // we get a priority change, in some order.
+  //
+  // We check that the text of the alert is |"step" + index|.
+  //
+  // If gracePeriod is given, we check that the priority change occurred at
+  // least gracePeriod ms since the alert from the previous step (with a fudge
+  // factor to account for inaccurate timers).
+  function expectAlertAndPriorityChange(index, priority, /* optional */ gracePeriod) {
+    function checkAlertInfo(e) {
+      is(e.detail.message, 'step' + index, 'alert() number ' + index);
+      alertTimes.push(new Date());
+
+      // Block the alert; we'll unblock it by calling e.detail.unblock() later.
+      e.preventDefault();
+      return Promise.resolve(e.detail.unblock);
+    }
+
+    function checkGracePeriod() {
+      if (gracePeriod) {
+        var msSinceLastAlert = (new Date()) - alertTimes[index - 1];
+
+        // 50ms fudge factor.  This test is set up so that, if nsITimers are
+        // accurate, we don't need any fudge factor.  Unfortunately our timers
+        // are not accurate!  There's little we can do here except fudge.
+        // Thankfully all we're trying to test is that we get /some/ delay; the
+        // exact amount of delay isn't so important.
+        ok(msSinceLastAlert + 50 >= gracePeriod,
+           msSinceLastAlert + "ms since last alert >= (" + gracePeriod + " - 50ms)");
+      }
+    }
+
+    return Promise.all([
+      new Promise(function(resolve, reject) {
+        iframe.addEventListener('mozbrowsershowmodalprompt', function check(e) {
+          iframe.removeEventListener('mozbrowsershowmodalprompt', check);
+          resolve(checkAlertInfo(e));
+        });
+      }),
+      expectPriorityChange(childID, priority).then(checkGracePeriod)
+    ]).then(function(results) {
+      // checkAlertInfo returns the function to call to unblock the alert.
+      // It comes to us as the first element of the results array.
+      results[0]();
+    });
+  }
+
+  expectProcessCreated('FOREGROUND').then(function(chid) {
+    childID = chid;
+  }).then(function() {
+    return expectAlertAndPriorityChange(0, 'FOREGROUND_HIGH');
+  }).then(function() {
+    return expectAlertAndPriorityChange(1, 'FOREGROUND', priorityChangeGracePeriod);
+  }).then(function() {
+    return expectAlertAndPriorityChange(2, 'FOREGROUND_HIGH');
+  }).then(function() {
+    return expectAlertAndPriorityChange(3, 'FOREGROUND', priorityChangeGracePeriod);
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+const priorityChangeGracePeriod = 100;
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv(
+    {set: [['dom.ipc.processPriorityManager.backgroundGracePeriodMS',
+            priorityChangeGracePeriod],
+           ['dom.wakelock.enabled', true]]},
+    runTest);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_Keyboard.html b/dom/browser-element/mochitest/priority/test_Keyboard.html
new file mode 100644
index 000000000..a36f954ba
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Keyboard.html
@@ -0,0 +1,54 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that frames with mozapptype=inputmethod gets the keyboard-specific
+priority level when in the foreground.
+-->
+<head>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.setAttribute('mozapptype', 'inputmethod');
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  var childID = null;
+  Promise.all([
+    expectOnlyOneProcessCreated('FOREGROUND_KEYBOARD').then(function(chid) {
+      childID = chid;
+    }),
+    expectMozbrowserEvent(iframe, 'loadend')
+  ]).then(function() {
+    var p = expectPriorityChange(childID, 'BACKGROUND');
+
+    /* We wait until mozbrowserloadend before calling setVisible, because
+     * setVisible isn't available until mozbrowser has loaded.  In practice,
+     * that means we can call setVisible once we've gotten /any/ mozbrowser
+     * event. */
+    iframe.setVisible(false);
+    return p;
+  }).then(function() {
+    var p = expectPriorityChange(childID, 'FOREGROUND_KEYBOARD');
+    iframe.setVisible(true);
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_MultipleFrames.html b/dom/browser-element/mochitest/priority/test_MultipleFrames.html
new file mode 100644
index 000000000..57d9563e7
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_MultipleFrames.html
@@ -0,0 +1,58 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that when we remove one of a process's frames from the DOM, the process's
+priority is recomputed.
+-->
+<head>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = 'file_MultipleFrames.html';
+
+  var childID = null;
+  var iframe2;
+  Promise.all([
+    expectProcessCreated('FOREGROUND').then(function(chid) {
+      childID = chid;
+    }),
+    new Promise(function(resolve, reject) {
+      iframe.addEventListener('mozbrowseropenwindow', function(e) {
+        iframe2 = e.detail.frameElement;
+        var p = expectMozbrowserEvent(iframe2, 'loadend');
+        document.body.appendChild(iframe2);
+        resolve(p);
+      });
+    })
+  ]).then(function() {
+    // At this point, the child process has been set to FOREGROUND, and the popup
+    // opened by file_MultipleFrames has finished loading.
+    //
+    // Now setVisible(false) the popup frame and remove the popup frame from the
+    // DOM.  This should cause the process to take on BACKGROUND priority.
+    var p = expectPriorityChange(childID, 'BACKGROUND');
+    iframe.setVisible(false);
+    document.body.removeChild(iframe2);
+    return p;
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_NestedFrames.html b/dom/browser-element/mochitest/priority/test_NestedFrames.html
new file mode 100644
index 000000000..e5381bcc5
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_NestedFrames.html
@@ -0,0 +1,62 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test changing the visibility of an <iframe mozbrowser> changes the visibility
+(and thus the priority) of any <iframe mozbrowser>s it contains.
+-->
+<head>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  // Set up the following hierarchy of frames:
+  //
+  //   <iframe mozbrowser remote=false src='file_NestedFramesOuter.html'>
+  //     <iframe mozbrowser remote=true src='file_empty.html'>
+  //
+  // When we change the visibility of the outer iframe, it should change the
+  // priority of the inner one.
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.setAttribute('remote', false);
+  iframe.src = 'file_NestedFramesOuter.html#' + browserElementTestHelpers.emptyPage1;
+
+  // Note that this is the process corresponding to the /inner/ iframe.  The
+  // outer iframe runs in-process (because it has remote=false).
+  var childID = null;
+  Promise.all(
+    [expectOnlyOneProcessCreated('FOREGROUND').then(function(child) {
+       childID = child;
+     }),
+     expectMozbrowserEvent(iframe, 'loadend')]
+  ).then(function() {
+    // Send the outer iframe into the background.  This should change the
+    // priority of the inner frame's process to BACKGROUND.
+    var p = expectPriorityChange(childID, 'BACKGROUND');
+    iframe.setVisible(false);
+    return p;
+  }).then(function() {
+    var p = expectPriorityChange(childID, 'FOREGROUND');
+    iframe.setVisible(true);
+    return p;
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_Preallocated.html b/dom/browser-element/mochitest/priority/test_Preallocated.html
new file mode 100644
index 000000000..b2cb0335e
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Preallocated.html
@@ -0,0 +1,71 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that the preallocated process starts up with priority BACKGROUND.
+-->
+<head>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+browserElementTestHelpers.enableProcessPriorityManager();
+
+var preallocationEnabledPref = null;
+try {
+  preallocationEnabledPref = SpecialPowers.getBoolPref('dom.ipc.processPrelaunch.enabled');
+}
+catch(e) {
+  preallocationEnabledPref = null;
+}
+
+var childID = null;
+
+var cleanedUp = false;
+function cleanUp()
+{
+  if (cleanedUp) {
+    return;
+  }
+
+  cleanedUp = true;
+}
+
+// Even if this test times out, we still want to run cleanUp so as to set the
+// pref back.
+addEventListener('unload', cleanUp);
+
+function runTest()
+{
+  if (preallocationEnabledPref) {
+    ok(false, "dom.ipc.processPrelaunch.enabled must be " +
+              "false for this test to work.");
+    SimpleTest.finish();
+    return;
+  }
+
+  // Ensure that the preallocated process initially gets BACKGROUND priority.
+  // That's it.
+  expectProcessCreated('PREALLOC').then(function() {
+    // We need to set the pref asynchoronously or the preallocated process won't
+    // be shut down.
+    SimpleTest.executeSoon(function(){
+      cleanUp();
+      SimpleTest.finish();
+    });
+  });
+}
+// Setting this pref to true should cause us to prelaunch a process.
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({'set':[["dom.ipc.processPrelaunch.enabled",true]]},runTest);
+});
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_Simple.html b/dom/browser-element/mochitest/priority/test_Simple.html
new file mode 100644
index 000000000..7cc801e54
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Simple.html
@@ -0,0 +1,59 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+A simple test of the process priority manager.
+
+https://bugzilla.mozilla.org/show_bug.cgi?id=844323
+
+Note: If you run this test alone (i.e. not as part of the larger mochitest
+suite), you may see some IPC assertions, e.g. "Can't allocate graphics
+resources."
+
+What appears to be happening is that we close the Firefox window before the
+frame we create in this tab finishes starting up.  Then the frame finishes
+loading, and it tries to show itself.  But it's too late to show a remote frame
+at that point, so we kill the child process.
+
+In other words, I think these errors are nothing to worry about.
+-->
+<head>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+browserElementTestHelpers.enableProcessPriorityManager();
+
+var allCompleted = 0;
+var allExpected  = 2;
+function finish() {
+  allCompleted++;
+  if (allCompleted === allExpected) {
+    SimpleTest.finish();
+  }
+}
+
+function runTest() {
+  var iframeLoaded = false;
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  iframe.addEventListener('mozbrowserloadend', finish);
+  expectProcessCreated('FOREGROUND').then(finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_Visibility.html b/dom/browser-element/mochitest/priority/test_Visibility.html
new file mode 100644
index 000000000..58648b99f
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Visibility.html
@@ -0,0 +1,51 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that setVisible() changes a process's priority.
+-->
+<head>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  var childID = null;
+  Promise.all([
+    expectOnlyOneProcessCreated('FOREGROUND').then(function(chid) {
+      childID = chid;
+    }),
+    expectMozbrowserEvent(iframe, 'loadend')
+  ]).then(function() {
+    // Mark the frame as not visible.  This should cause its priority to drop
+    // to BACKGROUND.
+    var p = expectPriorityChange(childID, 'BACKGROUND');
+    iframe.setVisible(false);
+    return p;
+  }).then(function() {
+    // Mark the frame as visible again.  This should cause its priority change
+    // back to FOREGROUND.
+    var p = expectPriorityChange(childID, 'FOREGROUND');
+    iframe.setVisible(true);
+    return p;
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', runTest);
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/priority/test_WebGLContextLost.html b/dom/browser-element/mochitest/priority/test_WebGLContextLost.html
new file mode 100644
index 000000000..383506ec6
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_WebGLContextLost.html
@@ -0,0 +1,99 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that calling setVisible('false') and then sending a low-memory
+notification causes a WebGL context loss event.
+-->
+<head>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+browserElementTestHelpers.setEnabledPref(true);
+browserElementTestHelpers.addPermission();
+browserElementTestHelpers.enableProcessPriorityManager();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = 'file_WebGLContextLost.html';
+
+  // We use this to ensure that we don't call SimpleTest.finish() twice.
+  var finished = false;
+  function finishOnce() {
+    if (!finished) {
+      SimpleTest.finish();
+      finished = true;
+    }
+  }
+
+  expectMozbrowserEvent(iframe, 'error').then(function(e) {
+    if (finished) {
+      // We don't care if the frame dies after the test finishes.
+      return;
+    }
+    todo(false, "child process is crashing; this probably indicates that " +
+         "something is wrong with WebGL in child processes on your machine.");
+    is(e.detail.type, 'fatal');
+  }).then(finishOnce);
+
+  var childID = null;
+  Promise.all([
+    expectOnlyOneProcessCreated('FOREGROUND').then(function(chid) {
+      childID = chid;
+    }),
+    expectMozbrowserEvent(iframe, 'loadend'),
+    expectMozbrowserEvent(iframe, 'showmodalprompt').then(function(e) {
+      is(e.detail.message, 'ready');
+    })
+  ]).then(function() {
+    // Fire a low-memory notification once the process goes into the background
+    // due to the setVisible(false) call below.
+    expectPriorityChange(childID, 'BACKGROUND').then(function() {
+      SimpleTest.executeSoon(function() {
+        var os = SpecialPowers.Cc["@mozilla.org/observer-service;1"]
+                              .getService(SpecialPowers.Ci.nsIObserverService);
+        os.notifyObservers(null, "memory-pressure", "low-memory");
+        ok(true, 'Successfully notified observers.');
+      });
+    });
+
+    // This test isn't the only possible source of a low-memory notification; the
+    // browser can fire one whenever it likes.  So it's fine if we lose the
+    // WebGL context before we fire the low-memory notification ourself.
+
+    var p = expectMozbrowserEvent(iframe, 'showmodalprompt').then(function(e) {
+      is(e.detail.message, 'webglcontextlost');
+    });
+
+    iframe.setVisible(false);
+    return p;
+  }).then(finishOnce);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', function() {
+  // At the time this test was written, webgl was blocklisted inside child
+  // processes on desktop Linux.  The issue is that we spawn a child process to
+  // read driver info, but we only did this on the main prrocess.  Child
+  // processes never read the driver info themselves, nor do they get it from
+  // their parent, so they refuse to start up WebGL.
+  //
+  // This isn't a problem on B2G because we force WebGL on there.  But it
+  // obviously makes this test difficult.  bjacob says forcing WebGL on here
+  // shouldn't hurt things, and anyway this setting mirrors what we do on B2G,
+  // which is what we're trying to test!
+  SpecialPowers.pushPrefEnv({set: [["webgl.force-enabled", true]]},
+                            runTest);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_NoAttr.html b/dom/browser-element/mochitest/test_browserElement_NoAttr.html
new file mode 100644
index 000000000..070aee19f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_NoAttr.html
@@ -0,0 +1,46 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=710231
+-->
+<head>
+  <title>Test for Bug 710231</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=710231">Mozilla Bug 710231</a>
+
+<!--
+  Test that an iframe without the |mozbrowser| attribute does not emit
+  mozbrowserX events.
+-->
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+function runTest() {
+  var iframe = document.getElementById('iframe');
+  iframe.addEventListener('mozbrowserloadstart', function() {
+    ok(false, 'Should not send mozbrowserloadstart event.');
+  });
+
+  iframe.addEventListener('load', function() {
+    ok(true, 'Got iframe load event.');
+    SimpleTest.finish();
+  });
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+}
+
+addEventListener('load', function() { SimpleTest.executeSoon(runTest); });
+
+</script>
+
+<iframe id='iframe'></iframe>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_NoPermission.html b/dom/browser-element/mochitest/test_browserElement_NoPermission.html
new file mode 100644
index 000000000..4e1d88072
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_NoPermission.html
@@ -0,0 +1,49 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=710231
+-->
+<head>
+  <title>Test for Bug 710231</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=710231">Mozilla Bug 710231</a>
+
+<!--
+  Test that an iframe with the |mozbrowser| attribute does not emit
+  mozbrowserX events when this page does not have the "browser" permission.
+-->
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  iframe.addEventListener('mozbrowserloadstart', function() {
+    ok(false, 'Should not send mozbrowserloadstart event.');
+  });
+
+  iframe.addEventListener('load', function() {
+    ok(true, 'Got iframe load event.');
+    SimpleTest.finish();
+  });
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+}
+
+browserElementTestHelpers.setEnabledPref(true);
+SpecialPowers.removePermission("browser", document);
+addEventListener('testready', runTest);
+
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_NoPref.html b/dom/browser-element/mochitest/test_browserElement_NoPref.html
new file mode 100644
index 000000000..df69e4c43
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_NoPref.html
@@ -0,0 +1,49 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=710231
+-->
+<head>
+  <title>Test for Bug 710231</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=710231">Mozilla Bug 710231</a>
+
+<!--
+  Test that an iframe with the |mozbrowser| attribute does not emit
+  mozbrowserX events when they're globally pref'ed off.
+-->
+
+<script type="application/javascript;version=1.7">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+function runTest() {
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', 'true');
+  document.body.appendChild(iframe);
+
+  iframe.addEventListener('mozbrowserloadstart', function() {
+    ok(false, 'Should not send mozbrowserloadstart event.');
+  });
+
+  iframe.addEventListener('load', function() {
+    ok(true, 'Got iframe load event.');
+    SimpleTest.finish();
+  });
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+}
+
+browserElementTestHelpers.setEnabledPref(false);
+addEventListener('testready', runTest);
+
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ActiveStateChange.html b/dom/browser-element/mochitest/test_browserElement_inproc_ActiveStateChange.html
new file mode 100644
index 000000000..4a14ad7cb
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ActiveStateChange.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test ActiveStateChangeOnChangingMutedOrVolume</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ActiveStateChange.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Alert.html b/dom/browser-element/mochitest/test_browserElement_inproc_Alert.html
new file mode 100644
index 000000000..03d03135d
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Alert.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=741587
+-->
+<head>
+  <title>Test for Bug 741587</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=741587">Mozilla Bug 741587</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Alert.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_AlertInFrame.html b/dom/browser-element/mochitest/test_browserElement_inproc_AlertInFrame.html
new file mode 100644
index 000000000..d797a1a3a
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_AlertInFrame.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for iframe mozbrowser</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AlertInFrame.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel.html b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel.html
new file mode 100644
index 000000000..6bba008d7
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element audioChannel.</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AudioChannel.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannelMutedByDefault.html b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannelMutedByDefault.html
new file mode 100644
index 000000000..304b1b8b4
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannelMutedByDefault.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1235535 - Audio Channel Muted-By-Default.</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AudioChannelMutedByDefault.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannelSeeking.html b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannelSeeking.html
new file mode 100644
index 000000000..a7834e929
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannelSeeking.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1225425 - Do not unregister the AudioChannelAgent during seeking</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AudioChannelSeeking.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel_nested.html b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel_nested.html
new file mode 100644
index 000000000..2ee58002c
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_AudioChannel_nested.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element audioChannel in nested mozbrowser iframes.</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AudioChannel_nested.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_AudioPlayback.html b/dom/browser-element/mochitest/test_browserElement_inproc_AudioPlayback.html
new file mode 100644
index 000000000..364eeff68
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_AudioPlayback.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1180824
+-->
+<head>
+  <title>Test for Bug 1180824</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1180824">Mozilla Bug 1180824</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_AudioPlayback.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Auth.html b/dom/browser-element/mochitest/test_browserElement_inproc_Auth.html
new file mode 100644
index 000000000..0dd60f8c6
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Auth.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=741587
+-->
+<head>
+  <title>Test for Bug 775464</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=775464">Mozilla Bug 775464</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Auth.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_BackForward.html b/dom/browser-element/mochitest/test_browserElement_inproc_BackForward.html
new file mode 100644
index 000000000..d841cc3e0
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_BackForward.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_BackForward.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_BadScreenshot.html b/dom/browser-element/mochitest/test_browserElement_inproc_BadScreenshot.html
new file mode 100644
index 000000000..8e4b61b33
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_BadScreenshot.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 800170</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_BadScreenshot.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_BrowserWindowNamespace.html b/dom/browser-element/mochitest/test_browserElement_inproc_BrowserWindowNamespace.html
new file mode 100644
index 000000000..3fafbe646
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_BrowserWindowNamespace.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 780351</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_BrowserWindowNamespace.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_BrowserWindowResize.html b/dom/browser-element/mochitest/test_browserElement_inproc_BrowserWindowResize.html
new file mode 100644
index 000000000..bcc86b872
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_BrowserWindowResize.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 891763</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_BrowserWindowResize.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Close.html b/dom/browser-element/mochitest/test_browserElement_inproc_Close.html
new file mode 100644
index 000000000..76d203f9d
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Close.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=757182
+-->
+<head>
+  <title>Test for Bug 757182</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=757182">Mozilla Bug 757182</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Close.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_CloseFromOpener.html b/dom/browser-element/mochitest/test_browserElement_inproc_CloseFromOpener.html
new file mode 100644
index 000000000..3c7ee4d87
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_CloseFromOpener.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=757182
+-->
+<head>
+  <title>Test for Bug 757182</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=757182">Mozilla Bug 757182</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_CloseFromOpener.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ContextmenuEvents.html b/dom/browser-element/mochitest/test_browserElement_inproc_ContextmenuEvents.html
new file mode 100644
index 000000000..a43f7dbef
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ContextmenuEvents.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Contextmenu Events</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ContextmenuEvents.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_CookiesNotThirdParty.html b/dom/browser-element/mochitest/test_browserElement_inproc_CookiesNotThirdParty.html
new file mode 100644
index 000000000..37ea16fb0
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_CookiesNotThirdParty.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 806127</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_CookiesNotThirdParty.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_CopyPaste.html b/dom/browser-element/mochitest/test_browserElement_inproc_CopyPaste.html
new file mode 100644
index 000000000..892245d4f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_CopyPaste.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=987040
+-->
+<head>
+  <title>Test for Bug 987040</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=987040">Mozilla Bug 987040</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_CopyPaste.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_DOMRequestError.html b/dom/browser-element/mochitest/test_browserElement_inproc_DOMRequestError.html
new file mode 100644
index 000000000..6a9e5bbba
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_DOMRequestError.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=787519
+-->
+<head>
+  <title>Test for Bug 787519</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=787519">Mozilla Bug 787519</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_DOMRequestError.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_DataURI.html b/dom/browser-element/mochitest/test_browserElement_inproc_DataURI.html
new file mode 100644
index 000000000..2ceb49cd0
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_DataURI.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=720157
+-->
+<head>
+  <title>Test for Bug 720157</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=720157">Mozilla Bug 720157</a>
+
+<script type='application/javascript;version=1.7' src='browserElement_DataURI.js'></script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_DocumentFirstPaint.html b/dom/browser-element/mochitest/test_browserElement_inproc_DocumentFirstPaint.html
new file mode 100644
index 000000000..3197adf66
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_DocumentFirstPaint.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 829486</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_DocumentFirstPaint.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Download.html b/dom/browser-element/mochitest/test_browserElement_inproc_Download.html
new file mode 100644
index 000000000..c2e5e2ed3
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Download.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 983747</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_Download.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ErrorSecurity.html b/dom/browser-element/mochitest/test_browserElement_inproc_ErrorSecurity.html
new file mode 100644
index 000000000..318d29831
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ErrorSecurity.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for mozbrowser</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ErrorSecurity.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ExecuteScript.html b/dom/browser-element/mochitest/test_browserElement_inproc_ExecuteScript.html
new file mode 100644
index 000000000..f63f31d42
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ExecuteScript.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1174733
+-->
+<head>
+  <title>Test for Bug 1163961</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1174733">Mozilla Bug 1174733</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_ExecuteScript.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ExposableURI.html b/dom/browser-element/mochitest/test_browserElement_inproc_ExposableURI.html
new file mode 100644
index 000000000..089e5db44
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ExposableURI.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=795317
+-->
+<head>
+  <title>Test for Bug 795317</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=795317">Mozilla Bug 795317</a>
+
+<script type="application/javascript;version1.7" src="browserElement_ExposableURI.js"></script>
+
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Find.html b/dom/browser-element/mochitest/test_browserElement_inproc_Find.html
new file mode 100644
index 000000000..386bc7882
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Find.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1163961
+-->
+<head>
+  <title>Test for Bug 1163961</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1163961">Mozilla Bug 1163961</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Find.js">
+</script>
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_FirstPaint.html b/dom/browser-element/mochitest/test_browserElement_inproc_FirstPaint.html
new file mode 100644
index 000000000..ee013860c
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_FirstPaint.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 787378</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_FirstPaint.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ForwardName.html b/dom/browser-element/mochitest/test_browserElement_inproc_ForwardName.html
new file mode 100644
index 000000000..f24691ff1
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ForwardName.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 781320</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ForwardName.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_FrameWrongURI.html b/dom/browser-element/mochitest/test_browserElement_inproc_FrameWrongURI.html
new file mode 100644
index 000000000..f0e6e6c20
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_FrameWrongURI.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_FrameWrongURI.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_GetContentDimensions.html b/dom/browser-element/mochitest/test_browserElement_inproc_GetContentDimensions.html
new file mode 100644
index 000000000..73b59800d
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_GetContentDimensions.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_GetContentDimensions.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_GetScreenshot.html b/dom/browser-element/mochitest/test_browserElement_inproc_GetScreenshot.html
new file mode 100644
index 000000000..cb246fc06
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_GetScreenshot.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=753595
+-->
+<head>
+  <title>Test for Bug 753595</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=753595">Mozilla Bug 753595</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_GetScreenshot.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_GetScreenshotDppx.html b/dom/browser-element/mochitest/test_browserElement_inproc_GetScreenshotDppx.html
new file mode 100644
index 000000000..dfc10d102
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_GetScreenshotDppx.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=959066
+-->
+<head>
+  <title>Test for Bug 959066</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=959066">Mozilla Bug 959066</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_GetScreenshotDppx.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Iconchange.html b/dom/browser-element/mochitest/test_browserElement_inproc_Iconchange.html
new file mode 100644
index 000000000..2f17287de
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Iconchange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=719461
+-->
+<head>
+  <title>Test for Bug 719461</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=719461">Mozilla Bug 719461</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Iconchange.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_LoadEvents.html b/dom/browser-element/mochitest/test_browserElement_inproc_LoadEvents.html
new file mode 100644
index 000000000..3370ff874
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_LoadEvents.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=710231
+-->
+<head>
+  <title>Test for Bug 710231</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=710231">Mozilla Bug 710231</a>
+
+<script type="application/javascript;version1.7" src="browserElement_LoadEvents.js"></script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Manifestchange.html b/dom/browser-element/mochitest/test_browserElement_inproc_Manifestchange.html
new file mode 100644
index 000000000..64200bd48
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Manifestchange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=982800
+-->
+<head>
+  <title>Test for Bug 982800</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=982800">Mozilla Bug 982800</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Manifestchange.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Metachange.html b/dom/browser-element/mochitest/test_browserElement_inproc_Metachange.html
new file mode 100644
index 000000000..d799a52e4
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Metachange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=962626
+-->
+<head>
+  <title>Test for Bug 962626</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=962626">Mozilla Bug 962626</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Metachange.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_NextPaint.html b/dom/browser-element/mochitest/test_browserElement_inproc_NextPaint.html
new file mode 100644
index 000000000..d9250a8db
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_NextPaint.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 808231</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_NextPaint.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_NoAudioTrack.html b/dom/browser-element/mochitest/test_browserElement_inproc_NoAudioTrack.html
new file mode 100644
index 000000000..77e33befa
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_NoAudioTrack.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1227051 - No audio track video shouldn't register the AudioChannelAgent</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_NoAudioTrack.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenMixedProcess.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenMixedProcess.html
new file mode 100644
index 000000000..1248c1772
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenMixedProcess.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 776129</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenMixedProcess.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenNamed.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenNamed.html
new file mode 100644
index 000000000..bbe12545c
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenNamed.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenNamed.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenTab.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenTab.html
new file mode 100644
index 000000000..85b979bd0
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenTab.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1144015
+-->
+<head>
+  <title>Test for Bug 1144015</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1144015">Mozilla Bug 1144015</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_OpenTab.js">
+</script>
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindow.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindow.html
new file mode 100644
index 000000000..7c249792f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindow.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindow.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowDifferentOrigin.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowDifferentOrigin.html
new file mode 100644
index 000000000..327ff8960
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowDifferentOrigin.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowDifferentOrigin.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowEmpty.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowEmpty.html
new file mode 100644
index 000000000..03738de71
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowEmpty.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 1216937</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowEmpty.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowInFrame.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowInFrame.html
new file mode 100644
index 000000000..e2c02d4a9
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowInFrame.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowInFrame.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowRejected.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowRejected.html
new file mode 100644
index 000000000..a96b378f6
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowRejected.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowRejected.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowRejected2.html b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowRejected2.html
new file mode 100644
index 000000000..a96b378f6
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_OpenWindowRejected2.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowRejected.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Opensearch.html b/dom/browser-element/mochitest/test_browserElement_inproc_Opensearch.html
new file mode 100644
index 000000000..23f21ed83
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Opensearch.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=883002
+-->
+<head>
+  <title>Test for Bug 883002</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=883002">Mozilla Bug 883002</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Opensearch.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_PrivateBrowsing.html b/dom/browser-element/mochitest/test_browserElement_inproc_PrivateBrowsing.html
new file mode 100644
index 000000000..0947fd7c7
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_PrivateBrowsing.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=832700
+-->
+<head>
+  <title>Test for Bug 832700</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=832700">Mozilla Bug 832700</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_PrivateBrowsing.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_PromptCheck.html b/dom/browser-element/mochitest/test_browserElement_inproc_PromptCheck.html
new file mode 100644
index 000000000..476c7e2c2
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_PromptCheck.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=741587
+-->
+<head>
+  <title>Test for Bug 741587</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=741587">Mozilla Bug 741587</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_PromptCheck.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_PromptConfirm.html b/dom/browser-element/mochitest/test_browserElement_inproc_PromptConfirm.html
new file mode 100644
index 000000000..b29a52025
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_PromptConfirm.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=741587
+-->
+<head>
+  <title>Test for Bug 741587</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=741587">Mozilla Bug 741587</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_PromptConfirm.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Proxy.html b/dom/browser-element/mochitest/test_browserElement_inproc_Proxy.html
new file mode 100644
index 000000000..05a416eee
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Proxy.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1196654
+-->
+<head>
+  <title>Test for Bug 1196654</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1196654">Mozilla Bug 1196654</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Proxy.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_PurgeHistory.html b/dom/browser-element/mochitest/test_browserElement_inproc_PurgeHistory.html
new file mode 100644
index 000000000..1c052996c
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_PurgeHistory.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_PurgeHistory.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Reload.html b/dom/browser-element/mochitest/test_browserElement_inproc_Reload.html
new file mode 100644
index 000000000..75b912b19
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Reload.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_Reload.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ReloadPostRequest.html b/dom/browser-element/mochitest/test_browserElement_inproc_ReloadPostRequest.html
new file mode 100644
index 000000000..d26e7a0b5
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ReloadPostRequest.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ReloadPostRequest.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_RemoveBrowserElement.html b/dom/browser-element/mochitest/test_browserElement_inproc_RemoveBrowserElement.html
new file mode 100644
index 000000000..8ccbe09a7
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_RemoveBrowserElement.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=787517
+-->
+<head>
+  <title>Test for Bug 787517</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=787517">Mozilla Bug 787517</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_RemoveBrowserElement.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ScrollEvent.html b/dom/browser-element/mochitest/test_browserElement_inproc_ScrollEvent.html
new file mode 100644
index 000000000..e87792243
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ScrollEvent.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=770847
+-->
+<head>
+  <title>Test for Bug 770847</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=770847">Mozilla Bug 770847</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_ScrollEvent.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_SecurityChange.html b/dom/browser-element/mochitest/test_browserElement_inproc_SecurityChange.html
new file mode 100644
index 000000000..ceaa6a40e
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_SecurityChange.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_SecurityChange.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_SendEvent.html b/dom/browser-element/mochitest/test_browserElement_inproc_SendEvent.html
new file mode 100644
index 000000000..5eee91ed7
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_SendEvent.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=774809
+-->
+<head>
+  <title>Test for Bug 774809</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=774809">Mozilla Bug 774809</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_SendEvent.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_SetInputMethodActive.html b/dom/browser-element/mochitest/test_browserElement_inproc_SetInputMethodActive.html
new file mode 100644
index 000000000..957bf82fc
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_SetInputMethodActive.html
@@ -0,0 +1,14 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 905573</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_SetInputMethodActive.js">
+</script>
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_SetVisible.html b/dom/browser-element/mochitest/test_browserElement_inproc_SetVisible.html
new file mode 100644
index 000000000..6241d4b1f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_SetVisible.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=702880
+-->
+ <head>
+  <title>Test for Bug 702880</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=753595">Mozilla Bug 702880</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_SetVisible.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_SetVisibleFrames.html b/dom/browser-element/mochitest/test_browserElement_inproc_SetVisibleFrames.html
new file mode 100644
index 000000000..8ae182285
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_SetVisibleFrames.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 762939</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_SetVisibleFrames.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_SetVisibleFrames2.html b/dom/browser-element/mochitest/test_browserElement_inproc_SetVisibleFrames2.html
new file mode 100644
index 000000000..17d161a95
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_SetVisibleFrames2.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 762939</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_SetVisibleFrames2.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Stop.html b/dom/browser-element/mochitest/test_browserElement_inproc_Stop.html
new file mode 100644
index 000000000..42c32da7e
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Stop.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_Stop.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_TargetBlank.html b/dom/browser-element/mochitest/test_browserElement_inproc_TargetBlank.html
new file mode 100644
index 000000000..916ed312b
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_TargetBlank.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for mozbrowser</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_TargetBlank.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_TargetTop.html b/dom/browser-element/mochitest/test_browserElement_inproc_TargetTop.html
new file mode 100644
index 000000000..6c99f1c21
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_TargetTop.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 771273</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_TargetTop.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_ThemeColor.html b/dom/browser-element/mochitest/test_browserElement_inproc_ThemeColor.html
new file mode 100644
index 000000000..4075ce58d
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_ThemeColor.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1013913
+-->
+<head>
+  <title>Test for Bug 1013913</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1013913">Mozilla Bug 1013913</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_ThemeColor.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Titlechange.html b/dom/browser-element/mochitest/test_browserElement_inproc_Titlechange.html
new file mode 100644
index 000000000..1fdde48c1
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Titlechange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=720157
+-->
+<head>
+  <title>Test for Bug 720157</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=720157">Mozilla Bug 720157</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_Titlechange.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_TopBarrier.html b/dom/browser-element/mochitest/test_browserElement_inproc_TopBarrier.html
new file mode 100644
index 000000000..c77a7a9ec
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_TopBarrier.html
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=725796
+-->
+<head>
+  <title>Test for Bug 725796</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=725796">Mozilla Bug 725796</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_TopBarrier.js">
+</script>
+
+</body>
+</html>
+
+
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_Viewmode.html b/dom/browser-element/mochitest/test_browserElement_inproc_Viewmode.html
new file mode 100644
index 000000000..286dd3989
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_Viewmode.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1162844
+-->
+<head>
+  <title>Test for Bug 1162844</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1162844">Mozilla Bug 1162844</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Viewmode.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_VisibilityChange.html b/dom/browser-element/mochitest/test_browserElement_inproc_VisibilityChange.html
new file mode 100644
index 000000000..ce4251a42
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_VisibilityChange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=868816
+-->
+<head>
+  <title>Test for Bug 868816</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=868816">Mozilla Bug 868816</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_VisibilityChange.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptions.html b/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptions.html
new file mode 100644
index 000000000..36479ee06
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptions.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 770239</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_XFrameOptions.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsAllowFrom.html b/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsAllowFrom.html
new file mode 100644
index 000000000..801c7879f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsAllowFrom.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 690168</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_XFrameOptionsAllowFrom.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsDeny.html b/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsDeny.html
new file mode 100644
index 000000000..edd91dbd7
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsDeny.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 770239</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_XFrameOptionsDeny.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsSameOrigin.html b/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsSameOrigin.html
new file mode 100644
index 000000000..e0ecbabc4
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_XFrameOptionsSameOrigin.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 770239</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_XFrameOptionsSameOrigin.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_inproc_getWebManifest.html b/dom/browser-element/mochitest/test_browserElement_inproc_getWebManifest.html
new file mode 100644
index 000000000..1252de5e5
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_inproc_getWebManifest.html
@@ -0,0 +1,17 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 1169633</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.8"
+  src="async.js">
+</script>
+<script type="application/javascript;version=1.8"
+  src="browserElement_getWebManifest.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ActiveStateChange.html b/dom/browser-element/mochitest/test_browserElement_oop_ActiveStateChange.html
new file mode 100644
index 000000000..4a14ad7cb
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ActiveStateChange.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test ActiveStateChangeOnChangingMutedOrVolume</title>
+  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ActiveStateChange.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Alert.html b/dom/browser-element/mochitest/test_browserElement_oop_Alert.html
new file mode 100644
index 000000000..03d03135d
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Alert.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=741587
+-->
+<head>
+  <title>Test for Bug 741587</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=741587">Mozilla Bug 741587</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Alert.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_AlertInFrame.html b/dom/browser-element/mochitest/test_browserElement_oop_AlertInFrame.html
new file mode 100644
index 000000000..d797a1a3a
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_AlertInFrame.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for iframe mozbrowser</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AlertInFrame.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel.html b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel.html
new file mode 100644
index 000000000..34909e904
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element audioChannel.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AudioChannel.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_AudioChannelMutedByDefault.html b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannelMutedByDefault.html
new file mode 100644
index 000000000..60bead59f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannelMutedByDefault.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1235535 - Audio Channel Muted-By-Default.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AudioChannelMutedByDefault.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_AudioChannelSeeking.html b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannelSeeking.html
new file mode 100644
index 000000000..54c3a1fb4
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannelSeeking.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1225425 - Do not unregister the AudioChannelAgent during seeking</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AudioChannelSeeking.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel_nested.html b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel_nested.html
new file mode 100644
index 000000000..d189a7ca4
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_AudioChannel_nested.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element audioChannel.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_AudioChannel_nested.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_AudioPlayback.html b/dom/browser-element/mochitest/test_browserElement_oop_AudioPlayback.html
new file mode 100644
index 000000000..bb3a1c2d6
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_AudioPlayback.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1180824
+-->
+<head>
+  <title>Test for Bug 1180824</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1180824">Mozilla Bug 1180824</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_AudioPlayback.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Auth.html b/dom/browser-element/mochitest/test_browserElement_oop_Auth.html
new file mode 100644
index 000000000..0dd60f8c6
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Auth.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=741587
+-->
+<head>
+  <title>Test for Bug 775464</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=775464">Mozilla Bug 775464</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Auth.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_BackForward.html b/dom/browser-element/mochitest/test_browserElement_oop_BackForward.html
new file mode 100644
index 000000000..e5d753b5e
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_BackForward.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_BackForward.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_BadScreenshot.html b/dom/browser-element/mochitest/test_browserElement_oop_BadScreenshot.html
new file mode 100644
index 000000000..5713b512e
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_BadScreenshot.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 800170</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_BadScreenshot.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_BrowserWindowResize.html b/dom/browser-element/mochitest/test_browserElement_oop_BrowserWindowResize.html
new file mode 100644
index 000000000..bcc86b872
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_BrowserWindowResize.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 891763</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_BrowserWindowResize.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Close.html b/dom/browser-element/mochitest/test_browserElement_oop_Close.html
new file mode 100644
index 000000000..76d203f9d
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Close.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=757182
+-->
+<head>
+  <title>Test for Bug 757182</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=757182">Mozilla Bug 757182</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Close.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_CloseFromOpener.html b/dom/browser-element/mochitest/test_browserElement_oop_CloseFromOpener.html
new file mode 100644
index 000000000..3c7ee4d87
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_CloseFromOpener.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=757182
+-->
+<head>
+  <title>Test for Bug 757182</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=757182">Mozilla Bug 757182</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_CloseFromOpener.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ContextmenuEvents.html b/dom/browser-element/mochitest/test_browserElement_oop_ContextmenuEvents.html
new file mode 100644
index 000000000..a43f7dbef
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ContextmenuEvents.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Contextmenu Events</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ContextmenuEvents.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_CookiesNotThirdParty.html b/dom/browser-element/mochitest/test_browserElement_oop_CookiesNotThirdParty.html
new file mode 100644
index 000000000..37ea16fb0
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_CookiesNotThirdParty.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 806127</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_CookiesNotThirdParty.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_CopyPaste.html b/dom/browser-element/mochitest/test_browserElement_oop_CopyPaste.html
new file mode 100644
index 000000000..892245d4f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_CopyPaste.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=987040
+-->
+<head>
+  <title>Test for Bug 987040</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=987040">Mozilla Bug 987040</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_CopyPaste.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_DOMRequestError.html b/dom/browser-element/mochitest/test_browserElement_oop_DOMRequestError.html
new file mode 100644
index 000000000..48d404cc3
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_DOMRequestError.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=787519
+-->
+<head>
+  <title>Test for Bug 787519</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=787519">Mozilla Bug 787519</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_DOMRequestError.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_DataURI.html b/dom/browser-element/mochitest/test_browserElement_oop_DataURI.html
new file mode 100644
index 000000000..2ceb49cd0
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_DataURI.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=720157
+-->
+<head>
+  <title>Test for Bug 720157</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=720157">Mozilla Bug 720157</a>
+
+<script type='application/javascript;version=1.7' src='browserElement_DataURI.js'></script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_DocumentFirstPaint.html b/dom/browser-element/mochitest/test_browserElement_oop_DocumentFirstPaint.html
new file mode 100644
index 000000000..6667a76eb
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_DocumentFirstPaint.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 829486</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_DocumentFirstPaint.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Download.html b/dom/browser-element/mochitest/test_browserElement_oop_Download.html
new file mode 100644
index 000000000..c2e5e2ed3
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Download.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 983747</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_Download.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ErrorSecurity.html b/dom/browser-element/mochitest/test_browserElement_oop_ErrorSecurity.html
new file mode 100644
index 000000000..318d29831
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ErrorSecurity.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for mozbrowser</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ErrorSecurity.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ExecuteScript.html b/dom/browser-element/mochitest/test_browserElement_oop_ExecuteScript.html
new file mode 100644
index 000000000..e3bbabfa0
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ExecuteScript.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1174733
+-->
+<head>
+  <title>Test for Bug 1163961</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1174733">Mozilla Bug 1174733</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_ExecuteScript.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ExposableURI.html b/dom/browser-element/mochitest/test_browserElement_oop_ExposableURI.html
new file mode 100644
index 000000000..089e5db44
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ExposableURI.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=795317
+-->
+<head>
+  <title>Test for Bug 795317</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=795317">Mozilla Bug 795317</a>
+
+<script type="application/javascript;version1.7" src="browserElement_ExposableURI.js"></script>
+
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Find.html b/dom/browser-element/mochitest/test_browserElement_oop_Find.html
new file mode 100644
index 000000000..e0333a6bb
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Find.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1163961
+-->
+<head>
+  <title>Test for Bug 1163961</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1163961">Mozilla Bug 1163961</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Find.js">
+</script>
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_FirstPaint.html b/dom/browser-element/mochitest/test_browserElement_oop_FirstPaint.html
new file mode 100644
index 000000000..ee013860c
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_FirstPaint.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 787378</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_FirstPaint.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ForwardName.html b/dom/browser-element/mochitest/test_browserElement_oop_ForwardName.html
new file mode 100644
index 000000000..f24691ff1
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ForwardName.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 781320</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ForwardName.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_FrameWrongURI.html b/dom/browser-element/mochitest/test_browserElement_oop_FrameWrongURI.html
new file mode 100644
index 000000000..f0e6e6c20
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_FrameWrongURI.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_FrameWrongURI.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_GetContentDimensions.html b/dom/browser-element/mochitest/test_browserElement_oop_GetContentDimensions.html
new file mode 100644
index 000000000..067615c1b
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_GetContentDimensions.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_GetContentDimensions.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_GetScreenshot.html b/dom/browser-element/mochitest/test_browserElement_oop_GetScreenshot.html
new file mode 100644
index 000000000..81d3e1993
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_GetScreenshot.html
@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=753595
+-->
+<head>
+  <title>Test for Bug 753595</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=753595">Mozilla Bug 753595</a>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=878003">Mozilla Bug 878003</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_GetScreenshot.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_GetScreenshotDppx.html b/dom/browser-element/mochitest/test_browserElement_oop_GetScreenshotDppx.html
new file mode 100644
index 000000000..9d30fc541
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_GetScreenshotDppx.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=959066
+-->
+<head>
+  <title>Test for Bug 959066</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=959066">Mozilla Bug 959066</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_GetScreenshotDppx.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Iconchange.html b/dom/browser-element/mochitest/test_browserElement_oop_Iconchange.html
new file mode 100644
index 000000000..2f17287de
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Iconchange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=719461
+-->
+<head>
+  <title>Test for Bug 719461</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=719461">Mozilla Bug 719461</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Iconchange.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_LoadEvents.html b/dom/browser-element/mochitest/test_browserElement_oop_LoadEvents.html
new file mode 100644
index 000000000..c6daf805e
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_LoadEvents.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=710231
+-->
+<head>
+  <title>Test for Bug 710231</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=710231">Mozilla Bug 710231</a>
+
+<script type="application/javascript;version1.7" src="browserElement_LoadEvents.js"></script>
+
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Manifestchange.html b/dom/browser-element/mochitest/test_browserElement_oop_Manifestchange.html
new file mode 100644
index 000000000..64200bd48
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Manifestchange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=982800
+-->
+<head>
+  <title>Test for Bug 982800</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=982800">Mozilla Bug 982800</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Manifestchange.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Metachange.html b/dom/browser-element/mochitest/test_browserElement_oop_Metachange.html
new file mode 100644
index 000000000..d799a52e4
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Metachange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=962626
+-->
+<head>
+  <title>Test for Bug 962626</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=962626">Mozilla Bug 962626</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Metachange.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_NextPaint.html b/dom/browser-element/mochitest/test_browserElement_oop_NextPaint.html
new file mode 100644
index 000000000..8144819f2
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_NextPaint.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 808231</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_NextPaint.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_NoAudioTrack.html b/dom/browser-element/mochitest/test_browserElement_oop_NoAudioTrack.html
new file mode 100644
index 000000000..90782bc63
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_NoAudioTrack.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1227051 - No audio track video shouldn't register the AudioChannelAgent</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_NoAudioTrack.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenMixedProcess.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenMixedProcess.html
new file mode 100644
index 000000000..cefe06c3e
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenMixedProcess.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 776129</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenMixedProcess.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenNamed.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenNamed.html
new file mode 100644
index 000000000..bbe12545c
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenNamed.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenNamed.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenTab.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenTab.html
new file mode 100644
index 000000000..85b979bd0
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenTab.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1144015
+-->
+<head>
+  <title>Test for Bug 1144015</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1144015">Mozilla Bug 1144015</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_OpenTab.js">
+</script>
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenWindow.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindow.html
new file mode 100644
index 000000000..7c249792f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindow.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindow.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowDifferentOrigin.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowDifferentOrigin.html
new file mode 100644
index 000000000..327ff8960
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowDifferentOrigin.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowDifferentOrigin.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowEmpty.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowEmpty.html
new file mode 100644
index 000000000..03738de71
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowEmpty.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 1216937</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowEmpty.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowInFrame.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowInFrame.html
new file mode 100644
index 000000000..e2c02d4a9
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowInFrame.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowInFrame.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowRejected.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowRejected.html
new file mode 100644
index 000000000..a96b378f6
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowRejected.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowRejected.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowRejected2.html b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowRejected2.html
new file mode 100644
index 000000000..a96b378f6
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_OpenWindowRejected2.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_OpenWindowRejected.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Opensearch.html b/dom/browser-element/mochitest/test_browserElement_oop_Opensearch.html
new file mode 100644
index 000000000..23f21ed83
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Opensearch.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=883002
+-->
+<head>
+  <title>Test for Bug 883002</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=883002">Mozilla Bug 883002</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Opensearch.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_PrivateBrowsing.html b/dom/browser-element/mochitest/test_browserElement_oop_PrivateBrowsing.html
new file mode 100644
index 000000000..0947fd7c7
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_PrivateBrowsing.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=832700
+-->
+<head>
+  <title>Test for Bug 832700</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=832700">Mozilla Bug 832700</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_PrivateBrowsing.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_PromptCheck.html b/dom/browser-element/mochitest/test_browserElement_oop_PromptCheck.html
new file mode 100644
index 000000000..476c7e2c2
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_PromptCheck.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=741587
+-->
+<head>
+  <title>Test for Bug 741587</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=741587">Mozilla Bug 741587</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_PromptCheck.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_PromptConfirm.html b/dom/browser-element/mochitest/test_browserElement_oop_PromptConfirm.html
new file mode 100644
index 000000000..b29a52025
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_PromptConfirm.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=741587
+-->
+<head>
+  <title>Test for Bug 741587</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=741587">Mozilla Bug 741587</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_PromptConfirm.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Proxy.html b/dom/browser-element/mochitest/test_browserElement_oop_Proxy.html
new file mode 100644
index 000000000..05a416eee
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Proxy.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1196654
+-->
+<head>
+  <title>Test for Bug 1196654</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1196654">Mozilla Bug 1196654</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Proxy.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_PurgeHistory.html b/dom/browser-element/mochitest/test_browserElement_oop_PurgeHistory.html
new file mode 100644
index 000000000..cf606fd80
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_PurgeHistory.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_PurgeHistory.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Reload.html b/dom/browser-element/mochitest/test_browserElement_oop_Reload.html
new file mode 100644
index 000000000..75b912b19
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Reload.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_Reload.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ReloadPostRequest.html b/dom/browser-element/mochitest/test_browserElement_oop_ReloadPostRequest.html
new file mode 100644
index 000000000..d26e7a0b5
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ReloadPostRequest.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_ReloadPostRequest.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_RemoveBrowserElement.html b/dom/browser-element/mochitest/test_browserElement_oop_RemoveBrowserElement.html
new file mode 100644
index 000000000..8ccbe09a7
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_RemoveBrowserElement.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=787517
+-->
+<head>
+  <title>Test for Bug 787517</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=787517">Mozilla Bug 787517</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_RemoveBrowserElement.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ScrollEvent.html b/dom/browser-element/mochitest/test_browserElement_oop_ScrollEvent.html
new file mode 100644
index 000000000..e87792243
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ScrollEvent.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=770847
+-->
+<head>
+  <title>Test for Bug 770847</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=770847">Mozilla Bug 770847</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_ScrollEvent.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_SecurityChange.html b/dom/browser-element/mochitest/test_browserElement_oop_SecurityChange.html
new file mode 100644
index 000000000..ceaa6a40e
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_SecurityChange.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_SecurityChange.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_SendEvent.html b/dom/browser-element/mochitest/test_browserElement_oop_SendEvent.html
new file mode 100644
index 000000000..38d16a9da
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_SendEvent.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=774809
+-->
+<head>
+  <title>Test for Bug 774809</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=774809">Mozilla Bug 774809</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_SendEvent.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_SetInputMethodActive.html b/dom/browser-element/mochitest/test_browserElement_oop_SetInputMethodActive.html
new file mode 100644
index 000000000..5d4b45bc8
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_SetInputMethodActive.html
@@ -0,0 +1,14 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 905573</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_SetInputMethodActive.js">
+</script>
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_SetVisible.html b/dom/browser-element/mochitest/test_browserElement_oop_SetVisible.html
new file mode 100644
index 000000000..a2220d1b3
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_SetVisible.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=702880
+-->
+ <head>
+  <title>Test for Bug 702880</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=753595">Mozilla Bug 702880</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_SetVisible.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_SetVisibleFrames.html b/dom/browser-element/mochitest/test_browserElement_oop_SetVisibleFrames.html
new file mode 100644
index 000000000..b6477c870
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_SetVisibleFrames.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 762939</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_SetVisibleFrames.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_SetVisibleFrames2.html b/dom/browser-element/mochitest/test_browserElement_oop_SetVisibleFrames2.html
new file mode 100644
index 000000000..108080f50
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_SetVisibleFrames2.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 762939</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_SetVisibleFrames2.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Stop.html b/dom/browser-element/mochitest/test_browserElement_oop_Stop.html
new file mode 100644
index 000000000..3425944e8
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Stop.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test of browser element.</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_Stop.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_TargetBlank.html b/dom/browser-element/mochitest/test_browserElement_oop_TargetBlank.html
new file mode 100644
index 000000000..916ed312b
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_TargetBlank.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for mozbrowser</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_TargetBlank.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_TargetTop.html b/dom/browser-element/mochitest/test_browserElement_oop_TargetTop.html
new file mode 100644
index 000000000..6c99f1c21
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_TargetTop.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 771273</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_TargetTop.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_ThemeColor.html b/dom/browser-element/mochitest/test_browserElement_oop_ThemeColor.html
new file mode 100644
index 000000000..4075ce58d
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_ThemeColor.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1013913
+-->
+<head>
+  <title>Test for Bug 1013913</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1013913">Mozilla Bug 1013913</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_ThemeColor.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Titlechange.html b/dom/browser-element/mochitest/test_browserElement_oop_Titlechange.html
new file mode 100644
index 000000000..1fdde48c1
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Titlechange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=720157
+-->
+<head>
+  <title>Test for Bug 720157</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=720157">Mozilla Bug 720157</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_Titlechange.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_TopBarrier.html b/dom/browser-element/mochitest/test_browserElement_oop_TopBarrier.html
new file mode 100644
index 000000000..8756b4455
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_TopBarrier.html
@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=725796
+-->
+<head>
+  <title>Test for Bug 725796</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=725796">Mozilla Bug 725796</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_TopBarrier.js">
+</script>
+
+</body>
+</html>
+
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_Viewmode.html b/dom/browser-element/mochitest/test_browserElement_oop_Viewmode.html
new file mode 100644
index 000000000..286dd3989
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_Viewmode.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1162844
+-->
+<head>
+  <title>Test for Bug 1162844</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1162844">Mozilla Bug 1162844</a>
+
+<script type="application/javascript;version=1.7" src="browserElement_Viewmode.js">
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_VisibilityChange.html b/dom/browser-element/mochitest/test_browserElement_oop_VisibilityChange.html
new file mode 100644
index 000000000..546882c1c
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_VisibilityChange.html
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=868816
+-->
+<head>
+  <title>Test for Bug 868816</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=868816">Mozilla Bug 868816</a>
+
+<script type="application/javascript;version=1.7" src='browserElement_VisibilityChange.js'>
+</script>
+
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptions.html b/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptions.html
new file mode 100644
index 000000000..36479ee06
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptions.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 770239</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_XFrameOptions.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsAllowFrom.html b/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsAllowFrom.html
new file mode 100644
index 000000000..801c7879f
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsAllowFrom.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 690168</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_XFrameOptionsAllowFrom.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsDeny.html b/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsDeny.html
new file mode 100644
index 000000000..edd91dbd7
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsDeny.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 770239</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_XFrameOptionsDeny.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsSameOrigin.html b/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsSameOrigin.html
new file mode 100644
index 000000000..e0ecbabc4
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_XFrameOptionsSameOrigin.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 770239</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.7" src="browserElement_XFrameOptionsSameOrigin.js">
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dom/browser-element/mochitest/test_browserElement_oop_getWebManifest.html b/dom/browser-element/mochitest/test_browserElement_oop_getWebManifest.html
new file mode 100644
index 000000000..4ee13d924
--- /dev/null
+++ b/dom/browser-element/mochitest/test_browserElement_oop_getWebManifest.html
@@ -0,0 +1,16 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Test for Bug 1169633</title>
+  <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="/tests/dom/browser-element/mochitest/browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script type="application/javascript;version=1.8"
+  src="async.js"></script>
+<script type="application/javascript;version=1.8"
+  src="browserElement_getWebManifest.js">
+</script>
+</body>
+</html>
diff --git a/dom/browser-element/moz.build b/dom/browser-element/moz.build
new file mode 100644
index 000000000..0b00a2e06
--- /dev/null
+++ b/dom/browser-element/moz.build
@@ -0,0 +1,60 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+EXPORTS.mozilla += [
+    'BrowserElementParent.h',
+]
+
+EXPORTS.mozilla.dom += [
+    'BrowserElementAudioChannel.h',
+]
+
+SOURCES += [
+    'BrowserElementAudioChannel.cpp',
+    'BrowserElementParent.cpp',
+]
+
+XPIDL_SOURCES += [
+    'nsIBrowserElementAPI.idl',
+]
+
+XPIDL_MODULE = 'browser-element'
+
+EXTRA_COMPONENTS += [
+    'BrowserElementParent.js',
+    'BrowserElementParent.manifest',
+    'BrowserElementProxy.js',
+    'BrowserElementProxy.manifest',
+]
+
+EXTRA_JS_MODULES += [
+    'BrowserElementPromptService.jsm',
+]
+
+LOCAL_INCLUDES += [
+    '/dom/html',
+]
+
+include('/ipc/chromium/chromium-config.mozbuild')
+
+FINAL_LIBRARY = 'xul'
+
+LOCAL_INCLUDES += [
+    '/dom/',
+    '/dom/base',
+    '/dom/ipc',
+]
+
+MOCHITEST_MANIFESTS += [
+    'mochitest/mochitest-oop.ini',
+    'mochitest/mochitest.ini',
+    'mochitest/priority/mochitest.ini',
+]
+
+MOCHITEST_CHROME_MANIFESTS += [
+    'mochitest/chrome.ini',
+    'mochitest/priority/chrome.ini',
+]
diff --git a/dom/browser-element/nsIBrowserElementAPI.idl b/dom/browser-element/nsIBrowserElementAPI.idl
new file mode 100644
index 000000000..0833d53b0
--- /dev/null
+++ b/dom/browser-element/nsIBrowserElementAPI.idl
@@ -0,0 +1,112 @@
+/* -*- Mode: IDL; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "nsISupports.idl"
+
+interface nsIDOMDOMRequest;
+interface nsIFrameLoader;
+
+[scriptable, function, uuid(00d0e19d-bd67-491f-8e85-b9905224d3bb)]
+interface nsIBrowserElementNextPaintListener : nsISupports
+{
+  void recvNextPaint();
+};
+
+%{C++
+#define BROWSER_ELEMENT_API_CONTRACTID "@mozilla.org/dom/browser-element-api;1"
+#define BROWSER_ELEMENT_API_CID                                 \
+    { 0x651db7e3, 0x1734, 0x4536,                               \
+      { 0xb1, 0x5a, 0x5b, 0x3a, 0xe6, 0x44, 0x13, 0x4c } }
+%}
+
+/**
+ * Interface to the BrowserElementParent implementation. All methods
+ * but setFrameLoader throw when the remote process is dead.
+ */
+[scriptable, uuid(57758c10-6036-11e5-a837-0800200c9a66)]
+interface nsIBrowserElementAPI : nsISupports
+{
+  const long FIND_CASE_SENSITIVE = 0;
+  const long FIND_CASE_INSENSITIVE = 1;
+
+  const long FIND_FORWARD = 0;
+  const long FIND_BACKWARD = 1;
+
+  /**
+   * Notify frame scripts that support the API to destroy.
+   */
+  void destroyFrameScripts();
+
+  void setFrameLoader(in nsIFrameLoader frameLoader);
+
+  void setVisible(in boolean visible);
+  nsIDOMDOMRequest getVisible();
+  void setActive(in boolean active);
+  boolean getActive();
+
+  void sendMouseEvent(in DOMString type,
+                      in uint32_t x,
+                      in uint32_t y,
+                      in uint32_t button,
+                      in uint32_t clickCount,
+                      in uint32_t mifiers);
+  void sendTouchEvent(in DOMString aType,
+                      [const, array, size_is(count)] in uint32_t aIdentifiers,
+                      [const, array, size_is(count)] in int32_t aXs,
+                      [const, array, size_is(count)] in int32_t aYs,
+                      [const, array, size_is(count)] in uint32_t aRxs,
+                      [const, array, size_is(count)] in uint32_t aRys,
+                      [const, array, size_is(count)] in float aRotationAngles,
+                      [const, array, size_is(count)] in float aForces,
+                      in uint32_t count,
+                      in long aModifiers);
+  void goBack();
+  void goForward();
+  void reload(in boolean hardReload);
+  void stop();
+  nsIDOMDOMRequest download(in DOMString url,
+                            [optional] in jsval options);
+  nsIDOMDOMRequest purgeHistory();
+  nsIDOMDOMRequest getScreenshot(in uint32_t width,
+                                 in uint32_t height,
+                                 [optional] in DOMString mimeType);
+  void zoom(in float zoom);
+  nsIDOMDOMRequest getCanGoBack();
+  nsIDOMDOMRequest getCanGoForward();
+  nsIDOMDOMRequest getContentDimensions();
+
+  void findAll(in DOMString searchString, in long caseSensitivity);
+  void findNext(in long direction);
+  void clearMatch();
+
+  void mute();
+  void unmute();
+  nsIDOMDOMRequest getMuted();
+
+  void setVolume(in float volume);
+  nsIDOMDOMRequest getVolume();
+
+  void addNextPaintListener(in nsIBrowserElementNextPaintListener listener);
+  void removeNextPaintListener(in nsIBrowserElementNextPaintListener listener);
+
+  nsIDOMDOMRequest setInputMethodActive(in boolean isActive);
+
+  nsIDOMDOMRequest getAudioChannelVolume(in uint32_t audioChannel);
+  nsIDOMDOMRequest setAudioChannelVolume(in uint32_t audioChannel, in float volume);
+
+  nsIDOMDOMRequest getAudioChannelMuted(in uint32_t audioChannel);
+  nsIDOMDOMRequest setAudioChannelMuted(in uint32_t audioChannel, in bool muted);
+
+  nsIDOMDOMRequest isAudioChannelActive(in uint32_t audioChannel);
+
+  nsIDOMDOMRequest executeScript(in DOMString script, in jsval options);
+
+  /**
+   * Returns an object that represents a Web Manifest:
+   * http://w3c.github.io/manifest/
+   */
+  nsIDOMDOMRequest getWebManifest();
+};