From 1cfc5531f66643c5acb19aeedc271ef58aa80cc7 Mon Sep 17 00:00:00 2001
From: Reuben Morais <reuben.morais@gmail.com>
Date: Thu, 25 Apr 2013 08:40:18 -0700
Subject: [PATCH 01/13] Bug 862250 - Make 'equals' searches on tel only match
 the value entered by the user. r=gwagner

--HG--
extra : rebase_source : 2652c484e01b9b6bb8c27212fc76cb5d9ddfba2d
---
 dom/contacts/fallback/ContactDB.jsm          | 34 ++++++++++++--
 dom/contacts/tests/test_contacts_basics.html | 47 ++++++++++++++++++--
 2 files changed, 73 insertions(+), 8 deletions(-)

diff --git a/dom/contacts/fallback/ContactDB.jsm b/dom/contacts/fallback/ContactDB.jsm
index 0b244163227..1e0249c66ea 100644
--- a/dom/contacts/fallback/ContactDB.jsm
+++ b/dom/contacts/fallback/ContactDB.jsm
@@ -19,7 +19,7 @@ Cu.import("resource://gre/modules/PhoneNumberUtils.jsm");
 Cu.import("resource://gre/modules/Timer.jsm");
 
 const DB_NAME = "contacts";
-const DB_VERSION = 8;
+const DB_VERSION = 9;
 const STORE_NAME = "contacts";
 const SAVED_GETALL_STORE_NAME = "getallcache";
 const CHUNK_SIZE = 20;
@@ -315,6 +315,28 @@ ContactDB.prototype = {
       } else if (currVersion == 7) {
         if (DEBUG) debug("Adding object store for cached searches");
         db.createObjectStore(SAVED_GETALL_STORE_NAME);
+      } else if (currVersion == 8) {
+        if (DEBUG) debug("Make exactTel only contain the value entered by the user");
+        if (!objectStore) {
+          objectStore = aTransaction.objectStore(STORE_NAME);
+        }
+
+        objectStore.openCursor().onsuccess = function(event) {
+          let cursor = event.target.result;
+          if (cursor) {
+            if (cursor.value.properties.tel) {
+              cursor.value.search.exactTel = [];
+              cursor.value.properties.tel.forEach(
+                function(tel) {
+                  let normalized = PhoneNumberUtils.normalize(tel.value.toString());
+                  cursor.value.search.exactTel.push(normalized);
+                }
+              );
+              cursor.update(cursor.value);
+            }
+            cursor.continue();
+          }
+        };
       }
     }
 
@@ -417,9 +439,10 @@ ContactDB.prototype = {
 
               // Chop off the first characters
               let number = aContact.properties[field][i].value;
-              contact.search.exactTel.push(number);
               let search = {};
               if (number) {
+                number = number.toString();
+                contact.search.exactTel.push(PhoneNumberUtils.normalize(number));
                 for (let i = 0; i < number.length; i++) {
                   search[number.substring(i, number.length)] = 1;
                 }
@@ -442,7 +465,6 @@ ContactDB.prototype = {
                   }
                   if (parsedNumber.internationalNumber &&
                       number.toString() !== parsedNumber.internationalNumber) {
-                    contact.search.exactTel.push(parsedNumber.internationalNumber);
                     let digits = parsedNumber.internationalNumber.match(/\d/g);
                     if (digits) {
                       digits = digits.join('');
@@ -775,7 +797,11 @@ ContactDB.prototype = {
         if (DEBUG) debug("Getting index: " + key);
         // case sensitive
         let index = store.index(key);
-        request = index.mozGetAll(options.filterValue, limit);
+        let filterValue = options.filterValue;
+        if (key == "tel") {
+          filterValue = PhoneNumberUtils.normalize(filterValue);
+        }
+        request = index.mozGetAll(filterValue, limit);
       } else {
         // not case sensitive
         let tmp = typeof options.filterValue == "string"
diff --git a/dom/contacts/tests/test_contacts_basics.html b/dom/contacts/tests/test_contacts_basics.html
index 8393efda273..1457f275556 100644
--- a/dom/contacts/tests/test_contacts_basics.html
+++ b/dom/contacts/tests/test_contacts_basics.html
@@ -87,7 +87,7 @@ var properties1 = {
   familyName: ["TestFamilyName","Wagner"],
   givenName: ["Test1","Test2"],
   nickname: "nicktest",
-  tel: [{type: ["work"], value: "123456", carrier: "testCarrier"} , {type: ["home", "fax"], value: "+9-876-5432"}],
+  tel: [{type: ["work"], value: "123456", carrier: "testCarrier"} , {type: ["home", "fax"], value: "+55 (31) 9876-3456"}],
   adr: adr1,
   email: [{type: ["work"], value: "x@y.com"}]
 };
@@ -333,12 +333,12 @@ var steps = [
       checkContacts(createResult1, properties1);
       dump("findResult: " + JSON.stringify(findResult1) + "\n");
       // Some manual testing. Testint the testfunctions
-      // tel: [{type: ["work"], value: "123456", carrier: "testCarrier"} , {type: ["home", "fax"], value: "+9-876-5432"}],
+      // tel: [{type: ["work"], value: "123456", carrier: "testCarrier"} , {type: ["home", "fax"], value: "+55 (31) 9876-3456"}],
       is(findResult1.tel[0].carrier, "testCarrier", "Same Carrier");
       is(findResult1.tel[0].type, "work", "Same type");
       is(findResult1.tel[0].value, "123456", "Same Value");
       is(findResult1.tel[1].type[1], "fax", "Same type");
-      is(findResult1.tel[1].value, "+9-876-5432", "Same Value");
+      is(findResult1.tel[1].value, "+55 (31) 9876-3456", "Same Value");
 
       is(findResult1.adr[0].countryName, "country 1", "Same country");
 
@@ -503,6 +503,45 @@ var steps = [
     };
     req.onerror = onFailure;
   },
+  function () {
+    ok(true, "Retrieving by tel exact");
+    var options = {filterBy: ["tel"],
+                   filterOp: "equals",
+                   filterValue: "+55 319 8 7 6 3456"};
+    req = mozContacts.find(options);
+    req.onsuccess = function () {
+      is(req.result.length, 1, "Found exactly 1 contact.");
+      findResult1 = req.result[0];
+      ok(findResult1.id == sample_id1, "Same ID");
+      checkContacts(createResult1, properties1);
+      next();
+    };
+    req.onerror = onFailure;
+  },
+  function () {
+    ok(true, "Retrieving by tel exact with substring");
+    var options = {filterBy: ["tel"],
+                   filterOp: "equals",
+                   filterValue: "3456"};
+    req = mozContacts.find(options);
+    req.onsuccess = function () {
+      is(req.result.length, 0, "Found no contacts.");
+      next();
+    };
+    req.onerror = onFailure;
+  },
+  function () {
+    ok(true, "Retrieving by tel exact with substring");
+    var options = {filterBy: ["tel"],
+                   filterOp: "equals",
+                   filterValue: "+55 (31)"};
+    req = mozContacts.find(options);
+    req.onsuccess = function () {
+      is(req.result.length, 0, "Found no contacts.");
+      next();
+    };
+    req.onerror = onFailure;
+  },
   function () {
     ok(true, "Retrieving by substring tel2");
     var options = {filterBy: ["tel"],
@@ -522,7 +561,7 @@ var steps = [
     ok(true, "Retrieving by substring tel3");
     var options = {filterBy: ["tel"],
                    filterOp: "contains",
-                   filterValue: "98765432"};
+                   filterValue: "98763456"};
     req = mozContacts.find(options);
     req.onsuccess = function () {
       is(req.result.length, 1, "Found exactly 1 contact.");

From 8325d83c1b51708cc829f8dcc19ee66d0c34da19 Mon Sep 17 00:00:00 2001
From: Reuben Morais <reuben.morais@gmail.com>
Date: Thu, 25 Apr 2013 09:08:32 -0700
Subject: [PATCH 02/13] Bug 862250 - Add 'match' filterOp for telephone
 numbers. r=gwagner

--HG--
extra : rebase_source : ff5240597f467c9af008bfc043b1717f23b90185
---
 dom/contacts/fallback/ContactDB.jsm          | 52 ++++++++++++--
 dom/contacts/tests/test_contacts_basics.html | 74 +++++++++++++++++++-
 2 files changed, 118 insertions(+), 8 deletions(-)

diff --git a/dom/contacts/fallback/ContactDB.jsm b/dom/contacts/fallback/ContactDB.jsm
index 1e0249c66ea..c55672f1a00 100644
--- a/dom/contacts/fallback/ContactDB.jsm
+++ b/dom/contacts/fallback/ContactDB.jsm
@@ -19,7 +19,7 @@ Cu.import("resource://gre/modules/PhoneNumberUtils.jsm");
 Cu.import("resource://gre/modules/Timer.jsm");
 
 const DB_NAME = "contacts";
-const DB_VERSION = 9;
+const DB_VERSION = 10;
 const STORE_NAME = "contacts";
 const SAVED_GETALL_STORE_NAME = "getallcache";
 const CHUNK_SIZE = 20;
@@ -337,6 +337,28 @@ ContactDB.prototype = {
             cursor.continue();
           }
         };
+      } else if (currVersion == 9) {
+        if (DEBUG) debug("Add a telMatch index with national and international numbers");
+        objectStore.createIndex("telMatch", "search.parsedTel", {multiEntry: true});
+        objectStore.openCursor().onsuccess = function(event) {
+          let cursor = event.target.result;
+          if (cursor) {
+            if (cursor.value.properties.tel) {
+              cursor.value.search.parsedTel = [];
+              cursor.value.properties.tel.forEach(
+                function(tel) {
+                  cursor.value.search.parsedTel.push(parsed.nationalNumber);
+                  cursor.value.search.parsedTel.push(PhoneNumberUtils.normalize(parsed.nationalFormat));
+                  cursor.value.search.parsedTel.push(parsed.internationalNumber);
+                  cursor.value.search.parsedTel.push(PhoneNumberUtils.normalize(parsed.internationalFormat));
+                  cursor.value.search.parsedTel.push(PhoneNumberUtils.normalize(tel.value.toString()));
+                }
+              );
+              cursor.update(cursor.value);
+            }
+            cursor.continue();
+          }
+        };
       }
     }
 
@@ -424,7 +446,8 @@ ContactDB.prototype = {
       email:           [],
       category:        [],
       tel:             [],
-      exactTel:        []
+      exactTel:        [],
+      parsedTel:       []
     };
 
     for (let field in aContact.properties) {
@@ -443,6 +466,7 @@ ContactDB.prototype = {
               if (number) {
                 number = number.toString();
                 contact.search.exactTel.push(PhoneNumberUtils.normalize(number));
+                contact.search.parsedTel.push(PhoneNumberUtils.normalize(number));
                 for (let i = 0; i < number.length; i++) {
                   search[number.substring(i, number.length)] = 1;
                 }
@@ -463,8 +487,14 @@ ContactDB.prototype = {
                     debug("NationalNumber: " + parsedNumber.nationalNumber);
                     debug("NationalFormat: " + parsedNumber.nationalFormat);
                   }
+
+                  contact.search.parsedTel.push(parsedNumber.nationalNumber);
+                  contact.search.parsedTel.push(PhoneNumberUtils.normalize(parsedNumber.nationalFormat));
+                  contact.search.parsedTel.push(parsedNumber.internationalNumber);
+                  contact.search.parsedTel.push(PhoneNumberUtils.normalize(parsedNumber.internationalFormat));
+
                   if (parsedNumber.internationalNumber &&
-                      number.toString() !== parsedNumber.internationalNumber) {
+                      number !== parsedNumber.internationalNumber) {
                     let digits = parsedNumber.internationalNumber.match(/\d/g);
                     if (digits) {
                       digits = digits.join('');
@@ -753,7 +783,7 @@ ContactDB.prototype = {
     if (DEBUG) debug("ContactDB:find val:" + aOptions.filterValue + " by: " + aOptions.filterBy + " op: " + aOptions.filterOp);
     let self = this;
     this.newTxn("readonly", STORE_NAME, function (txn, store) {
-      if (aOptions && (aOptions.filterOp == "equals" || aOptions.filterOp == "contains")) {
+      if (aOptions && (["equals", "contains", "match"].indexOf(aOptions.filterOp) >= 0)) {
         self._findWithIndex(txn, store, aOptions);
       } else {
         self._findAll(txn, store, aOptions);
@@ -802,11 +832,19 @@ ContactDB.prototype = {
           filterValue = PhoneNumberUtils.normalize(filterValue);
         }
         request = index.mozGetAll(filterValue, limit);
+      } else if (options.filterOp == "match") {
+        if (DEBUG) debug("match");
+        if (key != "tel") {
+          dump("ContactDB: 'match' filterOp only works on tel\n");
+          return txn.abort();
+        }
+
+        let index = store.index("telMatch");
+        let normalized = PhoneNumberUtils.normalize(options.filterValue)
+        request = index.mozGetAll(normalized, limit);
       } else {
         // not case sensitive
-        let tmp = typeof options.filterValue == "string"
-                  ? options.filterValue.toLowerCase()
-                  : options.filterValue.toString().toLowerCase();
+        let tmp = options.filterValue.toString().toLowerCase();
         if (key === 'tel') {
           let digits = tmp.match(/\d/g);
           if (digits) {
diff --git a/dom/contacts/tests/test_contacts_basics.html b/dom/contacts/tests/test_contacts_basics.html
index 1457f275556..26464ac891f 100644
--- a/dom/contacts/tests/test_contacts_basics.html
+++ b/dom/contacts/tests/test_contacts_basics.html
@@ -87,7 +87,7 @@ var properties1 = {
   familyName: ["TestFamilyName","Wagner"],
   givenName: ["Test1","Test2"],
   nickname: "nicktest",
-  tel: [{type: ["work"], value: "123456", carrier: "testCarrier"} , {type: ["home", "fax"], value: "+55 (31) 9876-3456"}],
+  tel: [{type: ["work"], value: "123456", carrier: "testCarrier"} , {type: ["home", "fax"], value: "+55 (31) 9876-3456"}, {type: ["home"], value: "+49 451 491934"}],
   adr: adr1,
   email: [{type: ["work"], value: "x@y.com"}]
 };
@@ -542,6 +542,78 @@ var steps = [
     };
     req.onerror = onFailure;
   },
+  function () {
+    ok(true, "Retrieving by tel match national number");
+    var options = {filterBy: ["tel"],
+                   filterOp: "match",
+                   filterValue: "3198763456"};
+    req = mozContacts.find(options);
+    req.onsuccess = function () {
+      is(req.result.length, 1, "Found exactly 1 contact.");
+      findResult1 = req.result[0];
+      ok(findResult1.id == sample_id1, "Same ID");
+      checkContacts(createResult1, properties1);
+      next();
+    };
+    req.onerror = onFailure;
+  },
+  function () {
+    ok(true, "Retrieving by tel match national format");
+    var options = {filterBy: ["tel"],
+                   filterOp: "match",
+                   filterValue: "0451 491934"};
+    req = mozContacts.find(options);
+    req.onsuccess = function () {
+      is(req.result.length, 1, "Found exactly 1 contact.");
+      findResult1 = req.result[0];
+      ok(findResult1.id == sample_id1, "Same ID");
+      checkContacts(createResult1, properties1);
+      next();
+    };
+    req.onerror = onFailure;
+  },
+  function () {
+    ok(true, "Retrieving by tel match entered number");
+    var options = {filterBy: ["tel"],
+                   filterOp: "match",
+                   filterValue: "123456"};
+    req = mozContacts.find(options);
+    req.onsuccess = function () {
+      is(req.result.length, 1, "Found exactly 1 contact.");
+      findResult1 = req.result[0];
+      ok(findResult1.id == sample_id1, "Same ID");
+      checkContacts(createResult1, properties1);
+      next();
+    };
+    req.onerror = onFailure;
+  },
+  function () {
+    ok(true, "Retrieving by tel match international number");
+    var options = {filterBy: ["tel"],
+                   filterOp: "match",
+                   filterValue: "+55 31 98763456"};
+    req = mozContacts.find(options);
+    req.onsuccess = function () {
+      is(req.result.length, 1, "Found exactly 1 contact.");
+      findResult1 = req.result[0];
+      ok(findResult1.id == sample_id1, "Same ID");
+      checkContacts(createResult1, properties1);
+      next();
+    };
+    req.onerror = onFailure;
+  }
+  function () {
+    ok(true, "Retrieving by match with field other than tel");
+    var options = {filterBy: ["givenName"],
+                   filterOp: "match",
+                   filterValue: "my friends call me 555-4040"};
+    req = mozContacts.find(options);
+    req.onsuccess = onUnwantedSuccess;
+    req.onerror = function() {
+      ok(true, "Failed");
+      next();
+    }
+  },
   function () {
     ok(true, "Retrieving by substring tel2");
     var options = {filterBy: ["tel"],

From d1432b1adae03fbb09c72b368edd86fc8ba96299 Mon Sep 17 00:00:00 2001
From: Reuben Morais <reuben.morais@gmail.com>
Date: Thu, 25 Apr 2013 09:34:38 -0700
Subject: [PATCH 03/13] Bug 862250 - Follow up, fixing test.

---
 dom/contacts/tests/test_contacts_basics.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dom/contacts/tests/test_contacts_basics.html b/dom/contacts/tests/test_contacts_basics.html
index 26464ac891f..9ce45d50029 100644
--- a/dom/contacts/tests/test_contacts_basics.html
+++ b/dom/contacts/tests/test_contacts_basics.html
@@ -601,7 +601,7 @@ var steps = [
       next();
     };
     req.onerror = onFailure;
-  }
+  },
   function () {
     ok(true, "Retrieving by match with field other than tel");
     var options = {filterBy: ["givenName"],

From 3541bd638a99ced0d635f24aa96f97f61ad63fd8 Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:25 -0400
Subject: [PATCH 04/13] Bug 844323 - Prelude part 1: Use a pref to in
 nsHTMLMediaElement to control whether we talk to the audio service.
 r=amarchesini

Previously, we used #ifdef B2G.  Using a pref allows us to write mochitests which run in desktop Firefox that test the audio service and its interaction with other components.
---
 b2g/app/b2g.js                                |  5 +-
 content/html/content/src/HTMLMediaElement.cpp | 46 +++++++++++--------
 mobile/android/app/mobile.js                  |  3 ++
 3 files changed, 34 insertions(+), 20 deletions(-)

diff --git a/b2g/app/b2g.js b/b2g/app/b2g.js
index 24e8154ef9d..b1cc016bb85 100644
--- a/b2g/app/b2g.js
+++ b/b2g/app/b2g.js
@@ -665,6 +665,9 @@ pref("memory_info_dumper.watch_fifo.directory", "/data/local");
 
 pref("general.useragent.enable_overrides", true);
 
+// Make <audio> and <video> talk to the AudioChannelService.
+pref("media.useAudioChannelService", true);
+
 pref("b2g.version", @MOZ_B2G_VERSION@);
 
 // Disable console buffering to save memory.
@@ -673,4 +676,4 @@ pref("consoleservice.buffered", false);
 #ifdef MOZ_WIDGET_GONK
 // Performance testing suggests 2k is a better page size for SQLite.
 pref("toolkit.storage.pageSize", 2048);
-#endif
\ No newline at end of file
+#endif
diff --git a/content/html/content/src/HTMLMediaElement.cpp b/content/html/content/src/HTMLMediaElement.cpp
index d344abba77a..4b91b0906fd 100644
--- a/content/html/content/src/HTMLMediaElement.cpp
+++ b/content/html/content/src/HTMLMediaElement.cpp
@@ -970,6 +970,11 @@ static bool IsAutoplayEnabled()
   return Preferences::GetBool("media.autoplay.enabled");
 }
 
+static bool UseAudioChannelService()
+{
+  return Preferences::GetBool("media.useAudioChannelService");
+}
+
 void HTMLMediaElement::UpdatePreloadAction()
 {
   PreloadAction nextAction = PRELOAD_UNDEFINED;
@@ -2163,7 +2168,10 @@ bool HTMLMediaElement::ParseAttribute(int32_t aNamespaceID,
 
 bool HTMLMediaElement::CheckAudioChannelPermissions(const nsAString& aString)
 {
-#ifdef ANDROID
+  if (!UseAudioChannelService()) {
+    return true;
+  }
+
   // Only normal channel doesn't need permission.
   if (!aString.EqualsASCII("normal")) {
     nsCOMPtr<nsIPermissionManager> permissionManager =
@@ -2179,7 +2187,7 @@ bool HTMLMediaElement::CheckAudioChannelPermissions(const nsAString& aString)
       return false;
     }
   }
-#endif
+
   return true;
 }
 
@@ -3218,17 +3226,17 @@ void HTMLMediaElement::SuspendOrResumeElement(bool aPauseElement, bool aSuspendE
 void HTMLMediaElement::NotifyOwnerDocumentActivityChanged()
 {
   nsIDocument* ownerDoc = OwnerDoc();
-#ifdef ANDROID
-  nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(OwnerDoc());
-  if (domDoc) {
-    bool hidden = false;
-    domDoc->GetHidden(&hidden);
-    // SetVisibilityState will update mChannelSuspended via the CanPlayChanged callback.
-    if (mPlayingThroughTheAudioChannel && mAudioChannelAgent) {
-      mAudioChannelAgent->SetVisibilityState(!hidden);
+  if (UseAudioChannelService()) {
+    nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(OwnerDoc());
+    if (domDoc) {
+      bool hidden = false;
+      domDoc->GetHidden(&hidden);
+      // SetVisibilityState will update mChannelSuspended via the CanPlayChanged callback.
+      if (mPlayingThroughTheAudioChannel && mAudioChannelAgent) {
+        mAudioChannelAgent->SetVisibilityState(!hidden);
+      }
     }
   }
-#endif
   bool suspendEvents = !ownerDoc->IsActive() || !ownerDoc->IsVisible();
   bool pauseElement = suspendEvents || mChannelSuspended;
 
@@ -3656,9 +3664,10 @@ ImageContainer* HTMLMediaElement::GetImageContainer()
 
 nsresult HTMLMediaElement::UpdateChannelMuteState(bool aCanPlay)
 {
-  // Only on B2G we mute the HTMLMediaElement following the rules of
-  // AudioChannelService.
-#ifdef ANDROID
+  if (!UseAudioChannelService()) {
+    return NS_OK;
+  }
+
   // We have to mute this channel:
   if (!aCanPlay && !mChannelSuspended) {
     mChannelSuspended = true;
@@ -3669,15 +3678,15 @@ nsresult HTMLMediaElement::UpdateChannelMuteState(bool aCanPlay)
   }
 
   SuspendOrResumeElement(mChannelSuspended, false);
-#endif
-
   return NS_OK;
 }
 
 void HTMLMediaElement::UpdateAudioChannelPlayingState()
 {
-  // The HTMLMediaElement is registered to the AudioChannelService only on B2G.
-#ifdef ANDROID
+  if (!UseAudioChannelService()) {
+    return;
+  }
+
   bool playingThroughTheAudioChannel =
      (!mPaused &&
       (HasAttr(kNameSpaceID_None, nsGkAtoms::loop) ||
@@ -3711,7 +3720,6 @@ void HTMLMediaElement::UpdateAudioChannelPlayingState()
       mAudioChannelAgent = nullptr;
     }
   }
-#endif
 }
 
 /* void canPlayChanged (in boolean canPlay); */
diff --git a/mobile/android/app/mobile.js b/mobile/android/app/mobile.js
index 393dbe156ed..c3a1d46a1ca 100644
--- a/mobile/android/app/mobile.js
+++ b/mobile/android/app/mobile.js
@@ -712,3 +712,6 @@ pref("media.webaudio.enabled", true);
 // This needs more tests and stability fixes first, as well as UI.
 pref("media.navigator.enabled", false);
 pref("media.peerconnection.enabled", false);
+
+// Make <audio> and <video> talk to the AudioChannelService.
+pref("media.useAudioChannelService", true);

From 96c547be00ad9ffb17dbba11b4abe38d4ad4e9fb Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:26 -0400
Subject: [PATCH 05/13] Bug 844323 - Prelude part 2: Switch
 xpcom/base/StaticPtr from NULL to nullptr, and add a necessary include.
 r=khuey

This is necessary to make this header compile in one of the places I use it.  Anyway it's the right change.
---
 xpcom/base/StaticPtr.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/xpcom/base/StaticPtr.h b/xpcom/base/StaticPtr.h
index de7c73858a9..865606702f3 100644
--- a/xpcom/base/StaticPtr.h
+++ b/xpcom/base/StaticPtr.h
@@ -7,6 +7,9 @@
 #ifndef mozilla_StaticPtr_h
 #define mozilla_StaticPtr_h
 
+#include "mozilla/Assertions.h"
+#include "mozilla/NullPtr.h"
+
 namespace mozilla {
 
 /**
@@ -216,7 +219,7 @@ REFLEXIVE_EQUALITY_OPERATORS(const StaticAutoPtr<T>&, U*,
 
 // Let us compare StaticAutoPtr to 0.
 REFLEXIVE_EQUALITY_OPERATORS(const StaticAutoPtr<T>&, StaticPtr_internal::Zero*,
-                             lhs.get() == NULL, class T)
+                             lhs.get() == nullptr, class T)
 
 // StaticRefPtr (in)equality operators
 
@@ -242,7 +245,7 @@ REFLEXIVE_EQUALITY_OPERATORS(const StaticRefPtr<T>&, U*,
 
 // Let us compare StaticRefPtr to 0.
 REFLEXIVE_EQUALITY_OPERATORS(const StaticRefPtr<T>&, StaticPtr_internal::Zero*,
-                             lhs.get() == NULL, class T)
+                             lhs.get() == nullptr, class T)
 
 #undef REFLEXIVE_EQUALITY_OPERATORS
 

From 0e0722d49d660459313cb38a76fb0c23fb4ba4c4 Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:26 -0400
Subject: [PATCH 06/13] Bug 844323 - Prelude part 3: Change
 ProcessPriorityManager's export directory. r=khuey

It was mozilla/dom/ipc/ before, but this changes it to mozilla/, which matches the class's namespace.
---
 content/canvas/src/WebGLContext.cpp | 2 +-
 dom/ipc/moz.build                   | 2 +-
 layout/build/nsLayoutStatics.cpp    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/canvas/src/WebGLContext.cpp b/content/canvas/src/WebGLContext.cpp
index 245e2fa9d64..26b38dfb6ae 100644
--- a/content/canvas/src/WebGLContext.cpp
+++ b/content/canvas/src/WebGLContext.cpp
@@ -45,7 +45,7 @@
 #include "mozilla/Services.h"
 #include "mozilla/dom/WebGLRenderingContextBinding.h"
 #include "mozilla/dom/BindingUtils.h"
-#include "mozilla/dom/ipc/ProcessPriorityManager.h"
+#include "mozilla/ProcessPriorityManager.h"
 
 #include "Layers.h"
 
diff --git a/dom/ipc/moz.build b/dom/ipc/moz.build
index 594d9873f61..3802a9b2a0f 100644
--- a/dom/ipc/moz.build
+++ b/dom/ipc/moz.build
@@ -16,7 +16,6 @@ EXPORTS += [
 
 EXPORTS.mozilla.dom.ipc += [
     'Blob.h',
-    'ProcessPriorityManager.h',
     'nsIRemoteBlob.h',
 ]
 
@@ -36,5 +35,6 @@ EXPORTS.mozilla.dom += [
 
 EXPORTS.mozilla += [
     'AppProcessChecker.h',
+    'ProcessPriorityManager.h',
 ]
 
diff --git a/layout/build/nsLayoutStatics.cpp b/layout/build/nsLayoutStatics.cpp
index c262e267f74..130e83dd2df 100644
--- a/layout/build/nsLayoutStatics.cpp
+++ b/layout/build/nsLayoutStatics.cpp
@@ -110,7 +110,7 @@ using namespace mozilla::system;
 #include "nsEditorSpellCheck.h"
 #include "nsWindowMemoryReporter.h"
 #include "mozilla/dom/ContentParent.h"
-#include "mozilla/dom/ipc/ProcessPriorityManager.h"
+#include "mozilla/ProcessPriorityManager.h"
 #include "nsPermissionManager.h"
 #include "nsCookieService.h"
 #include "nsApplicationCacheService.h"

From 3f8e52a07a25abb53cb9fe3ed06ead7ffee28ae4 Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:26 -0400
Subject: [PATCH 07/13] Bug 844323 - Prelude part 4: Use 's' prefix on
 class-static variables, not 'g'. r=me

---
 dom/ipc/ContentParent.cpp | 86 +++++++++++++++++++--------------------
 dom/ipc/ContentParent.h   |  6 +--
 2 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/dom/ipc/ContentParent.cpp b/dom/ipc/ContentParent.cpp
index 1134faee6b3..fd872b1bce4 100644
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -194,9 +194,9 @@ MemoryReportRequestParent::~MemoryReportRequestParent()
     MOZ_COUNT_DTOR(MemoryReportRequestParent);
 }
 
-nsDataHashtable<nsStringHashKey, ContentParent*>* ContentParent::gAppContentParents;
-nsTArray<ContentParent*>* ContentParent::gNonAppContentParents;
-nsTArray<ContentParent*>* ContentParent::gPrivateContent;
+nsDataHashtable<nsStringHashKey, ContentParent*>* ContentParent::sAppContentParents;
+nsTArray<ContentParent*>* ContentParent::sNonAppContentParents;
+nsTArray<ContentParent*>* ContentParent::sPrivateContent;
 
 // This is true when subprocess launching is enabled.  This is the
 // case between StartUp() and ShutDown() or JoinAllSubprocesses().
@@ -376,17 +376,17 @@ ContentParent::JoinAllSubprocesses()
 /*static*/ already_AddRefed<ContentParent>
 ContentParent::GetNewOrUsed(bool aForBrowserElement)
 {
-    if (!gNonAppContentParents)
-        gNonAppContentParents = new nsTArray<ContentParent*>();
+    if (!sNonAppContentParents)
+        sNonAppContentParents = new nsTArray<ContentParent*>();
 
     int32_t maxContentProcesses = Preferences::GetInt("dom.ipc.processCount", 1);
     if (maxContentProcesses < 1)
         maxContentProcesses = 1;
 
-    if (gNonAppContentParents->Length() >= uint32_t(maxContentProcesses)) {
-        uint32_t idx = rand() % gNonAppContentParents->Length();
-        nsRefPtr<ContentParent> p = (*gNonAppContentParents)[idx];
-        NS_ASSERTION(p->IsAlive(), "Non-alive contentparent in gNonAppContentParents?");
+    if (sNonAppContentParents->Length() >= uint32_t(maxContentProcesses)) {
+        uint32_t idx = rand() % sNonAppContentParents->Length();
+        nsRefPtr<ContentParent> p = (*sNonAppContentParents)[idx];
+        NS_ASSERTION(p->IsAlive(), "Non-alive contentparent in sNonAppContentParents?");
         return p.forget();
     }
 
@@ -396,7 +396,7 @@ ContentParent::GetNewOrUsed(bool aForBrowserElement)
                           base::PRIVILEGES_DEFAULT,
                           PROCESS_PRIORITY_FOREGROUND);
     p->Init();
-    gNonAppContentParents->AppendElement(p);
+    sNonAppContentParents->AppendElement(p);
     return p.forget();
 }
 
@@ -482,10 +482,10 @@ ContentParent::CreateBrowserOrApp(const TabContext& aContext,
     // !HasOwnApp() branch above.
     nsCOMPtr<mozIApplication> ownApp = aContext.GetOwnApp();
 
-    if (!gAppContentParents) {
-        gAppContentParents =
+    if (!sAppContentParents) {
+        sAppContentParents =
             new nsDataHashtable<nsStringHashKey, ContentParent*>();
-        gAppContentParents->Init();
+        sAppContentParents->Init();
     }
 
     // Each app gets its own ContentParent instance.
@@ -497,7 +497,7 @@ ContentParent::CreateBrowserOrApp(const TabContext& aContext,
 
     ProcessPriority initialPriority = GetInitialProcessPriority(aFrameElement);
 
-    nsRefPtr<ContentParent> p = gAppContentParents->Get(manifestURL);
+    nsRefPtr<ContentParent> p = sAppContentParents->Get(manifestURL);
     if (p) {
         // Check that the process is still alive and set its priority.
         // Hopefully the process won't die after this point, if this call
@@ -517,7 +517,7 @@ ContentParent::CreateBrowserOrApp(const TabContext& aContext,
                                   privs, initialPriority);
             p->Init();
         }
-        gAppContentParents->Put(manifestURL, p);
+        sAppContentParents->Put(manifestURL, p);
     }
 
     nsRefPtr<TabParent> tp = new TabParent(aContext);
@@ -790,26 +790,26 @@ void
 ContentParent::MarkAsDead()
 {
     if (!mAppManifestURL.IsEmpty()) {
-        if (gAppContentParents) {
-            gAppContentParents->Remove(mAppManifestURL);
-            if (!gAppContentParents->Count()) {
-                delete gAppContentParents;
-                gAppContentParents = NULL;
+        if (sAppContentParents) {
+            sAppContentParents->Remove(mAppManifestURL);
+            if (!sAppContentParents->Count()) {
+                delete sAppContentParents;
+                sAppContentParents = NULL;
             }
         }
-    } else if (gNonAppContentParents) {
-        gNonAppContentParents->RemoveElement(this);
-        if (!gNonAppContentParents->Length()) {
-            delete gNonAppContentParents;
-            gNonAppContentParents = NULL;
+    } else if (sNonAppContentParents) {
+        sNonAppContentParents->RemoveElement(this);
+        if (!sNonAppContentParents->Length()) {
+            delete sNonAppContentParents;
+            sNonAppContentParents = NULL;
         }
     }
 
-    if (gPrivateContent) {
-        gPrivateContent->RemoveElement(this);
-        if (!gPrivateContent->Length()) {
-            delete gPrivateContent;
-            gPrivateContent = NULL;
+    if (sPrivateContent) {
+        sPrivateContent->RemoveElement(this);
+        if (!sPrivateContent->Length()) {
+            delete sPrivateContent;
+            sPrivateContent = NULL;
         }
     }
 
@@ -1149,17 +1149,17 @@ ContentParent::~ContentParent()
     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 
     // We should be removed from all these lists in ActorDestroy.
-    MOZ_ASSERT(!gPrivateContent || !gPrivateContent->Contains(this));
+    MOZ_ASSERT(!sPrivateContent || !sPrivateContent->Contains(this));
     if (mAppManifestURL.IsEmpty()) {
-        MOZ_ASSERT(!gNonAppContentParents ||
-                   !gNonAppContentParents->Contains(this));
+        MOZ_ASSERT(!sNonAppContentParents ||
+                   !sNonAppContentParents->Contains(this));
     } else {
-        // In general, we expect gAppContentParents->Get(mAppManifestURL) to be
+        // In general, we expect sAppContentParents->Get(mAppManifestURL) to be
         // NULL.  But it could be that we created another ContentParent for this
         // app after we did this->ActorDestroy(), so the right check is that
         // gAppContentParent->Get(mAppManifestURL) != this.
-        MOZ_ASSERT(!gAppContentParents ||
-                   gAppContentParents->Get(mAppManifestURL) != this);
+        MOZ_ASSERT(!sAppContentParents ||
+                   sAppContentParents->Get(mAppManifestURL) != this);
     }
 }
 
@@ -2523,17 +2523,17 @@ ContentParent::RecvScriptError(const nsString& aMessage,
 bool
 ContentParent::RecvPrivateDocShellsExist(const bool& aExist)
 {
-  if (!gPrivateContent)
-    gPrivateContent = new nsTArray<ContentParent*>();
+  if (!sPrivateContent)
+    sPrivateContent = new nsTArray<ContentParent*>();
   if (aExist) {
-    gPrivateContent->AppendElement(this);
+    sPrivateContent->AppendElement(this);
   } else {
-    gPrivateContent->RemoveElement(this);
-    if (!gPrivateContent->Length()) {
+    sPrivateContent->RemoveElement(this);
+    if (!sPrivateContent->Length()) {
       nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
       obs->NotifyObservers(nullptr, "last-pb-context-exited", nullptr);
-      delete gPrivateContent;
-      gPrivateContent = NULL;
+      delete sPrivateContent;
+      sPrivateContent = NULL;
     }
   }
   return true;
diff --git a/dom/ipc/ContentParent.h b/dom/ipc/ContentParent.h
index a12d9f76a0c..0ab964b3c60 100644
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -151,9 +151,9 @@ protected:
     virtual void ActorDestroy(ActorDestroyReason why);
 
 private:
-    static nsDataHashtable<nsStringHashKey, ContentParent*> *gAppContentParents;
-    static nsTArray<ContentParent*>* gNonAppContentParents;
-    static nsTArray<ContentParent*>* gPrivateContent;
+    static nsDataHashtable<nsStringHashKey, ContentParent*> *sAppContentParents;
+    static nsTArray<ContentParent*>* sNonAppContentParents;
+    static nsTArray<ContentParent*>* sPrivateContent;
 
     static void JoinProcessesIOThread(const nsTArray<ContentParent*>* aProcesses,
                                       Monitor* aMonitor, bool* aDone);

From 8af5a089ab2a73eafd1a7a3a39c42c0fa4e94700 Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:26 -0400
Subject: [PATCH 08/13] Bug 844323 - Part 1: Move process preallocation logic
 out of ContentParent and into a new file, PreallocatedProcessManager. r=bent

Also make the PreallocatedProcessManager respond to pref changes.  This allows us to write a test involving the preallocated process.  Making this change was the main motivation for this patch; I moved the logic out of ContentParent because with the pref-watching code it was becoming unweildy.
---
 dom/ipc/ContentParent.cpp              | 124 ++++---------
 dom/ipc/ContentParent.h                |  13 +-
 dom/ipc/Makefile.in                    |   1 +
 dom/ipc/PreallocatedProcessManager.cpp | 229 +++++++++++++++++++++++++
 dom/ipc/PreallocatedProcessManager.h   |  90 ++++++++++
 dom/ipc/ProcessPriorityManager.cpp     |   2 +-
 dom/ipc/moz.build                      |   1 +
 7 files changed, 359 insertions(+), 101 deletions(-)
 create mode 100644 dom/ipc/PreallocatedProcessManager.cpp
 create mode 100644 dom/ipc/PreallocatedProcessManager.h

diff --git a/dom/ipc/ContentParent.cpp b/dom/ipc/ContentParent.cpp
index fd872b1bce4..addd2e4f72a 100644
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -80,6 +80,8 @@
 #include "nsThreadUtils.h"
 #include "nsToolkitCompsCID.h"
 #include "nsWidgetsCID.h"
+#include "PreallocatedProcessManager.h"
+#include "ProcessPriorityManager.h"
 #include "SandboxHal.h"
 #include "StructuredCloneUtils.h"
 #include "TabParent.h"
@@ -197,6 +199,7 @@ MemoryReportRequestParent::~MemoryReportRequestParent()
 nsDataHashtable<nsStringHashKey, ContentParent*>* ContentParent::sAppContentParents;
 nsTArray<ContentParent*>* ContentParent::sNonAppContentParents;
 nsTArray<ContentParent*>* ContentParent::sPrivateContent;
+LinkedList<ContentParent> ContentParent::sContentParents;
 
 // This is true when subprocess launching is enabled.  This is the
 // case between StartUp() and ShutDown() or JoinAllSubprocesses().
@@ -205,60 +208,27 @@ static bool sCanLaunchSubprocesses;
 // The first content child has ID 1, so the chrome process can have ID 0.
 static uint64_t gContentChildID = 1;
 
-// Try to keep an app process always preallocated, to get
-// initialization off the critical path of app startup.
-static bool sKeepAppProcessPreallocated;
-static StaticRefPtr<ContentParent> sPreallocatedAppProcess;
-static CancelableTask* sPreallocateAppProcessTask;
-// This number is fairly arbitrary ... the intention is to put off
-// launching another app process until the last one has finished
-// loading its content, to reduce CPU/memory/IO contention.
-static int sPreallocateDelayMs;
 // We want the prelaunched process to know that it's for apps, but not
 // actually for any app in particular.  Use a magic manifest URL.
 // Can't be a static constant.
 #define MAGIC_PREALLOCATED_APP_MANIFEST_URL NS_LITERAL_STRING("{{template}}")
 
-/*static*/ void
+// PreallocateAppProcess is called by the PreallocatedProcessManager.
+// ContentParent then takes this process back within
+// MaybeTakePreallocatedAppProcess.
+
+/*static*/ already_AddRefed<ContentParent>
 ContentParent::PreallocateAppProcess()
 {
-    MOZ_ASSERT(!sPreallocatedAppProcess);
-
-    if (sPreallocateAppProcessTask) {
-        // We were called directly while a delayed task was scheduled.
-        sPreallocateAppProcessTask->Cancel();
-        sPreallocateAppProcessTask = nullptr;
-    }
-
-    sPreallocatedAppProcess =
+    nsRefPtr<ContentParent> process =
         new ContentParent(MAGIC_PREALLOCATED_APP_MANIFEST_URL,
                           /*isBrowserElement=*/false,
                           // Final privileges are set when we
                           // transform into our app.
                           base::PRIVILEGES_INHERIT,
                           PROCESS_PRIORITY_BACKGROUND);
-    sPreallocatedAppProcess->Init();
-}
-
-/*static*/ void
-ContentParent::DelayedPreallocateAppProcess()
-{
-    sPreallocateAppProcessTask = nullptr;
-    if (!sPreallocatedAppProcess) {
-        PreallocateAppProcess();
-    }
-}
-
-/*static*/ void
-ContentParent::ScheduleDelayedPreallocateAppProcess()
-{
-    if (!sKeepAppProcessPreallocated || sPreallocateAppProcessTask) {
-        return;
-    }
-    sPreallocateAppProcessTask =
-        NewRunnableFunction(DelayedPreallocateAppProcess);
-    MessageLoop::current()->PostDelayedTask(
-        FROM_HERE, sPreallocateAppProcessTask, sPreallocateDelayMs);
+    process->Init();
+    return process.forget();
 }
 
 /*static*/ already_AddRefed<ContentParent>
@@ -266,9 +236,7 @@ ContentParent::MaybeTakePreallocatedAppProcess(const nsAString& aAppManifestURL,
                                                ChildPrivileges aPrivs,
                                                ProcessPriority aInitialPriority)
 {
-    nsRefPtr<ContentParent> process = sPreallocatedAppProcess.get();
-    sPreallocatedAppProcess = nullptr;
-
+    nsRefPtr<ContentParent> process = PreallocatedProcessManager::Take();
     if (!process) {
         return nullptr;
     }
@@ -284,14 +252,6 @@ ContentParent::MaybeTakePreallocatedAppProcess(const nsAString& aAppManifestURL,
     return process.forget();
 }
 
-/*static*/ void
-ContentParent::FirstIdle(void)
-{
-    // The parent has gone idle for the first time. This would be a good
-    // time to preallocate an app process.
-    ScheduleDelayedPreallocateAppProcess();
-}
-
 /*static*/ void
 ContentParent::StartUp()
 {
@@ -299,22 +259,10 @@ ContentParent::StartUp()
         return;
     }
 
-    sKeepAppProcessPreallocated =
-        Preferences::GetBool("dom.ipc.processPrelaunch.enabled", false);
-    if (sKeepAppProcessPreallocated) {
-        ClearOnShutdown(&sPreallocatedAppProcess);
-
-        sPreallocateDelayMs = Preferences::GetUint(
-            "dom.ipc.processPrelaunch.delayMs", 1000);
-
-        MOZ_ASSERT(!sPreallocateAppProcessTask);
-
-        // Let's not slow down the main process initialization. Wait until
-        // the main process goes idle before we preallocate a process
-        MessageLoop::current()->PostIdleTask(FROM_HERE, NewRunnableFunction(FirstIdle));
-    }
-
     sCanLaunchSubprocesses = true;
+
+    // Try to preallocate a process that we can transform into an app later.
+    PreallocatedProcessManager::AllocateAfterDelay();
 }
 
 /*static*/ void
@@ -544,30 +492,14 @@ ContentParent::CreateBrowserOrApp(const TabContext& aContext,
     return static_cast<TabParent*>(browser);
 }
 
-static PLDHashOperator
-AppendToTArray(const nsAString& aKey, ContentParent* aValue, void* aArray)
-{
-    nsTArray<ContentParent*> *array =
-        static_cast<nsTArray<ContentParent*>*>(aArray);
-    array->AppendElement(aValue);
-    return PL_DHASH_NEXT;
-}
-
 void
 ContentParent::GetAll(nsTArray<ContentParent*>& aArray)
 {
     aArray.Clear();
 
-    if (gNonAppContentParents) {
-        aArray.AppendElements(*gNonAppContentParents);
-    }
-
-    if (gAppContentParents) {
-        gAppContentParents->EnumerateRead(&AppendToTArray, &aArray);
-    }
-
-    if (sPreallocatedAppProcess) {
-        aArray.AppendElement(sPreallocatedAppProcess);
+    for (ContentParent* cp = sContentParents.getFirst(); cp;
+         cp = cp->getNext()) {
+        aArray.AppendElement(cp);
     }
 }
 
@@ -814,6 +746,11 @@ ContentParent::MarkAsDead()
     }
 
     mIsAlive = false;
+
+    // Remove from sContentParents.
+    if (isInList()) {
+         remove();
+    }
 }
 
 void
@@ -922,10 +859,6 @@ ContentParent::ActorDestroy(ActorDestroyReason why)
 #endif
     }
 
-    if (sPreallocatedAppProcess == this) {
-        sPreallocatedAppProcess = nullptr;
-    }
-
     mMessageManager->Disconnect();
 
     // clear the child memory reporters
@@ -1086,6 +1019,9 @@ ContentParent::ContentParent(const nsAString& aAppManifestURL,
     , mSendPermissionUpdates(false)
     , mIsForBrowser(aIsForBrowser)
 {
+    // Insert ourselves into the global linked list of ContentParent objects.
+    sContentParents.insertBack(this);
+
     // From this point on, NS_WARNING, NS_ASSERTION, etc. should print out the
     // PID along with the warning.
     nsDebugImpl::SetMultiprocessMode("Parent");
@@ -1380,11 +1316,11 @@ ContentParent::RecvGetShowPasswordSetting(bool* showPassword)
 bool
 ContentParent::RecvFirstIdle()
 {
-    // When the ContentChild goes idle, it sends us a FirstIdle message
-    // which we use as a good time to prelaunch another process. If we
-    // prelaunch any sooner than this, then we'll be competing with the
+    // When the ContentChild goes idle, it sends us a FirstIdle message which we
+    // use as an indicator that it's a good time to prelaunch another process.
+    // If we prelaunch any sooner than this, then we'll be competing with the
     // child process and slowing it down.
-    ScheduleDelayedPreallocateAppProcess();
+    PreallocatedProcessManager::AllocateOnIdle();
     return true;
 }
 
diff --git a/dom/ipc/ContentParent.h b/dom/ipc/ContentParent.h
index 0ab964b3c60..2fda4e1e5a9 100644
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -58,6 +58,7 @@ class ContentParent : public PContentParent
                     , public nsIThreadObserver
                     , public nsIDOMGeoPositionCallback
                     , public mozilla::dom::ipc::MessageManagerCallback
+                    , public mozilla::LinkedListElement<ContentParent>
 {
     typedef mozilla::ipc::GeckoChildProcessHost GeckoChildProcessHost;
     typedef mozilla::ipc::OptionalURIParams OptionalURIParams;
@@ -84,6 +85,11 @@ public:
     static already_AddRefed<ContentParent>
     GetNewOrUsed(bool aForBrowserElement = false);
 
+    /**
+     * Create a subprocess suitable for use as a preallocated app process.
+     */
+    static already_AddRefed<ContentParent> PreallocateAppProcess();
+
     /**
      * Get or create a content process for the given TabContext.  aFrameElement
      * should be the frame/iframe element with which this process will
@@ -154,14 +160,11 @@ private:
     static nsDataHashtable<nsStringHashKey, ContentParent*> *sAppContentParents;
     static nsTArray<ContentParent*>* sNonAppContentParents;
     static nsTArray<ContentParent*>* sPrivateContent;
+    static LinkedList<ContentParent> sContentParents;
 
     static void JoinProcessesIOThread(const nsTArray<ContentParent*>* aProcesses,
                                       Monitor* aMonitor, bool* aDone);
 
-    static void PreallocateAppProcess();
-    static void DelayedPreallocateAppProcess();
-    static void ScheduleDelayedPreallocateAppProcess();
-
     // Take the preallocated process and transform it into a "real" app process,
     // for the specified manifest URL.  If there is no preallocated process (or
     // if it's dead), this returns false.
@@ -172,8 +175,6 @@ private:
 
     static hal::ProcessPriority GetInitialProcessPriority(nsIDOMElement* aFrameElement);
 
-    static void FirstIdle();
-
     // Hide the raw constructor methods since we don't want client code
     // using them.
     using PContentParent::SendPBrowserConstructor;
diff --git a/dom/ipc/Makefile.in b/dom/ipc/Makefile.in
index 98ec839a382..896848e9a0d 100644
--- a/dom/ipc/Makefile.in
+++ b/dom/ipc/Makefile.in
@@ -24,6 +24,7 @@ CPPSRCS = \
   CrashReporterParent.cpp \
   CrashReporterChild.cpp \
   PermissionMessageUtils.cpp \
+  PreallocatedProcessManager.cpp \
   ProcessPriorityManager.cpp \
   StructuredCloneUtils.cpp \
   TabParent.cpp \
diff --git a/dom/ipc/PreallocatedProcessManager.cpp b/dom/ipc/PreallocatedProcessManager.cpp
new file mode 100644
index 00000000000..64eca90a667
--- /dev/null
+++ b/dom/ipc/PreallocatedProcessManager.cpp
@@ -0,0 +1,229 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* 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 "mozilla/PreallocatedProcessManager.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/ContentParent.h"
+
+using namespace mozilla;
+using namespace mozilla::hal;
+using namespace mozilla::dom;
+
+namespace {
+
+/**
+ * This singleton class implements the static methods on
+ * PreallocatedProcessManager.
+ */
+class PreallocatedProcessManagerImpl MOZ_FINAL
+  : public nsIObserver
+{
+public:
+  static PreallocatedProcessManagerImpl* Singleton();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  // See comments on PreallocatedProcessManager for these methods.
+  void AllocateAfterDelay();
+  void AllocateOnIdle();
+  void AllocateNow();
+  already_AddRefed<ContentParent> Take();
+
+private:
+  static mozilla::StaticRefPtr<PreallocatedProcessManagerImpl> sSingleton;
+
+  PreallocatedProcessManagerImpl();
+  DISALLOW_EVIL_CONSTRUCTORS(PreallocatedProcessManagerImpl);
+
+  void Init();
+
+  void RereadPrefs();
+  void Enable();
+  void Disable();
+
+  void ObserveProcessShutdown(nsISupports* aSubject);
+
+  bool mEnabled;
+  nsRefPtr<ContentParent> mPreallocatedAppProcess;
+};
+
+/* static */ StaticRefPtr<PreallocatedProcessManagerImpl>
+PreallocatedProcessManagerImpl::sSingleton;
+
+/* static */ PreallocatedProcessManagerImpl*
+PreallocatedProcessManagerImpl::Singleton()
+{
+  if (!sSingleton) {
+    sSingleton = new PreallocatedProcessManagerImpl();
+    sSingleton->Init();
+    ClearOnShutdown(&sSingleton);
+  }
+
+  return sSingleton;
+}
+
+NS_IMPL_ISUPPORTS1(PreallocatedProcessManagerImpl, nsIObserver)
+
+PreallocatedProcessManagerImpl::PreallocatedProcessManagerImpl()
+  : mEnabled(false)
+{}
+
+void
+PreallocatedProcessManagerImpl::Init()
+{
+  Preferences::AddStrongObserver(this, "dom.ipc.processPrelaunch.enabled");
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (os) {
+    os->AddObserver(this, "ipc:content-shutdown",
+                    /* weakRef = */ false);
+  }
+  RereadPrefs();
+}
+
+NS_IMETHODIMP
+PreallocatedProcessManagerImpl::Observe(nsISupports* aSubject,
+                                        const char* aTopic,
+                                        const PRUnichar* aData)
+{
+  if (!strcmp("ipc:content-shutdown", aTopic)) {
+    ObserveProcessShutdown(aSubject);
+  } else if (!strcmp("nsPref:changed", aTopic)) {
+    // The only other observer we registered was for our prefs.
+    RereadPrefs();
+  } else {
+    MOZ_ASSERT(false);
+  }
+
+  return NS_OK;
+}
+
+void
+PreallocatedProcessManagerImpl::RereadPrefs()
+{
+  if (Preferences::GetBool("dom.ipc.processPrelaunch.enabled")) {
+    Enable();
+  } else {
+    Disable();
+  }
+}
+
+already_AddRefed<ContentParent>
+PreallocatedProcessManagerImpl::Take()
+{
+  return mPreallocatedAppProcess.forget();
+}
+
+void
+PreallocatedProcessManagerImpl::Enable()
+{
+  if (mEnabled) {
+    return;
+  }
+
+  mEnabled = true;
+  AllocateAfterDelay();
+}
+
+void
+PreallocatedProcessManagerImpl::AllocateAfterDelay()
+{
+  if (!mEnabled || mPreallocatedAppProcess) {
+    return;
+  }
+
+  MessageLoop::current()->PostDelayedTask(
+    FROM_HERE,
+    NewRunnableMethod(this, &PreallocatedProcessManagerImpl::AllocateOnIdle),
+    Preferences::GetUint("dom.ipc.processPrelaunch.delayMs", 1000));
+}
+
+void
+PreallocatedProcessManagerImpl::AllocateOnIdle()
+{
+  if (!mEnabled || mPreallocatedAppProcess) {
+    return;
+  }
+
+  MessageLoop::current()->PostIdleTask(
+    FROM_HERE,
+    NewRunnableMethod(this, &PreallocatedProcessManagerImpl::AllocateNow));
+}
+
+void
+PreallocatedProcessManagerImpl::AllocateNow()
+{
+  if (!mEnabled || mPreallocatedAppProcess) {
+    return;
+  }
+
+  mPreallocatedAppProcess = ContentParent::PreallocateAppProcess();
+}
+
+void
+PreallocatedProcessManagerImpl::Disable()
+{
+  if (!mEnabled) {
+    return;
+  }
+
+  mEnabled = false;
+
+  if (mPreallocatedAppProcess) {
+    mPreallocatedAppProcess->ShutDown();
+    mPreallocatedAppProcess = nullptr;
+  }
+}
+
+void
+PreallocatedProcessManagerImpl::ObserveProcessShutdown(nsISupports* aSubject)
+{
+  if (!mPreallocatedAppProcess) {
+    return;
+  }
+
+  nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE_VOID(props);
+
+  uint64_t childID = CONTENT_PROCESS_ID_UNKNOWN;
+  props->GetPropertyAsUint64(NS_LITERAL_STRING("childID"), &childID);
+  NS_ENSURE_TRUE_VOID(childID != CONTENT_PROCESS_ID_UNKNOWN);
+
+  if (childID == mPreallocatedAppProcess->ChildID()) {
+    mPreallocatedAppProcess = nullptr;
+  }
+}
+
+} // anonymous namespace
+
+namespace mozilla {
+
+/* static */ void
+PreallocatedProcessManager::AllocateAfterDelay()
+{
+  PreallocatedProcessManagerImpl::Singleton()->AllocateAfterDelay();
+}
+
+/* static */ void
+PreallocatedProcessManager::AllocateOnIdle()
+{
+  PreallocatedProcessManagerImpl::Singleton()->AllocateOnIdle();
+}
+
+/* static */ void
+PreallocatedProcessManager::AllocateNow()
+{
+  PreallocatedProcessManagerImpl::Singleton()->AllocateNow();
+}
+
+/* static */ already_AddRefed<ContentParent>
+PreallocatedProcessManager::Take()
+{
+  return PreallocatedProcessManagerImpl::Singleton()->Take();
+}
+
+} // namespace mozilla
diff --git a/dom/ipc/PreallocatedProcessManager.h b/dom/ipc/PreallocatedProcessManager.h
new file mode 100644
index 00000000000..19c2b419738
--- /dev/null
+++ b/dom/ipc/PreallocatedProcessManager.h
@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* 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_PreallocatedProcessManager_h
+#define mozilla_PreallocatedProcessManager_h
+
+#include "base/basictypes.h"
+#include "mozilla/StaticPtr.h"
+#include "nsCOMPtr.h"
+#include "nsIObserver.h"
+#include "nsAutoPtr.h"
+
+namespace mozilla {
+namespace dom {
+class ContentParent;
+}
+
+/**
+ * This class manages a ContentParent that it starts up ahead of any particular
+ * need.  You can then call Take() to get this process and use it.  Since we
+ * already started it up, it should be ready for use faster than if you'd
+ * created the process when you needed it.
+ *
+ * This class watches the dom.ipc.processPrelaunch.enabled pref.  If it changes
+ * from false to true, it preallocates a process.  If it changes from true to
+ * false, it kills the preallocated process, if any.
+ *
+ * We don't expect this pref to flip between true and false in production, but
+ * flipping the pref is important for tests.
+ *
+ * The static methods here are implemented by forwarding calls on to a
+ * PreallocatedProcessManagerImpl singleton class, so if you add a new static
+ * method here, you'll need to write a corresponding public method on the
+ * singleton.
+ */
+class PreallocatedProcessManager MOZ_FINAL
+{
+  typedef mozilla::dom::ContentParent ContentParent;
+
+public:
+  /**
+   * Create a process after a delay.  We wait for a period of time (specified
+   * by the dom.ipc.processPrelaunch.delayMs pref), then wait for this process
+   * to go idle, then allocate the new process.
+   *
+   * If the dom.ipc.processPrelaunch.enabled pref is false, or if we already
+   * have a preallocated process, this function does nothing.
+   */
+  static void AllocateAfterDelay();
+
+  /**
+   * Create a process once this process goes idle.
+   *
+   * If the dom.ipc.processPrelaunch.enabled pref is false, or if we already
+   * have a preallocated process, this function does nothing.
+   */
+  static void AllocateOnIdle();
+
+  /**
+   * Create a process right now.
+   *
+   * If the dom.ipc.processPrelaunch.enabled pref is false, or if we already
+   * have a preallocated process, this function does nothing.
+   */
+  static void AllocateNow();
+
+  /**
+   * Take the preallocated process, if we have one.  If we don't have one, this
+   * returns null.
+   *
+   * If you call Take() twice in a row, the second call is guaranteed to return
+   * null.
+   *
+   * After you Take() the preallocated process, you need to call one of the
+   * Allocate* functions (or change the dom.ipc.processPrelaunch pref from
+   * false to true) before we'll create a new process.
+   */
+  static already_AddRefed<ContentParent> Take();
+
+private:
+  PreallocatedProcessManager();
+  DISALLOW_EVIL_CONSTRUCTORS(PreallocatedProcessManager);
+};
+
+} // namespace mozilla
+
+#endif // defined mozilla_PreallocatedProcessManager_h
diff --git a/dom/ipc/ProcessPriorityManager.cpp b/dom/ipc/ProcessPriorityManager.cpp
index d5fabb982eb..fc2aaa6bcdc 100644
--- a/dom/ipc/ProcessPriorityManager.cpp
+++ b/dom/ipc/ProcessPriorityManager.cpp
@@ -5,7 +5,7 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/ClearOnShutdown.h"
-#include "mozilla/dom/ipc/ProcessPriorityManager.h"
+#include "mozilla/ProcessPriorityManager.h"
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/dom/TabChild.h"
 #include "mozilla/Hal.h"
diff --git a/dom/ipc/moz.build b/dom/ipc/moz.build
index 3802a9b2a0f..e4f7a13c5f1 100644
--- a/dom/ipc/moz.build
+++ b/dom/ipc/moz.build
@@ -35,6 +35,7 @@ EXPORTS.mozilla.dom += [
 
 EXPORTS.mozilla += [
     'AppProcessChecker.h',
+    'PreallocatedProcessManager.h',
     'ProcessPriorityManager.h',
 ]
 

From 7908e05f2241a43b63d36ee741c17848a2b63189 Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:26 -0400
Subject: [PATCH 09/13] Bug 844323 - Part 2 (The Main Event): Move
 ProcesPriorityManager to the main process. r=bent,khuey

---
 content/base/public/nsIFrameLoader.idl        |   18 +-
 content/base/src/nsFrameLoader.cpp            |   27 +
 content/base/src/nsFrameLoader.h              |    5 +
 content/canvas/src/WebGLContext.cpp           |    4 +-
 dom/audiochannel/AudioChannelService.cpp      |   31 +-
 dom/audiochannel/AudioChannelService.h        |   11 +-
 .../BrowserElementChildPreload.js             |   13 +-
 dom/browser-element/BrowserElementParent.jsm  |   17 +-
 dom/ipc/ContentChild.cpp                      |   66 +-
 dom/ipc/ContentChild.h                        |    5 +
 dom/ipc/ContentParent.cpp                     |  129 +-
 dom/ipc/ContentParent.h                       |   35 +-
 dom/ipc/PBrowser.ipdl                         |   14 -
 dom/ipc/PContent.ipdl                         |    6 +
 dom/ipc/ProcessPriorityManager.cpp            | 1204 ++++++++++-------
 dom/ipc/ProcessPriorityManager.h              |   89 +-
 dom/ipc/TabChild.cpp                          |    8 -
 dom/ipc/TabChild.h                            |   11 -
 dom/ipc/TabParent.cpp                         |   39 +-
 dom/ipc/TabParent.h                           |   14 +
 layout/build/nsLayoutStatics.cpp              |    2 +-
 21 files changed, 1137 insertions(+), 611 deletions(-)

diff --git a/content/base/public/nsIFrameLoader.idl b/content/base/public/nsIFrameLoader.idl
index 02a479b4880..ed0f088cc45 100644
--- a/content/base/public/nsIFrameLoader.idl
+++ b/content/base/public/nsIFrameLoader.idl
@@ -13,6 +13,7 @@ interface nsSubDocumentFrame;
 interface nsIMessageSender;
 interface nsIVariant;
 interface nsIDOMElement;
+interface nsITabParent;
 
 typedef unsigned long long nsContentViewId;
 
@@ -110,7 +111,7 @@ interface nsIContentViewManager : nsISupports
   readonly attribute nsIContentView rootContentView;
 };
 
-[scriptable, uuid(a4db652e-e3b0-4345-8107-cf6a30486759)]
+[scriptable, builtinclass, uuid(e4333e51-f2fa-4fdd-becd-75d000703355)]
 interface nsIFrameLoader : nsISupports
 {
   /**
@@ -118,6 +119,12 @@ interface nsIFrameLoader : nsISupports
    */
   readonly attribute nsIDocShell docShell;
 
+  /**
+   * Get this frame loader's TabParent, if it has a remote frame.  Otherwise,
+   * returns null.
+   */
+  readonly attribute nsITabParent tabParent;
+
   /**
    * Start loading the frame. This method figures out what to load
    * from the owner content in the frame loader.
@@ -249,6 +256,15 @@ interface nsIFrameLoader : nsISupports
    * returns the iframe element.
    */
   readonly attribute nsIDOMElement ownerElement;
+
+  /**
+   * Get or set this frame loader's visibility.
+   *
+   * The notion of "visibility" here is separate from the notion of a
+   * window/docshell's visibility.  This field is mostly here so that we can
+   * have a notion of visibility in the parent process when frames are OOP.
+   */
+  [infallible] attribute boolean visible;
 };
 
 %{C++
diff --git a/content/base/src/nsFrameLoader.cpp b/content/base/src/nsFrameLoader.cpp
index 6c24715495a..855de66033e 100644
--- a/content/base/src/nsFrameLoader.cpp
+++ b/content/base/src/nsFrameLoader.cpp
@@ -285,6 +285,7 @@ nsFrameLoader::nsFrameLoader(Element* aOwner, bool aNetworkCreated)
   , mClampScrollPosition(true)
   , mRemoteBrowserInitialized(false)
   , mObservingOwnerContent(false)
+  , mVisible(true)
   , mCurrentRemoteFrame(nullptr)
   , mRemoteBrowser(nullptr)
   , mRenderMode(RENDER_MODE_DEFAULT)
@@ -2551,3 +2552,29 @@ nsFrameLoader::ResetPermissionManagerStatus()
   }
 }
 
+/* [infallible] */ NS_IMETHODIMP
+nsFrameLoader::SetVisible(bool aVisible)
+{
+  mVisible = aVisible;
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (os) {
+    os->NotifyObservers(NS_ISUPPORTS_CAST(nsIFrameLoader*, this),
+                        "frameloader-visible-changed", nullptr);
+  }
+  return NS_OK;
+}
+
+/* [infallible] */ NS_IMETHODIMP
+nsFrameLoader::GetVisible(bool* aVisible)
+{
+  *aVisible = mVisible;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFrameLoader::GetTabParent(nsITabParent** aTabParent)
+{
+  nsCOMPtr<nsITabParent> tp = mRemoteBrowser;
+  tp.forget(aTabParent);
+  return NS_OK;
+}
diff --git a/content/base/src/nsFrameLoader.h b/content/base/src/nsFrameLoader.h
index 05c5d7db678..ce672582a5f 100644
--- a/content/base/src/nsFrameLoader.h
+++ b/content/base/src/nsFrameLoader.h
@@ -428,6 +428,11 @@ private:
   bool mRemoteBrowserInitialized : 1;
   bool mObservingOwnerContent : 1;
 
+  // Backs nsIFrameLoader::{Get,Set}Visible.  Visibility state here relates to
+  // whether this frameloader's <iframe mozbrowser> is setVisible(true)'ed, and
+  // doesn't necessarily correlate with docshell/document visibility.
+  bool mVisible : 1;
+
   // XXX leaking
   nsCOMPtr<nsIObserver> mChildHost;
   RenderFrameParent* mCurrentRemoteFrame;
diff --git a/content/canvas/src/WebGLContext.cpp b/content/canvas/src/WebGLContext.cpp
index 26b38dfb6ae..532ffa540d0 100644
--- a/content/canvas/src/WebGLContext.cpp
+++ b/content/canvas/src/WebGLContext.cpp
@@ -51,7 +51,6 @@
 
 using namespace mozilla;
 using namespace mozilla::dom;
-using namespace mozilla::dom::ipc;
 using namespace mozilla::gfx;
 using namespace mozilla::gl;
 using namespace mozilla::layers;
@@ -66,7 +65,8 @@ WebGLMemoryPressureObserver::Observe(nsISupports* aSubject,
 
     bool wantToLoseContext = true;
 
-    if (!mContext->mCanLoseContextInForeground && CurrentProcessIsForeground())
+    if (!mContext->mCanLoseContextInForeground &&
+        ProcessPriorityManager::CurrentProcessIsForeground())
         wantToLoseContext = false;
     else if (!nsCRT::strcmp(aSomeData,
                             NS_LITERAL_STRING("heap-minimize").get()))
diff --git a/dom/audiochannel/AudioChannelService.cpp b/dom/audiochannel/AudioChannelService.cpp
index 1b7981da33f..a5f31b6d17d 100644
--- a/dom/audiochannel/AudioChannelService.cpp
+++ b/dom/audiochannel/AudioChannelService.cpp
@@ -17,6 +17,7 @@
 #include "mozilla/dom/ContentParent.h"
 
 #include "nsThreadUtils.h"
+#include "nsHashPropertyBag.h"
 
 #ifdef MOZ_WIDGET_GONK
 #include "nsIAudioManager.h"
@@ -104,7 +105,7 @@ AudioChannelService::RegisterType(AudioChannelType aType, uint64_t aChildID)
   // In order to avoid race conditions, it's safer to notify any existing
   // agent any time a new one is registered.
   if (XRE_GetProcessType() == GeckoProcessType_Default) {
-    SendAudioChannelChangedNotification();
+    SendAudioChannelChangedNotification(aChildID);
     Notify();
   }
 }
@@ -142,7 +143,7 @@ AudioChannelService::UnregisterType(AudioChannelType aType,
         !mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].Contains(aChildID)) {
       mActiveContentChildIDs.RemoveElement(aChildID);
     }
-    SendAudioChannelChangedNotification();
+    SendAudioChannelChangedNotification(aChildID);
     Notify();
   }
 }
@@ -180,7 +181,6 @@ AudioChannelService::GetMuted(AudioChannelAgent* aAgent, bool aElementHidden)
                                 aElementHidden, oldElementHidden);
   data->mMuted = muted;
 
-  SendAudioChannelChangedNotification();
   return muted;
 }
 
@@ -207,7 +207,6 @@ AudioChannelService::GetMutedInternal(AudioChannelType aType, uint64_t aChildID,
       mActiveContentChildIDs.AppendElement(aChildID);
     }
   }
-
   else if (newType == AUDIO_CHANNEL_INT_CONTENT_HIDDEN &&
            oldType == AUDIO_CHANNEL_INT_CONTENT &&
            !mActiveContentChildIDsFrozen) {
@@ -228,6 +227,8 @@ AudioChannelService::GetMutedInternal(AudioChannelType aType, uint64_t aChildID,
     Notify();
   }
 
+  SendAudioChannelChangedNotification(aChildID);
+
   // Let play any visible audio channel.
   if (!aElementHidden) {
     return false;
@@ -258,13 +259,29 @@ AudioChannelService::ContentOrNormalChannelIsActive()
          !mChannelCounters[AUDIO_CHANNEL_INT_NORMAL].IsEmpty();
 }
 
+bool
+AudioChannelService::ProcessContentOrNormalChannelIsActive(uint64_t aChildID)
+{
+  return mChannelCounters[AUDIO_CHANNEL_INT_CONTENT].Contains(aChildID) ||
+         mChannelCounters[AUDIO_CHANNEL_INT_CONTENT_HIDDEN].Contains(aChildID) ||
+         mChannelCounters[AUDIO_CHANNEL_INT_NORMAL].Contains(aChildID);
+}
+
 void
-AudioChannelService::SendAudioChannelChangedNotification()
+AudioChannelService::SendAudioChannelChangedNotification(uint64_t aChildID)
 {
   if (XRE_GetProcessType() != GeckoProcessType_Default) {
     return;
   }
 
+  nsRefPtr<nsHashPropertyBag> props = new nsHashPropertyBag();
+  props->Init();
+  props->SetPropertyAsUint64(NS_LITERAL_STRING("childID"), aChildID);
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  obs->NotifyObservers(static_cast<nsIWritablePropertyBag*>(props),
+                       "audio-channel-process-changed", nullptr);
+
   // Calculating the most important active channel.
   AudioChannelType higher = AUDIO_CHANNEL_LAST;
 
@@ -341,7 +358,6 @@ AudioChannelService::SendAudioChannelChangedNotification()
       channelName.AssignLiteral("none");
     }
 
-    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
     obs->NotifyObservers(nullptr, "audio-channel-changed", channelName.get());
   }
 
@@ -355,7 +371,6 @@ AudioChannelService::SendAudioChannelChangedNotification()
       channelName.AssignLiteral("none");
     }
 
-    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
     obs->NotifyObservers(nullptr, "visible-audio-channel-changed", channelName.get());
   }
 }
@@ -461,7 +476,7 @@ AudioChannelService::Observe(nsISupports* aSubject, const char* aTopic, const PR
     // We don't have to remove the agents from the mAgents hashtable because if
     // that table contains only agents running on the same process.
 
-    SendAudioChannelChangedNotification();
+    SendAudioChannelChangedNotification(childID);
     Notify();
   } else {
     NS_WARNING("ipc:content-shutdown message without childID property");
diff --git a/dom/audiochannel/AudioChannelService.h b/dom/audiochannel/AudioChannelService.h
index 6f92ec66081..178d0cdc250 100644
--- a/dom/audiochannel/AudioChannelService.h
+++ b/dom/audiochannel/AudioChannelService.h
@@ -60,13 +60,20 @@ public:
    */
   virtual bool ContentOrNormalChannelIsActive();
 
+  /**
+   * Return true iff a normal or content channel is active for the given process
+   * ID.
+   */
+  virtual bool ProcessContentOrNormalChannelIsActive(uint64_t aChildID);
+
 protected:
   void Notify();
 
   /**
-   * Send the audio-channel-changed notification if needed.
+   * Send the audio-channel-changed notification for the given process ID if
+   * needed.
    */
-  void SendAudioChannelChangedNotification();
+  void SendAudioChannelChangedNotification(uint64_t aChildID);
 
   /* Register/Unregister IPC types: */
   void RegisterType(AudioChannelType aType, uint64_t aChildID);
diff --git a/dom/browser-element/BrowserElementChildPreload.js b/dom/browser-element/BrowserElementChildPreload.js
index a8d6f36f472..5d7c51c0dcc 100644
--- a/dom/browser-element/BrowserElementChildPreload.js
+++ b/dom/browser-element/BrowserElementChildPreload.js
@@ -646,13 +646,7 @@ BrowserElementChild.prototype = {
     }
 
     this._forcedVisible = data.json.visible;
-    this._updateDocShellVisibility();
-
-    // Fire a notification to the ProcessPriorityManager to reset this
-    // process's priority now (as opposed to after a brief delay).
-    var os = Cc["@mozilla.org/observer-service;1"].getService(Ci.nsIObserverService);
-    os.notifyObservers(/* subject */ null, 'process-priority:reset-now',
-                       /* data */ null);
+    this._updateVisibility();
   },
 
   _recvVisible: function(data) {
@@ -669,13 +663,14 @@ BrowserElementChild.prototype = {
   _recvOwnerVisibilityChange: function(data) {
     debug("Received ownerVisibilityChange: (" + data.json.visible + ")");
     this._ownerVisible = data.json.visible;
-    this._updateDocShellVisibility();
+    this._updateVisibility();
   },
 
-  _updateDocShellVisibility: function() {
+  _updateVisibility: function() {
     var visible = this._forcedVisible && this._ownerVisible;
     if (docShell.isActive !== visible) {
       docShell.isActive = visible;
+      sendAsyncMsg('visibility-change', {visibility: visible});
     }
   },
 
diff --git a/dom/browser-element/BrowserElementParent.jsm b/dom/browser-element/BrowserElementParent.jsm
index cf20bd60e2e..e566d453797 100644
--- a/dom/browser-element/BrowserElementParent.jsm
+++ b/dom/browser-element/BrowserElementParent.jsm
@@ -118,7 +118,8 @@ function BrowserElementParent(frameLoader, hasRemoteFrame) {
     "fullscreen-origin-change": this._remoteFullscreenOriginChange,
     "rollback-fullscreen": this._remoteFrameFullscreenReverted,
     "exit-fullscreen": this._exitFullscreen,
-    "got-visible": this._gotDOMRequestResult
+    "got-visible": this._gotDOMRequestResult,
+    "visibility-change": this._childVisibilityChange,
   }
 
   this._mm.addMessageListener('browser-element-api:call', function(aMsg) {
@@ -447,6 +448,7 @@ BrowserElementParent.prototype = {
 
   _setVisible: function(visible) {
     this._sendAsyncMsg('set-visible', {visible: visible});
+    this._frameLoader.visible = visible;
   },
 
   _sendMouseEvent: function(type, x, y, button, clickCount, modifiers) {
@@ -562,6 +564,19 @@ BrowserElementParent.prototype = {
                        {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;
+  },
+
   _exitFullscreen: function() {
     this._windowUtils.exitFullscreen();
   },
diff --git a/dom/ipc/ContentChild.cpp b/dom/ipc/ContentChild.cpp
index a186189b022..f32d7a78bfe 100644
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -48,6 +48,7 @@
 #include "nsJSEnvironment.h"
 #include "SandboxHal.h"
 #include "nsDebugImpl.h"
+#include "nsHashPropertyBag.h"
 #include "nsLayoutStylesheetCache.h"
 
 #include "IHistory.h"
@@ -571,12 +572,6 @@ ContentChild::RecvPBrowserConstructor(PBrowserChild* actor,
 {
     // This runs after AllocPBrowser() returns and the IPC machinery for this
     // PBrowserChild has been set up.
-    //
-    // We have to NotifyObservers("tab-child-created") before we
-    // TemporarilyLockProcessPriority because the NotifyObservers call may cause
-    // us to initialize the ProcessPriorityManager, and
-    // TemporarilyLockProcessPriority only works after the
-    // ProcessPriorityManager has been initialized.
 
     nsCOMPtr<nsIObserverService> os = services::GetObserverService();
     if (os) {
@@ -592,13 +587,6 @@ ContentChild::RecvPBrowserConstructor(PBrowserChild* actor,
         MOZ_ASSERT(!sFirstIdleTask);
         sFirstIdleTask = NewRunnableFunction(FirstIdle);
         MessageLoop::current()->PostIdleTask(FROM_HERE, sFirstIdleTask);
-
-        // We are either a brand-new process loading its first PBrowser, or we
-        // are the preallocated process transforming into a particular
-        // app/browser.  Either way, our parent has already set our process
-        // priority, and we want to leave it there for a few seconds while we
-        // start up.
-        TemporarilyLockProcessPriority();
     }
 
     return true;
@@ -1208,5 +1196,57 @@ ContentChild::RecvFileSystemUpdate(const nsString& aFsName,
     return true;
 }
 
+bool
+ContentChild::RecvNotifyProcessPriorityChanged(
+    const hal::ProcessPriority& aPriority)
+{
+    nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+    NS_ENSURE_TRUE(os, true);
+
+    nsRefPtr<nsHashPropertyBag> props = new nsHashPropertyBag();
+    props->Init();
+    props->SetPropertyAsInt32(NS_LITERAL_STRING("priority"),
+                              static_cast<int32_t>(aPriority));
+
+    os->NotifyObservers(static_cast<nsIPropertyBag2*>(props),
+                        "ipc:process-priority-changed",  nullptr);
+    return true;
+}
+
+bool
+ContentChild::RecvMinimizeMemoryUsage()
+{
+    nsCOMPtr<nsIMemoryReporterManager> mgr =
+        do_GetService("@mozilla.org/memory-reporter-manager;1");
+    NS_ENSURE_TRUE(mgr, true);
+
+    nsCOMPtr<nsICancelableRunnable> runnable =
+        do_QueryReferent(mMemoryMinimizerRunnable);
+
+    // Cancel the previous task if it's still pending.
+    if (runnable) {
+        runnable->Cancel();
+        runnable = nullptr;
+    }
+
+    mgr->MinimizeMemoryUsage(/* callback = */ nullptr,
+                             getter_AddRefs(runnable));
+    mMemoryMinimizerRunnable = do_GetWeakReference(runnable);
+    return true;
+}
+
+bool
+ContentChild::RecvCancelMinimizeMemoryUsage()
+{
+    nsCOMPtr<nsICancelableRunnable> runnable =
+        do_QueryReferent(mMemoryMinimizerRunnable);
+    if (runnable) {
+        runnable->Cancel();
+        mMemoryMinimizerRunnable = nullptr;
+    }
+
+    return true;
+}
+
 } // namespace dom
 } // namespace mozilla
diff --git a/dom/ipc/ContentChild.h b/dom/ipc/ContentChild.h
index af28f8c36ef..0fca5fc8155 100644
--- a/dom/ipc/ContentChild.h
+++ b/dom/ipc/ContentChild.h
@@ -192,6 +192,10 @@ public:
                                       const int32_t& aState,
                                       const int32_t& aMountGeneration);
 
+    virtual bool RecvNotifyProcessPriorityChanged(const hal::ProcessPriority& aPriority);
+    virtual bool RecvMinimizeMemoryUsage();
+    virtual bool RecvCancelMinimizeMemoryUsage();
+
 #ifdef ANDROID
     gfxIntSize GetScreenSize() { return mScreenSize; }
 #endif
@@ -244,6 +248,7 @@ private:
     bool mIsForApp;
     bool mIsForBrowser;
     nsString mProcessName;
+    nsWeakPtr mMemoryMinimizerRunnable;
 
     static ContentChild* sSingleton;
 
diff --git a/dom/ipc/ContentParent.cpp b/dom/ipc/ContentParent.cpp
index addd2e4f72a..afcc753b288 100644
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -59,6 +59,7 @@
 #include "nsFrameMessageManager.h"
 #include "nsHashPropertyBag.h"
 #include "nsIAlertsService.h"
+#include "nsIAppsService.h"
 #include "nsIClipboard.h"
 #include "nsIDOMApplicationRegistry.h"
 #include "nsIDOMGeoGeolocation.h"
@@ -221,8 +222,9 @@ static uint64_t gContentChildID = 1;
 ContentParent::PreallocateAppProcess()
 {
     nsRefPtr<ContentParent> process =
-        new ContentParent(MAGIC_PREALLOCATED_APP_MANIFEST_URL,
-                          /*isBrowserElement=*/false,
+        new ContentParent(/* app = */ nullptr,
+                          /* isForBrowserElement = */ false,
+                          /* isForPreallocated = */ true,
                           // Final privileges are set when we
                           // transform into our app.
                           base::PRIVILEGES_INHERIT,
@@ -339,8 +341,9 @@ ContentParent::GetNewOrUsed(bool aForBrowserElement)
     }
 
     nsRefPtr<ContentParent> p =
-        new ContentParent(/* appManifestURL = */ EmptyString(),
+        new ContentParent(/* app = */ nullptr,
                           aForBrowserElement,
+                          /* isForPreallocated = */ false,
                           base::PRIVILEGES_DEFAULT,
                           PROCESS_PRIORITY_FOREGROUND);
     p->Init();
@@ -461,8 +464,11 @@ ContentParent::CreateBrowserOrApp(const TabContext& aContext,
                                             initialPriority);
         if (!p) {
             NS_WARNING("Unable to use pre-allocated app process");
-            p = new ContentParent(manifestURL, /* isBrowserElement = */ false,
-                                  privs, initialPriority);
+            p = new ContentParent(ownApp,
+                                  /* isForBrowserElement = */ false,
+                                  /* isForPreallocated = */ false,
+                                  privs,
+                                  initialPriority);
             p->Init();
         }
         sAppContentParents->Put(manifestURL, p);
@@ -471,22 +477,10 @@ ContentParent::CreateBrowserOrApp(const TabContext& aContext,
     nsRefPtr<TabParent> tp = new TabParent(aContext);
     tp->SetOwnerElement(aFrameElement);
     PBrowserParent* browser = p->SendPBrowserConstructor(
-        tp.forget().get(), // DeallocPBrowserParent() releases this ref.
+        nsRefPtr<TabParent>(tp).forget().get(), // DeallocPBrowserParent() releases this ref.
         aContext.AsIPCTabContext(),
         /* chromeFlags */ 0);
 
-    // Send the frame element's mozapptype down to the child process.  This ends
-    // up in TabChild::GetAppType().  We have to do this /before/ we acquire the
-    // CPU wake lock for this process, because if the child sees that it has a
-    // CPU wake lock but its TabChild doesn't have the right mozapptype, it
-    // might downgrade its process priority.
-    nsCOMPtr<Element> frameElement = do_QueryInterface(aFrameElement);
-    if (frameElement) {
-      nsAutoString appType;
-      frameElement->GetAttr(kNameSpaceID_None, nsGkAtoms::mozapptype, appType);
-      unused << browser->SendSetAppType(appType);
-    }
-
     p->MaybeTakeCPUWakeLock(aFrameElement);
 
     return static_cast<TabParent*>(browser);
@@ -629,17 +623,6 @@ NS_IMPL_ISUPPORTS1(SystemMessageHandledListener,
 
 } // anonymous namespace
 
-void
-ContentParent::SetProcessPriority(ProcessPriority aPriority)
-{
-    if (!Preferences::GetBool("dom.ipc.processPriorityManager.enabled")) {
-        return;
-    }
-
-    hal::SetProcessPriority(base::GetProcId(mSubprocess->GetChildProcessHandle()),
-                            aPriority);
-}
-
 void
 ContentParent::MaybeTakeCPUWakeLock(nsIDOMElement* aFrameElement)
 {
@@ -667,7 +650,7 @@ ContentParent::MaybeTakeCPUWakeLock(nsIDOMElement* aFrameElement)
 bool
 ContentParent::SetPriorityAndCheckIsAlive(ProcessPriority aPriority)
 {
-    SetProcessPriority(aPriority);
+    ProcessPriorityManager::SetProcessPriority(this, aPriority);
 
     // Now that we've set this process's priority, check whether the process is
     // still alive.  Hopefully we've set the priority to FOREGROUND*, so the
@@ -686,14 +669,38 @@ ContentParent::SetPriorityAndCheckIsAlive(ProcessPriority aPriority)
     return true;
 }
 
+// Helper for ContentParent::TransformPreallocatedIntoApp.
+static void
+TryGetNameFromManifestURL(const nsAString& aManifestURL,
+                          nsAString& aName)
+{
+    aName.Truncate();
+    if (aManifestURL.IsEmpty() ||
+        aManifestURL == MAGIC_PREALLOCATED_APP_MANIFEST_URL) {
+        return;
+    }
+
+    nsCOMPtr<nsIAppsService> appsService = do_GetService(APPS_SERVICE_CONTRACTID);
+    NS_ENSURE_TRUE_VOID(appsService);
+
+    nsCOMPtr<mozIDOMApplication> domApp;
+    appsService->GetAppByManifestURL(aManifestURL, getter_AddRefs(domApp));
+
+    nsCOMPtr<mozIApplication> app = do_QueryInterface(domApp);
+    if (!app) {
+        return;
+    }
+
+    app->GetName(aName);
+}
+
 bool
 ContentParent::TransformPreallocatedIntoApp(const nsAString& aAppManifestURL,
                                             ChildPrivileges aPrivs)
 {
-    MOZ_ASSERT(mAppManifestURL == MAGIC_PREALLOCATED_APP_MANIFEST_URL);
-    // Clients should think of mAppManifestURL as const ... we're
-    // bending the rules here just for the preallocation hack.
-    const_cast<nsString&>(mAppManifestURL) = aAppManifestURL;
+    MOZ_ASSERT(IsPreallocated());
+    mAppManifestURL = aAppManifestURL;
+    TryGetNameFromManifestURL(aAppManifestURL, mAppName);
 
     return SendSetProcessPrivileges(aPrivs);
 }
@@ -1001,8 +1008,9 @@ ContentParent::GetTestShellSingleton()
     return static_cast<TestShellParent*>(ManagedPTestShellParent()[0]);
 }
 
-ContentParent::ContentParent(const nsAString& aAppManifestURL,
+ContentParent::ContentParent(mozIApplication* aApp,
                              bool aIsForBrowser,
+                             bool aIsForPreallocated,
                              ChildPrivileges aOSPrivileges,
                              ProcessPriority aInitialPriority /* = PROCESS_PRIORITY_FOREGROUND */)
     : mSubprocess(nullptr)
@@ -1011,7 +1019,6 @@ ContentParent::ContentParent(const nsAString& aAppManifestURL,
     , mGeolocationWatchID(-1)
     , mRunToCompletionDepth(0)
     , mShouldCallUnblockChild(false)
-    , mAppManifestURL(aAppManifestURL)
     , mForceKillTask(nullptr)
     , mNumDestroyingTabs(0)
     , mIsAlive(true)
@@ -1019,9 +1026,20 @@ ContentParent::ContentParent(const nsAString& aAppManifestURL,
     , mSendPermissionUpdates(false)
     , mIsForBrowser(aIsForBrowser)
 {
+    // No more than one of !!aApp, aIsForBrowser, and aIsForPreallocated should
+    // be true.
+    MOZ_ASSERT(!!aApp + aIsForBrowser + aIsForPreallocated <= 1);
+
     // Insert ourselves into the global linked list of ContentParent objects.
     sContentParents.insertBack(this);
 
+    if (aApp) {
+        aApp->GetManifestURL(mAppManifestURL);
+        aApp->GetName(mAppName);
+    } else if (aIsForPreallocated) {
+        mAppManifestURL = MAGIC_PREALLOCATED_APP_MANIFEST_URL;
+    }
+
     // From this point on, NS_WARNING, NS_ASSERTION, etc. should print out the
     // PID along with the warning.
     nsDebugImpl::SetMultiprocessMode("Parent");
@@ -1032,13 +1050,16 @@ ContentParent::ContentParent(const nsAString& aAppManifestURL,
 
     mSubprocess->LaunchAndWaitForProcessHandle();
 
-    // Set the subprocess's priority.  We do this first because we're likely
-    // /lowering/ its CPU and memory priority, which it has inherited from this
-    // process.
-    SetProcessPriority(aInitialPriority);
-
     Open(mSubprocess->GetChannel(), mSubprocess->GetChildProcessHandle());
 
+    // Set the subprocess's priority.  We do this early on because we're likely
+    // /lowering/ the process's CPU and memory priority, which it has inherited
+    // from this process.
+    //
+    // This call can cause us to send IPC messages to the child process, so it
+    // must come after the Open() call above.
+    ProcessPriorityManager::SetProcessPriority(this, aInitialPriority);
+
     // NB: internally, this will send an IPC message to the child
     // process to get it to create the CompositorChild.  This
     // message goes through the regular IPC queue for this
@@ -1369,7 +1390,7 @@ ContentParent::RecvAudioChannelChangedNotification()
     nsRefPtr<AudioChannelService> service =
         AudioChannelService::GetAudioChannelService();
     if (service) {
-       service->SendAudioChannelChangedNotification();
+       service->SendAudioChannelChangedNotification(ChildID());
     }
     return true;
 }
@@ -1714,6 +1735,30 @@ ContentParent::KillHard()
                             OtherProcess(), /*force=*/true));
 }
 
+bool
+ContentParent::IsPreallocated()
+{
+    return mAppManifestURL == MAGIC_PREALLOCATED_APP_MANIFEST_URL;
+}
+
+void
+ContentParent::FriendlyName(nsAString& aName)
+{
+    aName.Truncate();
+    if (IsPreallocated()) {
+        aName.AssignLiteral("(Preallocated)");
+    } else if (mIsForBrowser) {
+        aName.AssignLiteral("Browser");
+    } else if (!mAppName.IsEmpty()) {
+        aName = mAppName;
+    } else if (!mAppManifestURL.IsEmpty()) {
+        aName.AssignLiteral("Unknown app: ");
+        aName.Append(mAppManifestURL);
+    } else {
+        aName.AssignLiteral("???");
+    }
+}
+
 PCrashReporterParent*
 ContentParent::AllocPCrashReporter(const NativeThreadId& tid,
                                    const uint32_t& processType)
diff --git a/dom/ipc/ContentParent.h b/dom/ipc/ContentParent.h
index 2fda4e1e5a9..fe00d644353 100644
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -16,6 +16,7 @@
 #include "mozilla/dom/ipc/Blob.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/HalTypes.h"
+#include "mozilla/LinkedList.h"
 
 #include "nsFrameMessageManager.h"
 #include "nsIObserver.h"
@@ -137,6 +138,10 @@ public:
         return mSubprocess;
     }
 
+    int32_t Pid() {
+        return base::GetProcId(mSubprocess->GetChildProcessHandle());
+    }
+
     bool NeedsPermissionsUpdate() {
         return mSendPermissionUpdates;
     }
@@ -151,6 +156,15 @@ public:
     void KillHard();
 
     uint64_t ChildID() { return mChildID; }
+    bool IsPreallocated();
+
+    /**
+     * Get a user-friendly name for this ContentParent.  We make no guarantees
+     * about this name: It might not be unique, apps can spoof special names,
+     * etc.  So please don't use this name to make any decisions about the
+     * ContentParent based on the value returned here.
+     */
+    void FriendlyName(nsAString& aName);
 
 protected:
     void OnChannelConnected(int32_t pid);
@@ -180,17 +194,18 @@ private:
     using PContentParent::SendPBrowserConstructor;
     using PContentParent::SendPTestShellConstructor;
 
-    ContentParent(const nsAString& aAppManifestURL, bool aIsForBrowser,
+    // No more than one of !!aApp, aIsForBrowser, and aIsForPreallocated may be
+    // true.
+    ContentParent(mozIApplication* aApp,
+                  bool aIsForBrowser,
+                  bool aIsForPreallocated,
                   ChildPrivileges aOSPrivileges = base::PRIVILEGES_DEFAULT,
                   hal::ProcessPriority aInitialPriority = hal::PROCESS_PRIORITY_FOREGROUND);
+
     virtual ~ContentParent();
 
     void Init();
 
-    // Set the child process's priority.  Once the child starts up, it will
-    // manage its own priority via the ProcessPriorityManager.
-    void SetProcessPriority(hal::ProcessPriority aInitialPriority);
-
     // If the frame element indicates that the child process is "critical" and
     // has a pending system message, this function acquires the CPU wake lock on
     // behalf of the child.  We'll release the lock when the system message is
@@ -406,7 +421,15 @@ private:
     // the nsIObserverService.
     nsCOMArray<nsIMemoryReporter> mMemoryReporters;
 
-    const nsString mAppManifestURL;
+    nsString mAppManifestURL;
+
+    /**
+     * We cache mAppName instead of looking it up using mAppManifestURL when we
+     * need it because it turns out that getting an app from the apps service is
+     * expensive.
+     */
+    nsString mAppName;
+
     nsRefPtr<nsFrameMessageManager> mMessageManager;
 
     // After we initiate shutdown, we also start a timer to ensure
diff --git a/dom/ipc/PBrowser.ipdl b/dom/ipc/PBrowser.ipdl
index 29e710f4df0..4ad05444135 100644
--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -384,20 +384,6 @@ child:
                       uint32_t renderFlags, bool flushLayout,
                       nsIntSize renderSize);
 
-    /**
-     * Send the child its app type.  The app type identifies the kind of app
-     * shown in this PBrowser.  Currently, the only recognized app type is
-     * "homescreen".
-     *
-     * The value here corresponds to the "mozapptype" attribute on iframes.  For
-     * example, <iframe mozbrowser mozapp="..." mozapptype="homescreen">.
-     *
-     * Only app frames (i.e., frames with an app-id) should have a non-empty app
-     * type.  If you try to SetAppType() with a non-empty app type on a non-app
-     * PBrowserChild, we may assert.
-     */
-    SetAppType(nsString appType);
-
     /**
      * Sent by the chrome process when it no longer wants this remote
      * <browser>.  The child side cleans up in response, then
diff --git a/dom/ipc/PContent.ipdl b/dom/ipc/PContent.ipdl
index ebcd9612a28..bf6545dd96f 100644
--- a/dom/ipc/PContent.ipdl
+++ b/dom/ipc/PContent.ipdl
@@ -27,6 +27,7 @@ include URIParams;
 include "mozilla/chrome/RegistryMessageUtils.h";
 include "mozilla/dom/PermissionMessageUtils.h";
 include "mozilla/dom/TabMessageUtils.h";
+include "mozilla/HalTypes.h";
 include "mozilla/layout/RenderFrameUtils.h";
 include "mozilla/net/NeckoMessageUtils.h";
 include "nsGeoPositionIPCSerialiser.h";
@@ -44,6 +45,7 @@ using mozilla::null_t;
 using mozilla::void_t;
 using mozilla::dom::AudioChannelType;
 using mozilla::dom::NativeThreadId;
+using mozilla::hal::ProcessPriority;
 using mozilla::layout::ScrollingBehavior;
 using gfxIntSize;
 
@@ -349,6 +351,10 @@ child:
     FileSystemUpdate(nsString fsName, nsString mountPoint, int32_t fsState,
                      int32_t mountGeneration);
 
+    NotifyProcessPriorityChanged(ProcessPriority priority);
+    MinimizeMemoryUsage();
+    CancelMinimizeMemoryUsage();
+
 parent:
     /**
      * Tell the content process some attributes of itself.  This is
diff --git a/dom/ipc/ProcessPriorityManager.cpp b/dom/ipc/ProcessPriorityManager.cpp
index fc2aaa6bcdc..c6974fb9954 100644
--- a/dom/ipc/ProcessPriorityManager.cpp
+++ b/dom/ipc/ProcessPriorityManager.cpp
@@ -4,15 +4,14 @@
  * 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 "ProcessPriorityManager.h"
 #include "mozilla/ClearOnShutdown.h"
-#include "mozilla/ProcessPriorityManager.h"
-#include "mozilla/dom/ContentChild.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/TabParent.h"
 #include "mozilla/Hal.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Services.h"
-#include "mozilla/HalTypes.h"
-#include "mozilla/TimeStamp.h"
+#include "mozilla/unused.h"
 #include "AudioChannelService.h"
 #include "prlog.h"
 #include "nsPrintfCString.h"
@@ -29,6 +28,10 @@
 #include "nsIDOMDocument.h"
 #include "nsPIDOMWindow.h"
 #include "StaticPtr.h"
+#include "nsIObserver.h"
+#include "nsITimer.h"
+#include "nsPrintfCString.h"
+#include "prlog.h"
 
 #ifdef XP_WIN
 #include <process.h>
@@ -37,373 +40,614 @@
 #include <unistd.h>
 #endif
 
-using namespace mozilla::hal;
-
-namespace mozilla {
-namespace dom {
-namespace ipc {
-
-namespace {
-static bool sInitialized = false;
-class ProcessPriorityManager;
-static StaticRefPtr<ProcessPriorityManager> sManager;
-
-// Some header defines a LOG macro, but we don't want it here.
 #ifdef LOG
 #undef LOG
 #endif
 
-// Enable logging by setting
+// Use LOGP inside a ParticularProcessPriorityManager method; use LOG
+// everywhere else.  LOGP prints out information about the particular process
+// priority manager.
 //
-//   NSPR_LOG_MODULES=ProcessPriorityManager:5
-//
-// in your environment.  Or just comment out the "&& 0" below, if you're on
-// Android/B2G.
+// (Wow, our logging story is a huge mess.)
 
-#if defined(ANDROID) && 0
-#include <android/log.h>
-#define LOG(fmt, ...) \
-  __android_log_print(ANDROID_LOG_INFO, \
+// #define ENABLE_LOGGING 1
+
+#if defined(ANDROID) && defined(ENABLE_LOGGING)
+#  include <android/log.h>
+#  define LOG(fmt, ...) \
+     __android_log_print(ANDROID_LOG_INFO, \
+       "Gecko:ProcessPriorityManager", \
+       fmt, ## __VA_ARGS__)
+#  define LOGP(fmt, ...) \
+    __android_log_print(ANDROID_LOG_INFO, \
       "Gecko:ProcessPriorityManager", \
-      fmt, ## __VA_ARGS__)
+      "[%schild-id=%llu, pid=%d] " fmt, \
+      NameWithComma().get(), \
+      (long long unsigned) ChildID(), Pid(), ## __VA_ARGS__)
+
+#elif defined(ENABLE_LOGGING)
+#  define LOG(fmt, ...) \
+     printf("ProcessPriorityManager - " fmt "\n", ##__VA_ARGS__)
+#  define LOGP(fmt, ...) \
+     printf("ProcessPriorityManager[%schild-id=%llu, pid=%d] - " fmt "\n", \
+       NameWithComma().get(), \
+       (unsigned long long) ChildID(), Pid(), ##__VA_ARGS__)
+
 #elif defined(PR_LOGGING)
-static PRLogModuleInfo*
-GetPPMLog()
-{
-  static PRLogModuleInfo *sLog;
-  if (!sLog)
-    sLog = PR_NewLogModule("ProcessPriorityManager");
-  return sLog;
-}
-#define LOG(fmt, ...) \
-  PR_LOG(GetPPMLog(), PR_LOG_DEBUG,                                     \
-         ("[%d] ProcessPriorityManager - " fmt, getpid(), ##__VA_ARGS__))
+  static PRLogModuleInfo*
+  GetPPMLog()
+  {
+    static PRLogModuleInfo *sLog;
+    if (!sLog)
+      sLog = PR_NewLogModule("ProcessPriorityManager");
+    return sLog;
+  }
+#  define LOG(fmt, ...) \
+     PR_LOG(GetPPMLog(), PR_LOG_DEBUG, \
+            ("ProcessPriorityManager - " fmt, ##__VA_ARGS__))
+#  define LOGP(fmt, ...) \
+     PR_LOG(GetPPMLog(), PR_LOG_DEBUG, \
+            ("ProcessPriorityManager[%schild-id=%llu, pid=%d] - " fmt, \
+            NameWithComma().get(), \
+            (unsigned long long) ChildID(), Pid(), ##__VA_ARGS__))
 #else
 #define LOG(fmt, ...)
+#define LOGP(fmt, ...)
 #endif
 
-uint64_t
-GetContentChildID()
-{
-  ContentChild* contentChild = ContentChild::GetSingleton();
-  if (!contentChild) {
-    return 0;
-  }
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::hal;
 
-  return contentChild->GetID();
-}
+namespace {
+
+class ParticularProcessPriorityManager;
 
 /**
- * This class listens to various Gecko events and asks the hal back-end to
- * change this process's priority when it transitions between various states of
- * "importance".
+ * This singleton class does the work to implement the process priority manager
+ * in the main process.  This class may not be used in child processes.  (You
+ * can call StaticInit, but it won't do anything, and GetSingleton() will
+ * return null.)
  *
- * The process's priority determines its CPU priority and also how likely it is
- * to be killed when the system is running out of memory.
- *
- * The most basic dichotomy in the ProcessPriorityManager is between
- * "foreground" processes, which usually have at least one active docshell, and
- * "background" processes.
- *
- * An important heuristic here is that we don't always mark a process as having
- * "background" priority until it's met the requisite criteria for some amount
- * of time.
- *
- * We do this because otherwise there are cases where we'd thrash a process
- * between foreground and background priorities; for example, Gaia sometimes
- * releases and re-acquires CPU wake locks in quick succession.
- *
- * On the other hand, when the embedder of an <iframe mozbrowser> calls
- * setVisible(false) on an iframe, we immediately send the relevant process to
- * the background, if it has no other foreground docshells.  This is necessary
- * to ensure that when we load an app, the embedder first has a chance to send
- * the previous app into the background.  This ensures that there's only one
- * foreground app at a time, thus ensuring that we kill the right process if we
- * come under memory pressure.
+ * ProcessPriorityManager::CurrentProcessIsForeground(), which can be called in
+ * any process, is handled separately, by the ProcessPriorityManagerChild
+ * class.
  */
-class ProcessPriorityManager MOZ_FINAL
+class ProcessPriorityManagerImpl MOZ_FINAL
   : public nsIObserver
-  , public nsIDOMEventListener
-  , public nsITimerCallback
-  , public WakeLockObserver
 {
 public:
-  ProcessPriorityManager();
-  void Init();
+  /**
+   * If we're in the main process, get the ProcessPriorityManagerImpl
+   * singleton.  If we're in a child process, return null.
+   */
+  static ProcessPriorityManagerImpl* GetSingleton();
+
+  static void StaticInit();
+  static bool PrefsEnabled();
 
   NS_DECL_ISUPPORTS
-  NS_DECL_NSITIMERCALLBACK
   NS_DECL_NSIOBSERVER
-  NS_DECL_NSIDOMEVENTLISTENER
-  void Notify(const WakeLockInformation& aWakeLockInfo);
-
-  ProcessPriority GetPriority() const { return mProcessPriority; }
 
   /**
-   * This function doesn't do exactly what you might think; see the comment on
-   * ProcessPriorityManager.h::TemporarilyLockProcessPriority().
+   * This function implements ProcessPriorityManager::SetProcessPriority.
    */
-  void TemporarilyLockProcessPriority();
+  void SetProcessPriority(ContentParent* aContentParent,
+                          ProcessPriority aPriority);
 
   /**
-   * Recompute this process's priority and apply it, potentially after a brief
-   * delay.
-   *
-   * If we are transitioning to a priority that is lower than the current
-   * priority, that transition happens after a grace period.  Otherwise the
-   * transition happens immediately.
-   *
-   * Note that PROCESS_PRIORITY_UNKNOWN is considered the highest priority.
-   * Going from UNKNOWN to any other priority requires a grace period.
+   * If a magic testing-only pref is set, notify the observer service on the
+   * given topic with the given data.  This is used for testing
    */
-  void ResetPriority();
-
-  /**
-   * Recompute this process's priority and apply it immediately.
-   */
-  void ResetPriorityNow();
+  void FireTestOnlyObserverNotification(const char* aTopic,
+                                        const nsACString& aData = EmptyCString());
 
 private:
-  void OnContentDocumentGlobalCreated(nsISupports* aOuterWindow);
+  static bool sPrefListenersRegistered;
+  static bool sInitialized;
+  static StaticRefPtr<ProcessPriorityManagerImpl> sSingleton;
 
-  /**
-   * Is this process a "critical" process that's holding the "CPU" or
-   * "high-priority" wake lock?
-   */
-  bool IsCriticalProcessWithWakeLock();
+  static int PrefChangedCallback(const char* aPref, void* aClosure);
 
-  /**
-   * Compute whether this process is in the foreground and return the result.
-   */
-  bool ComputeIsInForeground();
+  ProcessPriorityManagerImpl();
+  ~ProcessPriorityManagerImpl() {}
+  DISALLOW_EVIL_CONSTRUCTORS(ProcessPriorityManagerImpl);
 
-  /**
-   * Compute the priority this process ought to have, based on what we know at
-   * the moment.
-   */
-  ProcessPriority ComputePriority();
+  void Init();
 
-  /**
-   * Immediately set this process's priority to the given priority.
-   */
-  void SetPriorityNow(ProcessPriority aPriority);
+  already_AddRefed<ParticularProcessPriorityManager>
+  GetParticularProcessPriorityManager(ContentParent* aContentParent);
 
-  /**
-   * If mResetPriorityTimer is null (i.e., not running), create a timer and set
-   * it to invoke ResetPriorityNow() after
-   * dom.ipc.processPriorityManager.aTimeoutPref ms.
-   */
-  void ScheduleResetPriority(const char* aTimeoutPref);
+  void ObserveContentParentCreated(nsISupports* aContentParent);
+  void ObserveContentParentDestroyed(nsISupports* aSubject);
 
-  // Tracks whether this process holds the "cpu" lock.
-  bool mHoldsCPUWakeLock;
-
-  // Tracks whether this process holds the "high-priority" lock.
-  bool mHoldsHighPriorityWakeLock;
-
-  // mProcessPriority tracks the priority we've given this process in hal.
-  ProcessPriority mProcessPriority;
-
-  // Have we seen at least one tab-child-created event yet?  Until this is
-  // true, ResetPriority() and ResetPriorityNow() do nothing.
-  bool mObservedTabChildCreated;
-
-  nsTArray<nsWeakPtr> mWindows;
-
-  // When this timer expires, we set mResetPriorityTimer to null and run
-  // ResetPriorityNow().
-  nsCOMPtr<nsITimer> mResetPriorityTimer;
-
-  nsWeakPtr mMemoryMinimizerRunnable;
+  nsDataHashtable<nsUint64HashKey, nsRefPtr<ParticularProcessPriorityManager> >
+    mParticularManagers;
 };
 
-NS_IMPL_ISUPPORTS3(ProcessPriorityManager,
-                   nsIObserver,
-                   nsIDOMEventListener,
-                   nsITimerCallback)
-
-ProcessPriorityManager::ProcessPriorityManager()
-  : mHoldsCPUWakeLock(false)
-  , mHoldsHighPriorityWakeLock(false)
-  , mProcessPriority(ProcessPriority(-1))
-  , mObservedTabChildCreated(false)
+/**
+ * This singleton class implements the parts of the process priority manager
+ * that are available from all processes.
+ */
+class ProcessPriorityManagerChild MOZ_FINAL
+  : public nsIObserver
 {
-  // When our parent process forked us, it may have set our process's priority
-  // to one of a few of the process priorities, depending on exactly why this
-  // process was created.
-  //
-  // We don't know which priority we were given, so we set mProcessPriority to
-  // -1 so that the next time ResetPriorityNow is run, we'll definitely call
-  // into hal and set our priority.
+public:
+  static void StaticInit();
+  static ProcessPriorityManagerChild* Singleton();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  bool CurrentProcessIsForeground();
+
+private:
+  static StaticRefPtr<ProcessPriorityManagerChild> sSingleton;
+
+  ProcessPriorityManagerChild();
+  ~ProcessPriorityManagerChild() {}
+  DISALLOW_EVIL_CONSTRUCTORS(ProcessPriorityManagerChild);
+
+  void Init();
+
+  hal::ProcessPriority mCachedPriority;
+};
+
+/**
+ * This class manages the priority of one particular process.  It is
+ * main-process only.
+ */
+class ParticularProcessPriorityManager MOZ_FINAL
+  : public WakeLockObserver
+  , public nsIObserver
+  , public nsITimerCallback
+{
+public:
+  ParticularProcessPriorityManager(ContentParent* aContentParent);
+  ~ParticularProcessPriorityManager();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSITIMERCALLBACK
+
+  virtual void Notify(const WakeLockInformation& aInfo) MOZ_OVERRIDE;
+  void Init();
+
+  int32_t Pid() const;
+  uint64_t ChildID() const;
+
+  /**
+   * Used in logging, this method returns the ContentParent's name followed by
+   * ", ".  If we can't get the ContentParent's name for some reason, it
+   * returns an empty string.
+   *
+   * The reference returned here is guaranteed to be live until the next call
+   * to NameWithComma() or until the ParticularProcessPriorityManager is
+   * destroyed, whichever comes first.
+   */
+  const nsAutoCString& NameWithComma();
+
+  bool HasAppType(const char* aAppType);
+
+  void OnAudioChannelProcessChanged(nsISupports* aSubject);
+  void OnRemoteBrowserFrameShown(nsISupports* aSubject);
+  void OnTabParentDestroyed(nsISupports* aSubject);
+  void OnFrameloaderVisibleChanged(nsISupports* aSubject);
+  void OnChannelConnected(nsISupports* aSubject);
+
+  ProcessPriority ComputePriority();
+  void ScheduleResetPriority(const char* aTimeoutPref);
+  void ResetPriority();
+  void ResetPriorityNow();
+
+  void SetPriorityNow(ProcessPriority aPriority);
+
+  void ShutDown();
+
+private:
+  void FireTestOnlyObserverNotification(
+    const char* aTopic,
+    const nsACString& aData = EmptyCString());
+
+  void FireTestOnlyObserverNotification(
+    const char* aTopic,
+    const char* aData = nullptr);
+
+  ContentParent* mContentParent;
+  uint64_t mChildID;
+  ProcessPriority mPriority;
+  bool mHoldsCPUWakeLock;
+  bool mHoldsHighPriorityWakeLock;
+
+  /**
+   * Used to implement NameWithComma().
+   */
+  nsAutoCString mNameWithComma;
+
+  nsCOMPtr<nsITimer> mResetPriorityTimer;
+};
+
+/* static */ bool ProcessPriorityManagerImpl::sInitialized = false;
+/* static */ bool ProcessPriorityManagerImpl::sPrefListenersRegistered = false;
+/* static */ StaticRefPtr<ProcessPriorityManagerImpl>
+  ProcessPriorityManagerImpl::sSingleton;
+
+NS_IMPL_ISUPPORTS1(ProcessPriorityManagerImpl,
+                   nsIObserver);
+
+/* static */ int
+ProcessPriorityManagerImpl::PrefChangedCallback(const char* aPref,
+                                                void* aClosure)
+{
+  StaticInit();
+  return 0;
+}
+
+/* static */ bool
+ProcessPriorityManagerImpl::PrefsEnabled()
+{
+  return Preferences::GetBool("dom.ipc.processPriorityManager.enabled") &&
+         !Preferences::GetBool("dom.ipc.tabs.disabled");
+}
+
+/* static */ void
+ProcessPriorityManagerImpl::StaticInit()
+{
+  if (sInitialized) {
+    return;
+  }
+
+  // The process priority manager is main-process only.
+  if (XRE_GetProcessType() != GeckoProcessType_Default) {
+    sInitialized = true;
+    return;
+  }
+
+  // If IPC tabs aren't enabled at startup, don't bother with any of this.
+  if (!PrefsEnabled()) {
+    LOG("InitProcessPriorityManager bailing due to prefs.");
+
+    // Run StaticInit() again if the prefs change.  We don't expect this to
+    // happen in normal operation, but it happens during testing.
+    if (!sPrefListenersRegistered) {
+      sPrefListenersRegistered = true;
+      Preferences::RegisterCallback(PrefChangedCallback,
+                                    "dom.ipc.processPriorityManager.enabled");
+      Preferences::RegisterCallback(PrefChangedCallback,
+                                    "dom.ipc.tabs.disabled");
+    }
+    return;
+  }
+
+  sInitialized = true;
+
+  sSingleton = new ProcessPriorityManagerImpl();
+  sSingleton->Init();
+  ClearOnShutdown(&sSingleton);
+}
+
+/* static */ ProcessPriorityManagerImpl*
+ProcessPriorityManagerImpl::GetSingleton()
+{
+  if (!sSingleton) {
+    StaticInit();
+  }
+
+  return sSingleton;
+}
+
+ProcessPriorityManagerImpl::ProcessPriorityManagerImpl()
+{
+  MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
+  mParticularManagers.Init();
 }
 
 void
-ProcessPriorityManager::Init()
+ProcessPriorityManagerImpl::Init()
 {
-  LOG("Starting up.");
+  LOG("Starting up.  This is the master process.");
+
+  // The master process's priority never changes; set it here and then forget
+  // about it.  We'll manage only subprocesses' priorities using the process
+  // priority manager.
+  hal::SetProcessPriority(getpid(), PROCESS_PRIORITY_MASTER);
 
-  // We can't do this in the constructor because we need to hold a strong ref
-  // to |this| before calling these methods.
-  //
-  // Notice that we track /window/ creation and destruction even though our
-  // notion of "is-foreground" is tied to /docshell/ activity.  We do this
-  // because docshells don't fire an event when their visibility changes, but
-  // windows do.
   nsCOMPtr<nsIObserverService> os = services::GetObserverService();
-  os->AddObserver(this, "tab-child-created", /* ownsWeak = */ false);
-  os->AddObserver(this, "content-document-global-created", /* ownsWeak = */ false);
-  os->AddObserver(this, "inner-window-destroyed", /* ownsWeak = */ false);
-  os->AddObserver(this, "audio-channel-agent-changed", /* ownsWeak = */ false);
-  os->AddObserver(this, "process-priority:reset-now", /* ownsWeak = */ false);
+  if (os) {
+    os->AddObserver(this, "ipc:content-created", /* ownsWeak */ false);
+    os->AddObserver(this, "ipc:content-shutdown", /* ownsWeak */ false);
+  }
+}
 
+NS_IMETHODIMP
+ProcessPriorityManagerImpl::Observe(
+  nsISupports* aSubject,
+  const char* aTopic,
+  const PRUnichar* aData)
+{
+  nsDependentCString topic(aTopic);
+  if (topic.EqualsLiteral("ipc:content-created")) {
+    ObserveContentParentCreated(aSubject);
+  } else if (topic.EqualsLiteral("ipc:content-shutdown")) {
+    ObserveContentParentDestroyed(aSubject);
+  } else {
+    MOZ_ASSERT(false);
+  }
+
+  return NS_OK;
+}
+
+already_AddRefed<ParticularProcessPriorityManager>
+ProcessPriorityManagerImpl::GetParticularProcessPriorityManager(
+  ContentParent* aContentParent)
+{
+  nsRefPtr<ParticularProcessPriorityManager> pppm;
+  mParticularManagers.Get(aContentParent->ChildID(), &pppm);
+  if (!pppm) {
+    pppm = new ParticularProcessPriorityManager(aContentParent);
+    pppm->Init();
+    mParticularManagers.Put(aContentParent->ChildID(), pppm);
+
+    FireTestOnlyObserverNotification("process-created",
+      nsPrintfCString("%lld", aContentParent->ChildID()));
+  }
+
+  return pppm.forget();
+}
+
+void
+ProcessPriorityManagerImpl::SetProcessPriority(ContentParent* aContentParent,
+                                               ProcessPriority aPriority)
+{
+  MOZ_ASSERT(aContentParent);
+  nsRefPtr<ParticularProcessPriorityManager> pppm =
+    GetParticularProcessPriorityManager(aContentParent);
+  pppm->SetPriorityNow(aPriority);
+}
+
+void
+ProcessPriorityManagerImpl::ObserveContentParentCreated(
+  nsISupports* aContentParent)
+{
+  // Do nothing; it's sufficient to get the PPPM.  But assign to nsRefPtr so we
+  // don't leak the already_AddRefed object.
+  nsCOMPtr<nsIObserver> cp = do_QueryInterface(aContentParent);
+  nsRefPtr<ParticularProcessPriorityManager> pppm =
+    GetParticularProcessPriorityManager(static_cast<ContentParent*>(cp.get()));
+}
+
+void
+ProcessPriorityManagerImpl::ObserveContentParentDestroyed(nsISupports* aSubject)
+{
+  nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE_VOID(props);
+
+  uint64_t childID = CONTENT_PROCESS_ID_UNKNOWN;
+  props->GetPropertyAsUint64(NS_LITERAL_STRING("childID"), &childID);
+  NS_ENSURE_TRUE_VOID(childID != CONTENT_PROCESS_ID_UNKNOWN);
+
+  nsRefPtr<ParticularProcessPriorityManager> pppm;
+  mParticularManagers.Get(childID, &pppm);
+  MOZ_ASSERT(pppm);
+  if (pppm) {
+    pppm->ShutDown();
+  }
+
+  mParticularManagers.Remove(childID);
+}
+
+NS_IMPL_ISUPPORTS2(ParticularProcessPriorityManager,
+                   nsIObserver,
+                   nsITimerCallback);
+
+ParticularProcessPriorityManager::ParticularProcessPriorityManager(
+  ContentParent* aContentParent)
+  : mContentParent(aContentParent)
+  , mChildID(aContentParent->ChildID())
+  , mPriority(PROCESS_PRIORITY_UNKNOWN)
+  , mHoldsCPUWakeLock(false)
+  , mHoldsHighPriorityWakeLock(false)
+{
+  MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
+  LOGP("Creating ParticularProcessPriorityManager.");
+}
+
+void
+ParticularProcessPriorityManager::Init()
+{
   RegisterWakeLockObserver(this);
 
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (os) {
+    os->AddObserver(this, "audio-channel-process-changed", /* ownsWeak */ false);
+    os->AddObserver(this, "remote-browser-frame-shown", /* ownsWeak */ false);
+    os->AddObserver(this, "ipc:browser-destroyed", /* ownsWeak */ false);
+    os->AddObserver(this, "frameloader-visible-changed", /* ownsWeak */ false);
+  }
+
   // This process may already hold the CPU lock; for example, our parent may
   // have acquired it on our behalf.
   WakeLockInformation info1, info2;
   GetWakeLockInfo(NS_LITERAL_STRING("cpu"), &info1);
-  mHoldsCPUWakeLock = info1.lockingProcesses().Contains(GetContentChildID());
+  mHoldsCPUWakeLock = info1.lockingProcesses().Contains(ChildID());
 
   GetWakeLockInfo(NS_LITERAL_STRING("high-priority"), &info2);
-  mHoldsHighPriorityWakeLock = info2.lockingProcesses().Contains(GetContentChildID());
-
-  LOG("Done starting up.  mHoldsCPUWakeLock=%d, mHoldsHighPriorityWakeLock=%d",
-      mHoldsCPUWakeLock, mHoldsHighPriorityWakeLock);
+  mHoldsHighPriorityWakeLock = info2.lockingProcesses().Contains(ChildID());
+  LOGP("Done starting up.  mHoldsCPUWakeLock=%d, mHoldsHighPriorityWakeLock=%d",
+       mHoldsCPUWakeLock, mHoldsHighPriorityWakeLock);
 }
 
-NS_IMETHODIMP
-ProcessPriorityManager::Observe(
-  nsISupports* aSubject,
-  const char* aTopic,
-  const PRUnichar* aData)
+ParticularProcessPriorityManager::~ParticularProcessPriorityManager()
 {
-  if (!strcmp(aTopic, "tab-child-created")) {
-    mObservedTabChildCreated = true;
-    ResetPriority();
-  } else if (!strcmp(aTopic, "content-document-global-created")) {
-    OnContentDocumentGlobalCreated(aSubject);
-  } else if (!strcmp(aTopic, "inner-window-destroyed") ||
-             !strcmp(aTopic, "audio-channel-agent-changed")) {
-    ResetPriority();
-  } else if (!strcmp(aTopic, "process-priority:reset-now")) {
-    LOG("Got process-priority:reset-now notification.");
-    ResetPriorityNow();
-  } else {
-    MOZ_ASSERT(false);
-  }
-  return NS_OK;
+  LOGP("Destroying ParticularProcessPriorityManager.");
+  UnregisterWakeLockObserver(this);
 }
 
-void
-ProcessPriorityManager::Notify(const WakeLockInformation& aInfo)
+/* virtual */ void
+ParticularProcessPriorityManager::Notify(const WakeLockInformation& aInfo)
 {
   bool* dest = nullptr;
-  if (aInfo.topic() == NS_LITERAL_STRING("cpu")) {
+  if (aInfo.topic().EqualsLiteral("cpu")) {
     dest = &mHoldsCPUWakeLock;
-  } else if (aInfo.topic() == NS_LITERAL_STRING("high-priority")) {
+  } else if (aInfo.topic().EqualsLiteral("high-priority")) {
     dest = &mHoldsHighPriorityWakeLock;
   }
 
   if (dest) {
-    bool thisProcessLocks =
-      aInfo.lockingProcesses().Contains(GetContentChildID());
-
+    bool thisProcessLocks = aInfo.lockingProcesses().Contains(ChildID());
     if (thisProcessLocks != *dest) {
       *dest = thisProcessLocks;
-      LOG("Got wake lock changed event. "
-          "Now mHoldsCPUWakeLock=%d, mHoldsHighPriorityWakeLock=%d",
-          mHoldsCPUWakeLock, mHoldsHighPriorityWakeLock);
+      LOGP("Got wake lock changed event. "
+           "Now mHoldsCPUWakeLock=%d, mHoldsHighPriorityWakeLock=%d",
+           mHoldsCPUWakeLock, mHoldsHighPriorityWakeLock);
       ResetPriority();
     }
   }
 }
 
 NS_IMETHODIMP
-ProcessPriorityManager::HandleEvent(
-  nsIDOMEvent* aEvent)
+ParticularProcessPriorityManager::Observe(nsISupports* aSubject,
+                                          const char* aTopic,
+                                          const PRUnichar* aData)
 {
-  LOG("Got visibilitychange.");
-  ResetPriority();
+  if (!mContentParent) {
+    // We've been shut down.
+    return NS_OK;
+  }
+
+  nsDependentCString topic(aTopic);
+
+  if (topic.EqualsLiteral("audio-channel-process-changed")) {
+    OnAudioChannelProcessChanged(aSubject);
+  } else if (topic.EqualsLiteral("remote-browser-frame-shown")) {
+    OnRemoteBrowserFrameShown(aSubject);
+  } else if (topic.EqualsLiteral("ipc:browser-destroyed")) {
+    OnTabParentDestroyed(aSubject);
+  } else if (topic.EqualsLiteral("frameloader-visible-changed")) {
+    OnFrameloaderVisibleChanged(aSubject);
+  } else {
+    MOZ_ASSERT(false);
+  }
+
   return NS_OK;
 }
 
-void
-ProcessPriorityManager::OnContentDocumentGlobalCreated(
-  nsISupports* aOuterWindow)
+uint64_t
+ParticularProcessPriorityManager::ChildID() const
 {
-  LOG("DocumentGlobalCreated");
-  // Get the inner window (the topic of content-document-global-created is
-  // the /outer/ window!).
-  nsCOMPtr<nsPIDOMWindow> outerWindow = do_QueryInterface(aOuterWindow);
-  NS_ENSURE_TRUE_VOID(outerWindow);
-  nsCOMPtr<nsPIDOMWindow> innerWindow = outerWindow->GetCurrentInnerWindow();
-  NS_ENSURE_TRUE_VOID(innerWindow);
+  // We have to cache mContentParent->ChildID() instead of getting it from the
+  // ContentParent each time because after ShutDown() is called, mContentParent
+  // is null.  If we didn't cache ChildID(), then we wouldn't be able to run
+  // LOGP() after ShutDown().
+  return mChildID;
+}
 
-  // We're only interested in top-level windows.
-  nsCOMPtr<nsIDOMWindow> parentOuterWindow;
-  innerWindow->GetScriptableParent(getter_AddRefs(parentOuterWindow));
-  NS_ENSURE_TRUE_VOID(parentOuterWindow);
-  if (parentOuterWindow != outerWindow) {
-    return;
+int32_t
+ParticularProcessPriorityManager::Pid() const
+{
+  return mContentParent ? mContentParent->Pid() : -1;
+}
+
+const nsAutoCString&
+ParticularProcessPriorityManager::NameWithComma()
+{
+  mNameWithComma.Truncate();
+  if (!mContentParent) {
+    return mNameWithComma; // empty string
   }
 
-  nsCOMPtr<EventTarget> target = do_QueryInterface(innerWindow);
-  NS_ENSURE_TRUE_VOID(target);
-
-  nsWeakPtr weakWin = do_GetWeakReference(innerWindow);
-  NS_ENSURE_TRUE_VOID(weakWin);
-
-  if (mWindows.Contains(weakWin)) {
-    return;
+  nsAutoString name;
+  mContentParent->FriendlyName(name);
+  if (name.IsEmpty()) {
+    return mNameWithComma; // empty string
   }
 
-  target->AddSystemEventListener(NS_LITERAL_STRING("visibilitychange"),
-                                 this,
-                                 /* useCapture = */ false,
-                                 /* wantsUntrusted = */ false);
+  mNameWithComma = NS_ConvertUTF16toUTF8(name);
+  mNameWithComma.AppendLiteral(", ");
+  return mNameWithComma;
+}
 
-  mWindows.AppendElement(weakWin);
+void
+ParticularProcessPriorityManager::OnAudioChannelProcessChanged(nsISupports* aSubject)
+{
+  nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE_VOID(props);
+
+  uint64_t childID = CONTENT_PROCESS_ID_UNKNOWN;
+  props->GetPropertyAsUint64(NS_LITERAL_STRING("childID"), &childID);
+  if (childID == ChildID()) {
+    ResetPriority();
+  }
+}
+
+void
+ParticularProcessPriorityManager::OnRemoteBrowserFrameShown(nsISupports* aSubject)
+{
+  nsCOMPtr<nsIFrameLoader> fl = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE_VOID(fl);
+
+  nsCOMPtr<nsITabParent> tp;
+  fl->GetTabParent(getter_AddRefs(tp));
+  NS_ENSURE_TRUE_VOID(tp);
+
+  if (static_cast<TabParent*>(tp.get())->Manager() != mContentParent) {
+    return;
+  }
 
   ResetPriority();
 }
 
-bool
-ProcessPriorityManager::IsCriticalProcessWithWakeLock()
-{
-  if (!(mHoldsCPUWakeLock || mHoldsHighPriorityWakeLock)) {
-    return false;
-  }
-
-  ContentChild* contentChild = ContentChild::GetSingleton();
-  if (!contentChild) {
-    return false;
-  }
-
-  const InfallibleTArray<PBrowserChild*>& browsers =
-    contentChild->ManagedPBrowserChild();
-  for (uint32_t i = 0; i < browsers.Length(); i++) {
-    nsAutoString appType;
-    static_cast<TabChild*>(browsers[i])->GetAppType(appType);
-    if (appType.EqualsLiteral("critical")) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 void
-ProcessPriorityManager::ResetPriority()
+ParticularProcessPriorityManager::OnTabParentDestroyed(nsISupports* aSubject)
 {
-  if (!mObservedTabChildCreated) {
-    LOG("ResetPriority bailing because we haven't observed "
-        "a tab-child-created event.");
+  nsCOMPtr<nsITabParent> tp = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE_VOID(tp);
+
+  if (static_cast<TabParent*>(tp.get())->Manager() != mContentParent) {
     return;
   }
 
+  ResetPriority();
+}
+
+void
+ParticularProcessPriorityManager::OnFrameloaderVisibleChanged(nsISupports* aSubject)
+{
+  nsCOMPtr<nsIFrameLoader> fl = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE_VOID(fl);
+
+  nsCOMPtr<nsITabParent> tp;
+  fl->GetTabParent(getter_AddRefs(tp));
+  if (!tp) {
+    return;
+  }
+
+  if (static_cast<TabParent*>(tp.get())->Manager() != mContentParent) {
+    return;
+  }
+
+  // Most of the time when something changes in a process we call
+  // ResetPriority(), giving a grace period before downgrading its priority.
+  // But notice that here don't give a grace period: We call ResetPriorityNow()
+  // instead.
+  //
+  // We do this because we're reacting here to a setVisibility() call, which is
+  // an explicit signal from the process embedder that we should re-prioritize
+  // a process.  If we gave a grace period in response to setVisibility()
+  // calls, it would be impossible for the embedder to explicitly prioritize
+  // processes and prevent e.g. the case where we switch which process is in
+  // the foreground and, during the old fg processs's grace period, it OOMs the
+  // new fg process.
+
+  ResetPriorityNow();
+}
+
+void
+ParticularProcessPriorityManager::ResetPriority()
+{
   ProcessPriority processPriority = ComputePriority();
-  if (mProcessPriority == PROCESS_PRIORITY_UNKNOWN ||
-      mProcessPriority > processPriority) {
+  if (mPriority == PROCESS_PRIORITY_UNKNOWN ||
+      mPriority > processPriority) {
     ScheduleResetPriority("backgroundGracePeriodMS");
     return;
   }
@@ -412,247 +656,293 @@ ProcessPriorityManager::ResetPriority()
 }
 
 void
-ProcessPriorityManager::ResetPriorityNow()
+ParticularProcessPriorityManager::ResetPriorityNow()
 {
-  if (!mObservedTabChildCreated) {
-    LOG("ResetPriorityNow bailing because we haven't observed "
-        "a tab-child-created event.");
-    return;
-  }
-
   SetPriorityNow(ComputePriority());
 }
 
-bool
-ProcessPriorityManager::ComputeIsInForeground()
+void
+ParticularProcessPriorityManager::ScheduleResetPriority(const char* aTimeoutPref)
 {
-  // Critical processes holding the CPU/high-priority wake lock are always
-  // considered to be in the foreground.
-  if (IsCriticalProcessWithWakeLock()) {
-    return true;
+  if (mResetPriorityTimer) {
+    LOGP("ScheduleResetPriority bailing; the timer is already running.");
+    return;
   }
 
-  // We could try to be clever and keep a running count of the number of active
-  // docshells, instead of iterating over mWindows every time one window's
-  // visibility state changes.  But experience suggests that iterating over the
-  // windows is prone to fewer errors (and one mistake doesn't mess you up for
-  // the entire session).  Moreover, mWindows should be a very short list,
-  // since it contains only top-level content windows.
+  uint32_t timeout = Preferences::GetUint(
+    nsPrintfCString("dom.ipc.processPriorityManager.%s", aTimeoutPref).get());
+  LOGP("Scheduling reset timer to fire in %dms.", timeout);
+  mResetPriorityTimer = do_CreateInstance("@mozilla.org/timer;1");
+  mResetPriorityTimer->InitWithCallback(this, timeout, nsITimer::TYPE_ONE_SHOT);
+}
 
-  bool allHidden = true;
-  for (uint32_t i = 0; i < mWindows.Length(); i++) {
-    nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindows[i]);
-    if (!window) {
-      mWindows.RemoveElementAt(i);
-      i--;
-      continue;
+
+NS_IMETHODIMP
+ParticularProcessPriorityManager::Notify(nsITimer* aTimer)
+{
+  LOGP("Reset priority timer callback; about to ResetPriorityNow.");
+  ResetPriorityNow();
+  mResetPriorityTimer = nullptr;
+  return NS_OK;
+}
+
+bool
+ParticularProcessPriorityManager::HasAppType(const char* aAppType)
+{
+  const InfallibleTArray<PBrowserParent*>& browsers =
+    mContentParent->ManagedPBrowserParent();
+  for (uint32_t i = 0; i < browsers.Length(); i++) {
+    nsAutoString appType;
+    static_cast<TabParent*>(browsers[i])->GetAppType(appType);
+    if (appType.EqualsASCII(aAppType)) {
+      return true;
     }
-
-    nsCOMPtr<nsIDocShell> docshell = do_GetInterface(window);
-    if (!docshell) {
-      continue;
-    }
-
-    bool isActive = false;
-    docshell->GetIsActive(&isActive);
-
-
-#ifdef DEBUG
-    nsAutoCString spec;
-    nsCOMPtr<nsIURI> uri = window->GetDocumentURI();
-    if (uri) {
-      uri->GetSpec(spec);
-    }
-    LOG("Docshell at %s has visibility %d.", spec.get(), isActive);
-#endif
-
-    allHidden = allHidden && !isActive;
-
-    // We could break out early from this loop if
-    //   isActive && mProcessPriority == BACKGROUND,
-    // but then we might not clean up all the weak refs.
   }
 
-  return !allHidden;
+  return false;
 }
 
 ProcessPriority
-ProcessPriorityManager::ComputePriority()
+ParticularProcessPriorityManager::ComputePriority()
 {
-  if (ComputeIsInForeground()) {
-    if (IsCriticalProcessWithWakeLock()) {
-      return PROCESS_PRIORITY_FOREGROUND_HIGH;
+  if ((mHoldsCPUWakeLock || mHoldsHighPriorityWakeLock) &&
+      HasAppType("critical")) {
+    return PROCESS_PRIORITY_FOREGROUND_HIGH;
+  }
+
+  bool isVisible = false;
+  const InfallibleTArray<PBrowserParent*>& browsers =
+    mContentParent->ManagedPBrowserParent();
+  for (uint32_t i = 0; i < browsers.Length(); i++) {
+    if (static_cast<TabParent*>(browsers[i])->IsVisible()) {
+      isVisible = true;
+      break;
     }
+  }
+
+  if (isVisible) {
     return PROCESS_PRIORITY_FOREGROUND;
   }
 
   AudioChannelService* service = AudioChannelService::GetAudioChannelService();
-  if (service->ContentOrNormalChannelIsActive()) {
+  if (service->ProcessContentOrNormalChannelIsActive(ChildID())) {
     return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE;
   }
 
-  bool isHomescreen = false;
-
-  ContentChild* contentChild = ContentChild::GetSingleton();
-  if (contentChild) {
-    const InfallibleTArray<PBrowserChild*>& browsers =
-      contentChild->ManagedPBrowserChild();
-    for (uint32_t i = 0; i < browsers.Length(); i++) {
-      nsAutoString appType;
-      static_cast<TabChild*>(browsers[i])->GetAppType(appType);
-      if (appType.EqualsLiteral("homescreen")) {
-        isHomescreen = true;
-        break;
-      }
-    }
-  }
-
-  return isHomescreen ?
+  return HasAppType("homescreen") ?
          PROCESS_PRIORITY_BACKGROUND_HOMESCREEN :
          PROCESS_PRIORITY_BACKGROUND;
 }
 
 void
-ProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority)
+ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority)
 {
   if (aPriority == PROCESS_PRIORITY_UNKNOWN) {
     MOZ_ASSERT(false);
     return;
   }
 
-  if (mProcessPriority == aPriority) {
+  if (mPriority == aPriority) {
     return;
   }
 
-  LOG("Changing priority from %s to %s.",
-      ProcessPriorityToString(mProcessPriority),
-      ProcessPriorityToString(aPriority));
-  mProcessPriority = aPriority;
-  hal::SetProcessPriority(getpid(), mProcessPriority);
+  // If the prefs were disabled after this ParticularProcessPriorityManager was
+  // created, we can at least avoid any further calls to
+  // hal::SetProcessPriority.  Supporting dynamic enabling/disabling of the
+  // ProcessPriorityManager is mostly for testing.
+  if (!ProcessPriorityManagerImpl::PrefsEnabled()) {
+    return;
+  }
+
+  LOGP("Changing priority from %s to %s.",
+       ProcessPriorityToString(mPriority),
+       ProcessPriorityToString(aPriority));
+  mPriority = aPriority;
+  hal::SetProcessPriority(Pid(), mPriority);
+
+  unused << mContentParent->SendNotifyProcessPriorityChanged(mPriority);
 
   if (aPriority >= PROCESS_PRIORITY_FOREGROUND) {
-    // Cancel the memory minimization procedure we might have started.
-    nsCOMPtr<nsICancelableRunnable> runnable =
-      do_QueryReferent(mMemoryMinimizerRunnable);
-    if (runnable) {
-      runnable->Cancel();
-    }
+    unused << mContentParent->SendCancelMinimizeMemoryUsage();
   } else {
-    // We're in the background; dump as much memory as we can.
-    nsCOMPtr<nsIMemoryReporterManager> mgr =
-      do_GetService("@mozilla.org/memory-reporter-manager;1");
-    if (mgr) {
-      nsCOMPtr<nsICancelableRunnable> runnable =
-        do_QueryReferent(mMemoryMinimizerRunnable);
-
-      // Cancel the previous task if it's still pending
-      if (runnable) {
-        runnable->Cancel();
-      }
-
-      mgr->MinimizeMemoryUsage(/* callback = */ nullptr,
-                               getter_AddRefs(runnable));
-      mMemoryMinimizerRunnable = do_GetWeakReference(runnable);
-    }
+    unused << mContentParent->SendMinimizeMemoryUsage();
   }
+
+  FireTestOnlyObserverNotification("process-priority-set",
+                                   ProcessPriorityToString(mPriority));
 }
 
 void
-ProcessPriorityManager::ScheduleResetPriority(const char* aTimeoutPref)
+ParticularProcessPriorityManager::ShutDown()
 {
-  if (mResetPriorityTimer) {
-    LOG("ScheduleResetPriority bailing; the timer is already running.");
-    return;
-  }
+  MOZ_ASSERT(mContentParent);
 
-  uint32_t timeout = Preferences::GetUint(
-    nsPrintfCString("dom.ipc.processPriorityManager.%s", aTimeoutPref).get());
-  LOG("Scheduling reset timer to fire in %dms.", timeout);
-  mResetPriorityTimer = do_CreateInstance("@mozilla.org/timer;1");
-  mResetPriorityTimer->InitWithCallback(this, timeout, nsITimer::TYPE_ONE_SHOT);
-}
-
-NS_IMETHODIMP
-ProcessPriorityManager::Notify(nsITimer* aTimer)
-{
-  LOG("Reset priority timer callback; about to ResetPriorityNow.");
-  ResetPriorityNow();
-  mResetPriorityTimer = nullptr;
-  return NS_OK;
-}
-
-void
-ProcessPriorityManager::TemporarilyLockProcessPriority()
-{
-  LOG("TemporarilyLockProcessPriority");
-
-  // Each call to TemporarilyLockProcessPriority gives us an additional
-  // temporaryPriorityMS at our current priority (unless we receive a
-  // process-priority:reset-now notification).  So cancel our timer if it's
-  // running (which is due to a previous call to either
-  // TemporarilyLockProcessPriority() or ResetPriority()).
   if (mResetPriorityTimer) {
     mResetPriorityTimer->Cancel();
     mResetPriorityTimer = nullptr;
   }
-  ScheduleResetPriority("temporaryPriorityLockMS");
+
+  mContentParent = nullptr;
+}
+
+void
+ProcessPriorityManagerImpl::FireTestOnlyObserverNotification(
+  const char* aTopic,
+  const nsACString& aData /* = EmptyCString() */)
+{
+  if (!Preferences::GetBool("dom.ipc.processPriorityManager.testMode")) {
+    return;
+  }
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  NS_ENSURE_TRUE_VOID(os);
+
+  nsPrintfCString topic("process-priority-manager:TEST-ONLY:%s", aTopic);
+
+  LOG("Notifying observer %s, data %s",
+      topic.get(), PromiseFlatCString(aData).get());
+  os->NotifyObservers(nullptr, topic.get(), NS_ConvertUTF8toUTF16(aData).get());
+}
+
+void
+ParticularProcessPriorityManager::FireTestOnlyObserverNotification(
+  const char* aTopic,
+  const char* aData /* = nullptr */ )
+{
+  if (!Preferences::GetBool("dom.ipc.processPriorityManager.testMode")) {
+    return;
+  }
+
+  nsAutoCString data;
+  if (aData) {
+    data.AppendASCII(aData);
+  }
+
+  FireTestOnlyObserverNotification(aTopic, data);
+}
+
+void
+ParticularProcessPriorityManager::FireTestOnlyObserverNotification(
+  const char* aTopic,
+  const nsACString& aData /* = EmptyCString() */)
+{
+  if (!Preferences::GetBool("dom.ipc.processPriorityManager.testMode")) {
+    return;
+  }
+
+  nsAutoCString data(nsPrintfCString("%lld", ChildID()));
+  if (!aData.IsEmpty()) {
+    data.AppendLiteral(":");
+    data.Append(aData);
+  }
+
+  // ProcessPriorityManagerImpl::GetSingleton() is guaranteed not to return
+  // null, since ProcessPriorityManagerImpl is the only class which creates
+  // ParticularProcessPriorityManagers.
+
+  ProcessPriorityManagerImpl::GetSingleton()->
+    FireTestOnlyObserverNotification(aTopic, data);
+}
+
+StaticRefPtr<ProcessPriorityManagerChild>
+ProcessPriorityManagerChild::sSingleton;
+
+/* static */ void
+ProcessPriorityManagerChild::StaticInit()
+{
+  if (!sSingleton) {
+    sSingleton = new ProcessPriorityManagerChild();
+    ClearOnShutdown(&sSingleton);
+  }
+}
+
+/* static */ ProcessPriorityManagerChild*
+ProcessPriorityManagerChild::Singleton()
+{
+  StaticInit();
+  return sSingleton;
+}
+
+NS_IMPL_ISUPPORTS1(ProcessPriorityManagerChild,
+                   nsIObserver)
+
+ProcessPriorityManagerChild::ProcessPriorityManagerChild()
+{
+  if (XRE_GetProcessType() == GeckoProcessType_Default) {
+    mCachedPriority = PROCESS_PRIORITY_MASTER;
+  } else {
+    mCachedPriority = PROCESS_PRIORITY_UNKNOWN;
+  }
+}
+
+void
+ProcessPriorityManagerChild::Init()
+{
+  // The process priority should only be changed in child processes; don't even
+  // bother listening for changes if we're in the main process.
+  if (XRE_GetProcessType() != GeckoProcessType_Default) {
+    nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+    NS_ENSURE_TRUE_VOID(os);
+    os->AddObserver(this, "ipc:process-priority-changed", /* weak = */ false);
+  }
+}
+
+NS_IMETHODIMP
+ProcessPriorityManagerChild::Observe(
+  nsISupports* aSubject,
+  const char* aTopic,
+  const PRUnichar* aData)
+{
+  MOZ_ASSERT(!strcmp(aTopic, "ipc:process-priority-changed"));
+
+  nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE(props, NS_OK);
+
+  int32_t priority = static_cast<int32_t>(PROCESS_PRIORITY_UNKNOWN);
+  props->GetPropertyAsInt32(NS_LITERAL_STRING("priority"), &priority);
+  NS_ENSURE_TRUE(ProcessPriority(priority) != PROCESS_PRIORITY_UNKNOWN, NS_OK);
+
+  mCachedPriority = static_cast<ProcessPriority>(priority);
+
+  return NS_OK;
+}
+
+bool
+ProcessPriorityManagerChild::CurrentProcessIsForeground()
+{
+  return mCachedPriority == PROCESS_PRIORITY_UNKNOWN ||
+         mCachedPriority >= PROCESS_PRIORITY_FOREGROUND;
 }
 
 } // anonymous namespace
 
-void
-InitProcessPriorityManager()
+namespace mozilla {
+
+/* static */ void
+ProcessPriorityManager::Init()
 {
-  if (sInitialized) {
-    return;
-  }
-
-  // If IPC tabs aren't enabled at startup, don't bother with any of this.
-  if (!Preferences::GetBool("dom.ipc.processPriorityManager.enabled") ||
-      Preferences::GetBool("dom.ipc.tabs.disabled")) {
-    LOG("InitProcessPriorityManager bailing due to prefs.");
-    return;
-  }
-
-  sInitialized = true;
-
-  // If we're the master process, mark ourselves as such and don't create a
-  // ProcessPriorityManager (we never want to mark the master process as
-  // backgrounded).
-  if (XRE_GetProcessType() == GeckoProcessType_Default) {
-    LOG("This is the master process.");
-    hal::SetProcessPriority(getpid(), PROCESS_PRIORITY_MASTER);
-    return;
-  }
-
-  sManager = new ProcessPriorityManager();
-  sManager->Init();
-  ClearOnShutdown(&sManager);
+  ProcessPriorityManagerImpl::StaticInit();
+  ProcessPriorityManagerChild::StaticInit();
 }
 
-bool
-CurrentProcessIsForeground()
+/* static */ void
+ProcessPriorityManager::SetProcessPriority(ContentParent* aContentParent,
+                                           ProcessPriority aPriority)
 {
-  // The process priority manager is the only thing which changes our priority,
-  // so if the manager does not exist, then we must be in the foreground.
-  if (!sManager) {
-    return true;
-  }
+  MOZ_ASSERT(aContentParent);
 
-  return sManager->GetPriority() >= PROCESS_PRIORITY_FOREGROUND;
-}
-
-void
-TemporarilyLockProcessPriority()
-{
-  if (sManager) {
-    sManager->TemporarilyLockProcessPriority();
-  } else {
-    LOG("TemporarilyLockProcessPriority called before "
-        "InitProcessPriorityManager.  Bailing.");
+  ProcessPriorityManagerImpl* singleton =
+    ProcessPriorityManagerImpl::GetSingleton();
+  if (singleton) {
+    singleton->SetProcessPriority(aContentParent, aPriority);
   }
 }
 
-} // namespace ipc
-} // namespace dom
+/* static */ bool
+ProcessPriorityManager::CurrentProcessIsForeground()
+{
+  return ProcessPriorityManagerChild::Singleton()->
+    CurrentProcessIsForeground();
+}
+
 } // namespace mozilla
diff --git a/dom/ipc/ProcessPriorityManager.h b/dom/ipc/ProcessPriorityManager.h
index fec113f8fb7..34806d33efd 100644
--- a/dom/ipc/ProcessPriorityManager.h
+++ b/dom/ipc/ProcessPriorityManager.h
@@ -7,46 +7,75 @@
 #ifndef mozilla_ProcessPriorityManager_h_
 #define mozilla_ProcessPriorityManager_h_
 
+#include "mozilla/HalTypes.h"
+#include "mozilla/StaticPtr.h"
+#include "nsIObserver.h"
+#include "nsDataHashtable.h"
+
 namespace mozilla {
 namespace dom {
-namespace ipc {
+class ContentParent;
+}
 
 /**
- * Initialize the ProcessPriorityManager.
+ * This class sets the priority of subprocesses in response to explicit
+ * requests and events in the system.
  *
- * The ProcessPriorityManager informs the hal back-end whether this is the root
- * Gecko process, and, if we're not the root, informs hal when this process
- * transitions between having no visible top-level windows, and having at least
- * one visible top-level window.
+ * A process's priority changes e.g. when it goes into the background via
+ * mozbrowser's setVisible(false).  Process priority affects CPU scheduling and
+ * also which processes get killed when we run out of memory.
  *
- * Hal may adjust this process's operating system priority (e.g. niceness, on
- * *nix) according to these notificaitons.
- *
- * This function call does nothing if the pref for OOP tabs is not set.
+ * After you call Initialize(), the only thing you probably have to do is call
+ * SetProcessPriority on processes immediately after creating them in order to
+ * set their initial priority.  The ProcessPriorityManager takes care of the
+ * rest.
  */
-void InitProcessPriorityManager();
+class ProcessPriorityManager MOZ_FINAL
+{
+public:
+  /**
+   * Initialize the ProcessPriorityManager machinery, causing the
+   * ProcessPriorityManager to actively manage the priorities of all
+   * subprocesses.  You should call this before creating any subprocesses.
+   *
+   * You should also call this function even if you're in a child process,
+   * since it will initialize ProcessPriorityManagerChild.
+   */
+  static void Init();
 
-/**
- * True iff the current process has foreground or higher priority as
- * computed by DOM visibility.  The returned answer may not match the
- * actual OS process priority, for short intervals.
- */
-bool CurrentProcessIsForeground();
+  /**
+   * Set the process priority of a given ContentParent's process.
+   *
+   * Note that because this method takes a ContentParent*, you can only set the
+   * priority of your subprocesses.  In fact, because we don't support nested
+   * content processes (bug 761935), you can only call this method from the
+   * main process.
+   *
+   * It probably only makes sense to call this function immediately after a
+   * process is created.  At this point, the process priority manager doesn't
+   * have enough context about the processs to know what its priority should
+   * be.
+   *
+   * Eventually whatever priority you set here can and probably will be
+   * overwritten by the process priority manager.
+   */
+  static void SetProcessPriority(dom::ContentParent* aContentParent,
+                                 hal::ProcessPriority aPriority);
 
-/**
- * Calling this function prevents us from changing this process's priority
- * for a few seconds, if that change in priority would not have taken effect
- * immediately to begin with.
- *
- * In practice, this prevents foreground --> background transitions, but not
- * background --> foreground transitions.  It also does not prevent
- * transitions from an unknown priority (as happens immediately after we're
- * constructed) to a foreground priority.
- */
-void TemporarilyLockProcessPriority();
+  /**
+   * Returns true iff this process's priority is FOREGROUND*.
+   *
+   * Note that because process priorities are set in the main process, it's
+   * possible for this method to return a stale value.  So be careful about
+   * what you use this for.
+   */
+  static bool CurrentProcessIsForeground();
+
+private:
+  ProcessPriorityManager();
+  DISALLOW_EVIL_CONSTRUCTORS(ProcessPriorityManager);
+};
 
-} // namespace ipc
-} // namespace dom
 } // namespace mozilla
 
 #endif
diff --git a/dom/ipc/TabChild.cpp b/dom/ipc/TabChild.cpp
index 99710da71e1..871fcff6d79 100644
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -2018,14 +2018,6 @@ TabChild::RecvDestroy()
   return Send__delete__(this);
 }
 
-/* virtual */ bool
-TabChild::RecvSetAppType(const nsString& aAppType)
-{
-  MOZ_ASSERT_IF(!aAppType.IsEmpty(), HasOwnApp());
-  mAppType = aAppType;
-  return true;
-}
-
 PRenderFrameChild*
 TabChild::AllocPRenderFrame(ScrollingBehavior* aScrolling,
                             TextureFactoryIdentifier* aTextureFactoryIdentifier,
diff --git a/dom/ipc/TabChild.h b/dom/ipc/TabChild.h
index 161f27b148a..1af1600c535 100644
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -315,16 +315,6 @@ public:
     void MakeVisible();
     void MakeHidden();
 
-    virtual bool RecvSetAppType(const nsString& aAppType);
-
-    /**
-     * Get this object's app type.
-     *
-     * A TabChild's app type corresponds to the value of its frame element's
-     * "mozapptype" attribute.
-     */
-    void GetAppType(nsAString& aAppType) const { aAppType = mAppType; }
-
     // Returns true if the file descriptor was found in the cache, false
     // otherwise.
     bool GetCachedFileDescriptor(const nsAString& aPath,
@@ -459,7 +449,6 @@ private:
     bool mNotified;
     bool mContentDocumentIsDisplayed;
     bool mTriedBrowserInit;
-    nsString mAppType;
     ScreenOrientation mOrientation;
 
     DISALLOW_EVIL_CONSTRUCTORS(TabChild);
diff --git a/dom/ipc/TabParent.cpp b/dom/ipc/TabParent.cpp
index 3257f1905f5..5d27dfcd470 100644
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -219,6 +219,31 @@ TabParent::SetOwnerElement(nsIDOMElement* aElement)
   TryCacheDPI();
 }
 
+void
+TabParent::GetAppType(nsAString& aOut)
+{
+  aOut.Truncate();
+  nsCOMPtr<Element> elem = do_QueryInterface(mFrameElement);
+  if (!elem) {
+    return;
+  }
+
+  elem->GetAttr(kNameSpaceID_None, nsGkAtoms::mozapptype, aOut);
+}
+
+bool
+TabParent::IsVisible()
+{
+  nsRefPtr<nsFrameLoader> frameLoader = GetFrameLoader();
+  if (!frameLoader) {
+    return false;
+  }
+
+  bool visible = false;
+  frameLoader->GetVisible(&visible);
+  return visible;
+}
+
 void
 TabParent::Destroy()
 {
@@ -265,18 +290,20 @@ TabParent::ActorDestroy(ActorDestroyReason why)
     mIMETabParent = nullptr;
   }
   nsRefPtr<nsFrameLoader> frameLoader = GetFrameLoader();
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
   if (frameLoader) {
     ReceiveMessage(CHILD_PROCESS_SHUTDOWN_MESSAGE, false, nullptr, nullptr);
     frameLoader->DestroyChild();
 
-    if (why == AbnormalShutdown) {
-      nsCOMPtr<nsIObserverService> os = services::GetObserverService();
-      if (os) {
-        os->NotifyObservers(NS_ISUPPORTS_CAST(nsIFrameLoader*, frameLoader),
-                            "oop-frameloader-crashed", nullptr);
-      }
+    if (why == AbnormalShutdown && os) {
+      os->NotifyObservers(NS_ISUPPORTS_CAST(nsIFrameLoader*, frameLoader),
+                          "oop-frameloader-crashed", nullptr);
     }
   }
+
+  if (os) {
+    os->NotifyObservers(NS_ISUPPORTS_CAST(nsITabParent*, this), "ipc:browser-destroyed", nullptr);
+  }
 }
 
 bool
diff --git a/dom/ipc/TabParent.h b/dom/ipc/TabParent.h
index 15d107b5296..cf18f87eb4d 100644
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -62,6 +62,20 @@ public:
     virtual ~TabParent();
     nsIDOMElement* GetOwnerElement() { return mFrameElement; }
     void SetOwnerElement(nsIDOMElement* aElement);
+
+    /**
+     * Get the mozapptype attribute from this TabParent's owner DOM element.
+     */
+    void GetAppType(nsAString& aOut);
+
+    /**
+     * Returns true iff this TabParent's nsIFrameLoader is visible.
+     *
+     * The frameloader's visibility can be independent of e.g. its docshell's
+     * visibility.
+     */
+    bool IsVisible();
+
     nsIBrowserDOMWindow *GetBrowserDOMWindow() { return mBrowserDOMWindow; }
     void SetBrowserDOMWindow(nsIBrowserDOMWindow* aBrowserDOMWindow) {
         mBrowserDOMWindow = aBrowserDOMWindow;
diff --git a/layout/build/nsLayoutStatics.cpp b/layout/build/nsLayoutStatics.cpp
index 130e83dd2df..4043b18df82 100644
--- a/layout/build/nsLayoutStatics.cpp
+++ b/layout/build/nsLayoutStatics.cpp
@@ -265,7 +265,7 @@ nsLayoutStatics::Initialize()
   SVGElementFactory::Init();
   nsSVGUtils::Init();
 
-  InitProcessPriorityManager();
+  ProcessPriorityManager::Init();
 
   nsPermissionManager::AppClearDataObserverInit();
   nsCookieService::AppClearDataObserverInit();

From 9a39e4d0c4d3bbca50d6c13544279bada182ee26 Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:26 -0400
Subject: [PATCH 10/13] Bug 844323 - Part 3: ProcessPriorityManager tests.
 r=nsm,khuey

---
 .../mochitest/browserElementTestHelpers.js    | 399 +++++++++++++++++-
 dom/browser-element/mochitest/moz.build       |   1 +
 .../mochitest/priority/Makefile.in            |  45 ++
 .../mochitest/priority/file_Audio.html        |  19 +
 .../mochitest/priority/file_HighPriority.html |  20 +
 .../priority/file_MultipleFrames.html         |  14 +
 .../priority/file_NestedFramesOuter.html      |  20 +
 .../priority/file_WebGLContextLost.html       |  22 +
 .../mochitest/priority/moz.build              |   0
 .../mochitest/priority/silence.ogg            | Bin 0 -> 5940 bytes
 .../mochitest/priority/test_Audio.html        |  60 +++
 .../mochitest/priority/test_Background.html   |  55 +++
 .../priority/test_ExpectingSystemMessage.html |  55 +++
 .../mochitest/priority/test_HighPriority.html | 121 ++++++
 .../priority/test_MultipleFrames.html         |  56 +++
 .../mochitest/priority/test_NestedFrames.html |  73 ++++
 .../mochitest/priority/test_Preallocated.html |  77 ++++
 .../mochitest/priority/test_Simple.html       |  50 +++
 .../mochitest/priority/test_Visibility.html   |  52 +++
 .../priority/test_WebGLContextLost.html       | 100 +++++
 20 files changed, 1231 insertions(+), 8 deletions(-)
 create mode 100644 dom/browser-element/mochitest/priority/Makefile.in
 create mode 100644 dom/browser-element/mochitest/priority/file_Audio.html
 create mode 100644 dom/browser-element/mochitest/priority/file_HighPriority.html
 create mode 100644 dom/browser-element/mochitest/priority/file_MultipleFrames.html
 create mode 100644 dom/browser-element/mochitest/priority/file_NestedFramesOuter.html
 create mode 100644 dom/browser-element/mochitest/priority/file_WebGLContextLost.html
 create mode 100644 dom/browser-element/mochitest/priority/moz.build
 create mode 100644 dom/browser-element/mochitest/priority/silence.ogg
 create mode 100644 dom/browser-element/mochitest/priority/test_Audio.html
 create mode 100644 dom/browser-element/mochitest/priority/test_Background.html
 create mode 100644 dom/browser-element/mochitest/priority/test_ExpectingSystemMessage.html
 create mode 100644 dom/browser-element/mochitest/priority/test_HighPriority.html
 create mode 100644 dom/browser-element/mochitest/priority/test_MultipleFrames.html
 create mode 100644 dom/browser-element/mochitest/priority/test_NestedFrames.html
 create mode 100644 dom/browser-element/mochitest/priority/test_Preallocated.html
 create mode 100644 dom/browser-element/mochitest/priority/test_Simple.html
 create mode 100644 dom/browser-element/mochitest/priority/test_Visibility.html
 create mode 100644 dom/browser-element/mochitest/priority/test_WebGLContextLost.html

diff --git a/dom/browser-element/mochitest/browserElementTestHelpers.js b/dom/browser-element/mochitest/browserElementTestHelpers.js
index a1568b6dd39..1245fc2de03 100644
--- a/dom/browser-element/mochitest/browserElementTestHelpers.js
+++ b/dom/browser-element/mochitest/browserElementTestHelpers.js
@@ -61,18 +61,42 @@ const browserElementTestHelpers = {
     this.tempPermissions.push(location.href)
   },
 
-  removeAllTempPermissions: function() {
-    for(var i = 0; i < this.tempPermissions.length; i++) {
-      SpecialPowers.removePermission("browser", this.tempPermissions[i]);
-    }
-  },
-
+  'tempPermissions': [],
   addPermissionForUrl: function(url) {
     SpecialPowers.addPermission("browser", true, url);
     this.tempPermissions.push(url);
   },
 
-  'tempPermissions': [],
+  _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.tempPermissions.length; i++) {
+      SpecialPowers.removePermission("browser", this.tempPermissions[i]);
+    }
+
+    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',
@@ -81,6 +105,92 @@ const browserElementTestHelpers = {
   '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() {
+  var deferred = Promise.defer();
+
+  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);
+      deferred.resolve(childID);
+    }
+  );
+
+  return deferred.promise;
+}
+
+// Just like expectProcessCreated(), except we'll call ok(false) if a second
+// process is created.
+function expectOnlyOneProcessCreated() {
+  var p = expectProcessCreated();
+  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) {
+  var deferred = Promise.defer();
+
+  var observed = false;
+  browserElementTestHelpers.addProcessPriorityObserver(
+    'process-priority-set',
+    function(subject, topic, data) {
+      if (observed) {
+        return;
+      }
+
+      [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) {
+        deferred.resolve(priority);
+      } else {
+        deferred.reject(priority);
+      }
+    }
+  );
+
+  return deferred.promise;
+}
+
+// Returns a promise which is resolved the first time the given iframe fires
+// the mozbrowser##eventName event.
+function expectMozbrowserEvent(iframe, eventName) {
+  var deferred = Promise.defer();
+  iframe.addEventListener('mozbrowser' + eventName, function handler(e) {
+    iframe.removeEventListener('mozbrowser' + eventName, handler);
+    deferred.resolve(e);
+  });
+  return deferred.promise;
+}
+
 // Set some prefs:
 //
 //  * browser.pageThumbs.enabled: false
@@ -129,7 +239,7 @@ const browserElementTestHelpers = {
 })();
 
 addEventListener('unload', function() {
-  browserElementTestHelpers.removeAllTempPermissions();
+  browserElementTestHelpers.cleanUp();
 });
 
 // Wait for the load event before unlocking the test-ready event.
@@ -137,3 +247,276 @@ browserElementTestHelpers.lockTestReady();
 addEventListener('load', function() {
   SimpleTest.executeSoon(browserElementTestHelpers.unlockTestReady.bind(browserElementTestHelpers));
 });
+
+//////////////////////////////////
+// promise.js from the addon SDK with some modifications to the module
+// boilerplate.
+//////////////////////////////////
+
+;(function(id, factory) { // Module boilerplate :(
+    var globals = this;
+    factory(function require(id) {
+      return globals[id];
+    }, (globals[id] = {}), { uri: document.location.href + '#' + id, id: id });
+}).call(this, 'Promise', function Promise(require, exports, module) {
+
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+/**
+ * Internal utility: Wraps given `value` into simplified promise, successfully
+ * fulfilled to a given `value`. Note the result is not a complete promise
+ * implementation, as its method `then` does not returns anything.
+ */
+function fulfilled(value) {
+  return { then: function then(fulfill) { fulfill(value); } };
+}
+
+/**
+ * Internal utility: Wraps given input into simplified promise, pre-rejected
+ * with a given `reason`. Note the result is not a complete promise
+ * implementation, as its method `then` does not returns anything.
+ */
+function rejected(reason) {
+  return { then: function then(fulfill, reject) { reject(reason); } };
+}
+
+/**
+ * Internal utility: Returns `true` if given `value` is a promise. Value is
+ * assumed to be a promise if it implements method `then`.
+ */
+function isPromise(value) {
+  return value && typeof(value.then) === 'function';
+}
+
+/**
+ * Creates deferred object containing fresh promise & methods to either resolve
+ * or reject it. The result is an object with the following properties:
+ * - `promise` Eventual value representation implementing CommonJS [Promises/A]
+ *   (http://wiki.commonjs.org/wiki/Promises/A) API.
+ * - `resolve` Single shot function that resolves enclosed `promise` with a
+ *   given `value`.
+ * - `reject` Single shot function that rejects enclosed `promise` with a given
+ *   `reason`.
+ *
+ * An optional `prototype` argument is used as a prototype of the returned
+ * `promise` allowing one to implement additional API. If prototype is not
+ * passed then it falls back to `Object.prototype`.
+ *
+ *  ## Example
+ *
+ *  function fetchURI(uri, type) {
+ *    var deferred = defer();
+ *    var request = new XMLHttpRequest();
+ *    request.open("GET", uri, true);
+ *    request.responseType = type;
+ *    request.onload = function onload() {
+ *      deferred.resolve(request.response);
+ *    }
+ *    request.onerror = function(event) {
+ *     deferred.reject(event);
+ *    }
+ *    request.send();
+ *
+ *    return deferred.promise;
+ *  }
+ */
+function defer(prototype) {
+  // Define FIFO queue of observer pairs. Once promise is resolved & all queued
+  // observers are forwarded to `result` and variable is set to `null`.
+  var observers = [];
+
+  // Promise `result`, which will be assigned a resolution value once promise
+  // is resolved. Note that result will always be assigned promise (or alike)
+  // object to take care of propagation through promise chains. If result is
+  // `null` promise is not resolved yet.
+  var result = null;
+
+  prototype = (prototype || prototype === null) ? prototype : Object.prototype;
+
+  // Create an object implementing promise API.
+  var promise = Object.create(prototype, {
+    then: { value: function then(onFulfill, onError) {
+      var deferred = defer(prototype);
+
+      function resolve(value) {
+        // If `onFulfill` handler is provided resolve `deferred.promise` with
+        // result of invoking it with a resolution value. If handler is not
+        // provided propagate value through.
+        try {
+          deferred.resolve(onFulfill ? onFulfill(value) : value);
+        }
+        // `onFulfill` may throw exception in which case resulting promise
+        // is rejected with thrown exception.
+        catch(error) {
+          if (exports._reportErrors && typeof(console) === 'object')
+            console.error(error);
+          // Note: Following is equivalent of `deferred.reject(error)`,
+          // we use this shortcut to reduce a stack.
+          deferred.resolve(rejected(error));
+        }
+      }
+
+      function reject(reason) {
+        try {
+          if (onError) deferred.resolve(onError(reason));
+          else deferred.resolve(rejected(reason));
+        }
+        catch(error) {
+          if (exports._reportErrors && typeof(console) === 'object')
+            console.error(error)
+          deferred.resolve(rejected(error));
+        }
+      }
+
+      // If enclosed promise (`this.promise`) observers queue is still alive
+      // enqueue a new observer pair into it. Note that this does not
+      // necessary means that promise is pending, it may already be resolved,
+      // but we still have to queue observers to guarantee an order of
+      // propagation.
+      if (observers) {
+        observers.push({ resolve: resolve, reject: reject });
+      }
+      // Otherwise just forward observer pair right to a `result` promise.
+      else {
+        result.then(resolve, reject);
+      }
+
+      return deferred.promise;
+    }}
+  })
+
+  var deferred = {
+    promise: promise,
+    /**
+     * Resolves associated `promise` to a given `value`, unless it's already
+     * resolved or rejected. Note that resolved promise is not necessary a
+     * successfully fulfilled. Promise may be resolved with a promise `value`
+     * in which case `value` promise's fulfillment / rejection will propagate
+     * up to a promise resolved with `value`.
+     */
+    resolve: function resolve(value) {
+      if (!result) {
+        // Store resolution `value` in a `result` as a promise, so that all
+        // the subsequent handlers can be simply forwarded to it. Since
+        // `result` will be a promise all the value / error propagation will
+        // be uniformly taken care of.
+        result = isPromise(value) ? value : fulfilled(value);
+
+        // Forward already registered observers to a `result` promise in the
+        // order they were registered. Note that we intentionally dequeue
+        // observer at a time until queue is exhausted. This makes sure that
+        // handlers registered as side effect of observer forwarding are
+        // queued instead of being invoked immediately, guaranteeing FIFO
+        // order.
+        while (observers.length) {
+          var observer = observers.shift();
+          result.then(observer.resolve, observer.reject);
+        }
+
+        // Once `observers` queue is exhausted we `null`-ify it, so that
+        // new handlers are forwarded straight to the `result`.
+        observers = null;
+      }
+    },
+    /**
+     * Rejects associated `promise` with a given `reason`, unless it's already
+     * resolved / rejected. This is just a (better performing) convenience
+     * shortcut for `deferred.resolve(reject(reason))`.
+     */
+    reject: function reject(reason) {
+      // Note that if promise is resolved that does not necessary means that it
+      // is successfully fulfilled. Resolution value may be a promise in which
+      // case its result propagates. In other words if promise `a` is resolved
+      // with promise `b`, `a` is either fulfilled or rejected depending
+      // on weather `b` is fulfilled or rejected. Here `deferred.promise` is
+      // resolved with a promise pre-rejected with a given `reason`, there for
+      // `deferred.promise` is rejected with a given `reason`. This may feel
+      // little awkward first, but doing it this way greatly simplifies
+      // propagation through promise chains.
+      deferred.resolve(rejected(reason));
+    }
+  };
+
+  return deferred;
+}
+exports.defer = defer;
+
+/**
+ * Returns a promise resolved to a given `value`. Optionally a second
+ * `prototype` argument may be provided to be used as a prototype for the
+ * returned promise.
+ */
+function resolve(value, prototype) {
+  var deferred = defer(prototype);
+  deferred.resolve(value);
+  return deferred.promise;
+}
+exports.resolve = resolve;
+
+/**
+ * Returns a promise rejected with a given `reason`. Optionally a second
+ * `prototype` argument may be provided to be used as a prototype for the
+ * returned promise.
+ */
+function reject(reason, prototype) {
+  var deferred = defer(prototype);
+  deferred.reject(reason);
+  return deferred.promise;
+}
+exports.reject = reject;
+
+var promised = (function() {
+  // Note: Define shortcuts and utility functions here in order to avoid
+  // slower property accesses and unnecessary closure creations on each
+  // call of this popular function.
+
+  var call = Function.call;
+  var concat = Array.prototype.concat;
+
+  // Utility function that does following:
+  // execute([ f, self, args...]) => f.apply(self, args)
+  function execute(args) { return call.apply(call, args) }
+
+  // Utility function that takes promise of `a` array and maybe promise `b`
+  // as arguments and returns promise for `a.concat(b)`.
+  function promisedConcat(promises, unknown) {
+    return promises.then(function(values) {
+      return resolve(unknown).then(function(value) {
+        return values.concat([ value ])
+      });
+    });
+  }
+
+  return function promised(f, prototype) {
+    /**
+    Returns a wrapped `f`, which when called returns a promise that resolves to
+    `f(...)` passing all the given arguments to it, which by the way may be
+    promises. Optionally second `prototype` argument may be provided to be used
+    a prototype for a returned promise.
+
+    ## Example
+
+    var promise = promised(Array)(1, promise(2), promise(3))
+    promise.then(console.log) // => [ 1, 2, 3 ]
+    **/
+
+    return function promised() {
+      // create array of [ f, this, args... ]
+      return concat.apply([ f, this ], arguments).
+        // reduce it via `promisedConcat` to get promised array of fulfillments
+        reduce(promisedConcat, resolve([], prototype)).
+        // finally map that to promise of `f.apply(this, args...)`
+        then(execute);
+    }
+  }
+})();
+exports.promised = promised;
+
+var all = promised(Array);
+exports.all = all;
+
+});
diff --git a/dom/browser-element/mochitest/moz.build b/dom/browser-element/mochitest/moz.build
index 895d11993cf..5391ef08970 100644
--- a/dom/browser-element/mochitest/moz.build
+++ b/dom/browser-element/mochitest/moz.build
@@ -4,3 +4,4 @@
 # 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/.
 
+DIRS = ['priority']
diff --git a/dom/browser-element/mochitest/priority/Makefile.in b/dom/browser-element/mochitest/priority/Makefile.in
new file mode 100644
index 00000000000..5b0d4c2a701
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/Makefile.in
@@ -0,0 +1,45 @@
+# 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/.
+
+DEPTH		= @DEPTH@
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+relativesrcdir  = @relativesrcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+# Note: ../browserElementTestHelpers.js makes all tests in this directory OOP,
+# because testing the process-priority manager without OOP frames doesn't make
+# much sense.
+#
+# Good luck running these tests on anything but desktop Linux.
+
+ifeq ($(MOZ_WIDGET_TOOLKIT),gtk2)
+
+# This test disabled due to bug 865844.  In fact, it was never enabled!
+#
+#       test_WebGLContextLost.html \
+#       file_WebGLContextLost.html \
+
+MOCHITEST_FILES = \
+	test_Simple.html \
+	test_Visibility.html \
+	test_HighPriority.html \
+	file_HighPriority.html \
+	test_Background.html \
+	test_Audio.html \
+	file_Audio.html \
+	silence.ogg \
+	test_MultipleFrames.html \
+	file_MultipleFrames.html \
+	test_Preallocated.html \
+	test_ExpectingSystemMessage.html \
+	test_NestedFrames.html \
+	file_NestedFramesOuter.html \
+	$(NULL)
+
+endif # MOZ_WIDGET_TOOLKIT == gtk2
+
+include $(topsrcdir)/config/rules.mk
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 00000000000..97f4dc64d47
--- /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 00000000000..dc7197bba46
--- /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 00000000000..b3b56f5608b
--- /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 00000000000..e4378935f2d
--- /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 00000000000..bd5c84f11a1
--- /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/moz.build b/dom/browser-element/mochitest/priority/moz.build
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dom/browser-element/mochitest/priority/silence.ogg b/dom/browser-element/mochitest/priority/silence.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..6e0b352a321ae89cc2f41a008c660c8bf421afc2
GIT binary patch
literal 5940
zcmeGgZBSEJ_J+@ZK>3K6V5Bb)Ai=OhZ0rJyGa<@C0w_EJ8oJqC2&qK0wFKO<jx$k$
zLPQorlEpxokP<LiWGdTOamJl=t$-jOf{6Xttu2<=GTUusXWRYNJ@38fV5c+fO#5ry
zJ2yA?o^$Rw?|j{R-rKW(e<|`qzSgLuCZS>JO|*F0k(cYLG+F}Ww`&NYZ=j)n(a8VH
zv^~Vm$Bo!YgVnGNbw^1F%Jt2k;*<#llG0ybg_SR<)OEbl(p*0F!nXAE=Y>LHx)S46
zRch7M*vl_rl`qR1%CV~LK5Y6nk&;h{q6Jcn_>!IFG(<;8mr%%jM>p3|hEOCzwxOR}
zj!s<t>hDL7pU-0)Z6RjMLwR$*ZyANz=T`^gj!pqgi;1c?A{2mhe7d#np5(KuU&XUl
zqDtaY$B9{UYr2Wmyu<un#VV)s1IcGQyz%sKMIaafiRm0Y1JCC)KN|Rst||k6psQ+<
zKgibJ6pmv}5m^uVJBuYD{QhEDs<YpO%hK*tXg|Li{5S1CbH2v(krH6?Xdv~#;8_4z
zO#%td6hBHW4Cx5XrDqva7unOd*wbIKXQPrzqLXfIOIyIVmp-?nOrE<aFWXzDRQ~SJ
z;*mp(mP1SB<fQzN;?kk_pX{XS7!BDHGmVLSV*=l}oM8;mpB(Z-)r3iGJi~HE`~Cd(
zB#rUKM$7(I>-lrm2hQG5k_22FKs*h)_o~7BYWx01BRN_JHP(S2+Ql^!sYndA9DjvP
z^}IT6Flpfl1U?nx-0?a=o>nxj&CaXeHC|tM!z91q{?&#@P5`$<6UPX0OS8v2vu9(r
z&n}3jV~R>dMGHTmmoko%@dAo)UVG7UKu3SBqmnd>4%jmL=sUwGNkGujcOSFPS=XjB
zBdnj;oQ&>;w_D}iDWlG=ZtYB_x98vtYq>`|!=F5N-F9xys-2OBSsm1@F}geWf^!~V
zEN@T57^@QKH1pPA=ezr0uVT)+a(<KnvsP1gihEQ}@gtdPXPm$8nRz?&BiPaUUU%(i
zh!ST1sqXoFI)s3MT;C8vhL0HhR(Y2>_Sy;TSbI<vgEPSCjIaMgM5j$S!S9bh)Ba1D
zv#A(or8w$OkeXu%=_A)iG3O++s)aMyQx}?gzTap_o#g%b=C&yTF$`Us$y$BmTI9|!
z;hXa^!S=;+)fx9nuXZ>yzt-WtQ?b<n0nT?&83j(osylLmSY&>j?5cyTu$>59@3=3x
zvr$`at?RR2vLTqMcqW6nZ10gnia$2I|5mf|Zo`L5$39#-^P5d4)e6fKol+e%K}0%{
z>1e8I6OQ*Z?Usa44)$eE-Ybmpv+NsZxdkKKqItpeL(!f!(XE(V2$#~0%3B*77Gl+<
z&np+Us~5`Di$~P&UQ)mC)-lDUV;_FCt}ivL&m2gbgv|Ek{3kP~{o{=GM5&RhFea0k
z<2={<snh<g%(2xN2D=P{Ee3B(JFnHEX|=jW?FT1^SFe0;f1EjxFwk>xZtfGA;}NoV
zLh_6Viq<F{cie*0p+0xhdIuon=?E(zjuLJOp0<c@U&PbO<U7i~uPqX(1%@>v#6sxW
zoA>AIX3yC2Q}f(+j3u9Nue0L}wiD&r@QtDt>1j??C?{EHiO3r0xgA%^XKCfygB*E_
zG(2kn=Le<HA#UlYkA)(}Y1}D4Zh=4ek!aEdG`)tV)~FQ{&x<?{MdGz=-}*=Waf|##
zvqblC0YQ5hH0adY^Dx^Jv%?dU`=f;THnYDa3p4^jvoStdpb-fAiDdm0&-;HK|I-$L
zu%ku5FILjW+3KguprKRT93v*36X~iIbE2BK!Wc{uD+;#;El}4xVGZ#^K#0Qa^bXN8
z)}W#$-s36}VH!YKgGvJO3B*9oqa1==bA>T>dWl}+m%X6pNf?#Z?>4LsAssCk=}^q1
z`0+E@_r)TVVN@xgzQ{1DX-KD5*x|OfI9e0Fo6Qf0eoG)t$3y582t3T5@@rQq#74n}
z-zw0we@&d2K_iI$h^N~uN{S8UiK>%OWFWd%%$S-NmE6y;I5hT&vx0(!U1!xAtM^>8
zXnL(M%I<9(2$@|2y)_2A%MY#>Fnb_j_UCJ4f{5ap2^qq;$n#N#<&#GHgGPIe)iwEw
zU}|kw38SdAtjxSzWAV1ydDa1!D-{IIl2=q&nX<;}17G=B_N<RuxvAINXy+LQoUY*w
zC5&7seBc0I3IwJAa(#A1Ouzu7+|)v`9A5SF5t)@bjmzbN`^HZW1WOHSmW|jlymbmK
zH7J+NYDLgJz)p?`z!4rA!aVe>8|O#pn~N@gff#Wk38)2Pp{-ITbcCs*C82$lg_3+u
zHIAq99ifucBr~3q@94+3$<iDaJdk5H%A8m~j`IVNZc7II_R*V94h5ixQ0=LROWVtp
z$b>6B+Gvi036+hLp(1J=lTiqT&TiSKT>wjQRNn+xC!R$VKT^J<9!Q|JmONnBL;dlZ
zHbO!}V#?ZvgS*qC<)pbcBF{a-UA-xW0gco+(Aev39dI2m_LC5&>#;ov1Zk%_rO%p4
zQ}!CdysiyIQ7JE5Y9<O?muvN}mk6^iHB`P2Mg%K)z+_;;3F7(|Y(QwwVT4lOsBF-8
z+An(GqVpr}OTCcJhni~w>yMP=^P4-K41bzV4uHto3s6wihO1zJS+sYESdy@xbSOvI
zk!F9-ZhiQl5_=eD0%PMwq7gk9Jet!Ye87czt~pXQC(U=bnOpVDrec}wg1al*%hux+
z2hzswXL_;z+ZAoX<R#F=VW~QO@p7yrmG8b&HFSe%#t)=jV%GlS`gxPAKsd&%O&?n!
zi0@RK7G}K_UC<^RtI$V{U5`}_xt9{!qDHRIS6pxhsoE}%y6+yC9%UxB4X3%wYo`NI
zS9S&xC*94sCYx7$RC5?k37YN$cnO0bQ4z5KE~h*3woG_1cya18;W!yRPz@GK_>TTI
z;R=Z$>QfD0eKV6lK&5J$$5(r_u!AgIlN`4}9}0oXWNE;P2doG>7=1fn>2#QUJ762E
zn<GI6N!M?BR0G3On&vj)JPKhlRsb846$~H<m-!I5tN{2CGDs{r%6&_|<2JF4!dBFR
zf$>y|?#<g3wZNXD(_8>SGQOE&56A9te<apLnPaO4S$pG;Cx)_;ZDj0KBNX<!374kj
zo=9*o`z?~BjoM<|z|%(HLr%#Iw!$?VgnCnxd|R*?znK%tQ5W)qE|{5FV_mOz9Z2m{
zg~1t{gV6DgkbqE|M;wIM7&o7WngdTpL?wvZ{QQ?co)1D8{VXdX>LQbyEceg7UXR|m
z?CE$0vEnvsHf@?y>o#1uyeg*W&?S+l{dpKIIOT&c-r3xHxGARIAlpK|&*}UTRC(OZ
z;$6E$TK1OsXE9DfA~%Wr$l$A*5F$P@5VuhF?#kV??Bo>cO7aAuXQ6Zqjf{$#X6Kz6
z56*9ypi5hCgvb!W;3$Vi#}JK1vLV+r-^UB_zo}x7;7iN`1S^-m0m7%bq0oq@xlv!W
z#1G*(ghm8L0Q`ppC*6D61LJ9q3ecSli~uwTH@q(};ENzi{!5SU>!<a&cv>UkzpY_w
AR{#J2

literal 0
HcmV?d00001

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 00000000000..c78c136ebc9
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Audio.html
@@ -0,0 +1,60 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that frames playing audio get BACKGROUND_PERCEIVABLE 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() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = 'file_Audio.html';
+
+  var childID = null;
+  expectOnlyOneProcessCreated().then(function(chid) {
+    childID = chid;
+    return Promise.all(
+      [expectPriorityChange(childID, 'FOREGROUND'),
+       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);
+}
+
+// This test relies on <audio> elements interacting with the audio channel
+// service.  This is controled by the media.useAudioChannelService pref.
+addEventListener('testready', function() {
+  SpecialPowers.pushPrefEnv({set: [['media.useAudioChannelService', true]]},
+                            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 00000000000..cf5c6fac6d0
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Background.html
@@ -0,0 +1,55 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that calling setVisible('false') on an iframe causes its visibility to
+change.
+-->
+<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 = browserElementTestHelpers.emptyPage1;
+
+  var childID = null;
+  expectOnlyOneProcessCreated().then(function(chid) {
+    childID = chid;
+  }).then(function() {
+    return expectPriorityChange(childID, 'FOREGROUND');
+  }).then(function() {
+    return 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_ExpectingSystemMessage.html b/dom/browser-element/mochitest/priority/test_ExpectingSystemMessage.html
new file mode 100644
index 00000000000..91697269579
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_ExpectingSystemMessage.html
@@ -0,0 +1,55 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that a high-priority frame that's expecting a system message initially
+gets priority FOREGROUND_HIGH.
+-->
+<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();
+SpecialPowers.addPermission("embed-apps", true, document);
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.setAttribute('expecting-system-message', true);
+  iframe.setAttribute('mozapptype', 'critical');
+  iframe.setAttribute('mozapp', 'http://example.org/manifest.webapp');
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  var childID = null;
+  expectOnlyOneProcessCreated().then(function(chid) {
+    childID = chid;
+    return expectPriorityChange(childID, 'FOREGROUND_HIGH');
+  }).then(function() {
+    // We go back to foreground when the wake lock taken on behalf of our new
+    // process times out.
+    return expectPriorityChange(childID, 'FOREGROUND');
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', function() {
+  // Cause the CPU wake lock taken on behalf of this new process to time out
+  // after 1s.
+  SpecialPowers.pushPrefEnv(
+    {set: [["dom.ipc.systemMessageCPULockTimeoutSec", 1]]},
+    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 00000000000..7a4b2238452
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_HighPriority.html
@@ -0,0 +1,121 @@
+<!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() {
+  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(
+      [expectMozbrowserEvent(iframe, 'showmodalprompt').then(checkAlertInfo),
+       expectPriorityChange(childID, priority).then(checkGracePeriod)]
+    ).then(function(results) {
+      // expectMozbrowserEvent returns the function to call to unblock the
+      // alert.  It comes to us as the first element of the results array.
+      results[0]();
+    });
+  }
+
+  expectProcessCreated().then(function(chid) {
+    childID = chid;
+    return expectPriorityChange(childID, 'FOREGROUND');
+  }).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]]},
+    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 00000000000..90efc2d1383
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_MultipleFrames.html
@@ -0,0 +1,56 @@
+<!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="/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_MultipleFrames.html';
+
+  var childID = null;
+  var iframe2;
+  expectProcessCreated().then(function(chid) {
+    childID = chid;
+    return expectPriorityChange(childID, 'FOREGROUND');
+  }).then(function() {
+    return expectMozbrowserEvent(iframe, 'openwindow');
+  }).then(function(e) {
+    iframe2 = e.detail.frameElement;
+    document.body.appendChild(iframe2);
+    return expectMozbrowserEvent(iframe2, 'loadend');
+  }).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 00000000000..e1bf9bca355
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_NestedFrames.html
@@ -0,0 +1,73 @@
+<!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="/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();
+
+// Give our origin permission to open browsers, and remove it when the test is complete.
+var principal = SpecialPowers.wrap(SpecialPowers.getNodePrincipal(document));
+SpecialPowers.addPermission("browser", true, { url: SpecialPowers.wrap(principal.URI).spec,
+                                               appId: principal.appId,
+                                               isInBrowserElement: true });
+
+addEventListener('unload', function() {
+  var principal = SpecialPowers.wrap(SpecialPowers.getNodePrincipal(document));
+  SpecialPowers.removePermission("browser", { url: SpecialPowers.wrap(principal.URI).spec,
+                                              appId: principal.appId,
+                                              isInBrowserElement: true });
+});
+
+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;
+  expectOnlyOneProcessCreated().then(function(chid) {
+    childID = chid;
+    return Promise.all(
+      [expectPriorityChange(childID, 'FOREGROUND'),
+       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(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 00000000000..f5f99683f8a
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Preallocated.html
@@ -0,0 +1,77 @@
+<!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;
+
+  if (preallocationEnabledPref === null) {
+    SpecialPowers.clearUserPref('dom.ipc.processPrelaunch.enabled');
+  } else {
+    SpecialPowers.setBoolPref('dom.ipc.processPrelaunch.enabled',
+                              preallocationEnabledPref);
+  }
+}
+
+// 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().then(function(childID) {
+    return expectPriorityChange(childID, 'BACKGROUND');
+  }).then(function() {
+    cleanUp();
+    SimpleTest.finish();
+  });
+
+  // Setting this pref to true should cause us to prelaunch a process.
+  SpecialPowers.setBoolPref('dom.ipc.processPrelaunch.enabled', true);
+}
+
+addEventListener('testready', 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 00000000000..5e0e6f74dbe
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Simple.html
@@ -0,0 +1,50 @@
+<!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();
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  expectProcessCreated().then(function(childID) {
+    return expectPriorityChange(childID, 'FOREGROUND');
+  }).then(SimpleTest.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 00000000000..229c73a3557
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_Visibility.html
@@ -0,0 +1,52 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that setVisible() changes a process's 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() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  var childID = null;
+  expectOnlyOneProcessCreated().then(function(chid) {
+    childID = chid;
+    return Promise.all(
+      [expectPriorityChange(childID, 'FOREGROUND'),
+       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 00000000000..c163c844622
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_WebGLContextLost.html
@@ -0,0 +1,100 @@
+<!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;
+  expectOnlyOneProcessCreated().then(function(chid) {
+    childID = chid;
+    return Promise.all(
+      [expectPriorityChange(childID, 'FOREGROUND'),
+       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>

From 37ebeead76333cd45227a43f4491be228f606409 Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:26 -0400
Subject: [PATCH 11/13] Bug 860799 - Part 1: Give frames expecting a system
 message priority at least BACKGROUND_PERCEIVABLE, so long as either haven't
 yet handled the system message or are holding the CPU/high-priority wake
 lock. r=khuey

---
 dom/ipc/ProcessPriorityManager.cpp | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/dom/ipc/ProcessPriorityManager.cpp b/dom/ipc/ProcessPriorityManager.cpp
index c6974fb9954..f0d465c96ce 100644
--- a/dom/ipc/ProcessPriorityManager.cpp
+++ b/dom/ipc/ProcessPriorityManager.cpp
@@ -28,6 +28,7 @@
 #include "nsIDOMDocument.h"
 #include "nsPIDOMWindow.h"
 #include "StaticPtr.h"
+#include "nsIMozBrowserFrame.h"
 #include "nsIObserver.h"
 #include "nsITimer.h"
 #include "nsPrintfCString.h"
@@ -228,6 +229,7 @@ public:
   const nsAutoCString& NameWithComma();
 
   bool HasAppType(const char* aAppType);
+  bool IsExpectingSystemMessage();
 
   void OnAudioChannelProcessChanged(nsISupports* aSubject);
   void OnRemoteBrowserFrameShown(nsISupports* aSubject);
@@ -702,6 +704,27 @@ ParticularProcessPriorityManager::HasAppType(const char* aAppType)
   return false;
 }
 
+bool
+ParticularProcessPriorityManager::IsExpectingSystemMessage()
+{
+  const InfallibleTArray<PBrowserParent*>& browsers =
+    mContentParent->ManagedPBrowserParent();
+  for (uint32_t i = 0; i < browsers.Length(); i++) {
+    TabParent* tp = static_cast<TabParent*>(browsers[i]);
+    nsCOMPtr<nsIDOMElement> ownerElement = tp->GetOwnerElement();
+    nsCOMPtr<nsIMozBrowserFrame> bf = do_QueryInterface(ownerElement);
+    if (!bf) {
+      continue;
+    }
+
+    if (bf->GetIsExpectingSystemMessage()) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 ProcessPriority
 ParticularProcessPriorityManager::ComputePriority()
 {
@@ -724,6 +747,11 @@ ParticularProcessPriorityManager::ComputePriority()
     return PROCESS_PRIORITY_FOREGROUND;
   }
 
+  if ((mHoldsCPUWakeLock || mHoldsHighPriorityWakeLock) &&
+      IsExpectingSystemMessage()) {
+    return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE;
+  }
+
   AudioChannelService* service = AudioChannelService::GetAudioChannelService();
   if (service->ProcessContentOrNormalChannelIsActive(ChildID())) {
     return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE;

From 7291a2f7f90c3601443796c1ce59bc01c03074df Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:26 -0400
Subject: [PATCH 12/13] Bug 860799 - Part 2: Test that we give frames expecting
 a system message priority above vanilla BACKGROUND. r=khuey

---
 .../mochitest/priority/Makefile.in            |  1 +
 .../test_ExpectingSystemMessage2.html         | 70 +++++++++++++++++++
 2 files changed, 71 insertions(+)
 create mode 100644 dom/browser-element/mochitest/priority/test_ExpectingSystemMessage2.html

diff --git a/dom/browser-element/mochitest/priority/Makefile.in b/dom/browser-element/mochitest/priority/Makefile.in
index 5b0d4c2a701..fa30cf58632 100644
--- a/dom/browser-element/mochitest/priority/Makefile.in
+++ b/dom/browser-element/mochitest/priority/Makefile.in
@@ -36,6 +36,7 @@ MOCHITEST_FILES = \
 	file_MultipleFrames.html \
 	test_Preallocated.html \
 	test_ExpectingSystemMessage.html \
+	test_ExpectingSystemMessage2.html \
 	test_NestedFrames.html \
 	file_NestedFramesOuter.html \
 	$(NULL)
diff --git a/dom/browser-element/mochitest/priority/test_ExpectingSystemMessage2.html b/dom/browser-element/mochitest/priority/test_ExpectingSystemMessage2.html
new file mode 100644
index 00000000000..dccb29e3a31
--- /dev/null
+++ b/dom/browser-element/mochitest/priority/test_ExpectingSystemMessage2.html
@@ -0,0 +1,70 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that a regular (not mozapptype=critical) frame that's expecting a system
+message gets priority BACKGROUND_PERCEIVABLE when it's in the 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();
+SpecialPowers.addPermission("embed-apps", true, document);
+
+// Give our origin permission to open browsers, and remove it when the test is complete.
+var principal = SpecialPowers.wrap(SpecialPowers.getNodePrincipal(document));
+SpecialPowers.addPermission("browser", true, { url: SpecialPowers.wrap(principal.URI).spec,
+                                               appId: principal.appId,
+                                               isInBrowserElement: true });
+
+addEventListener('unload', function() {
+  var principal = SpecialPowers.wrap(SpecialPowers.getNodePrincipal(document));
+  SpecialPowers.removePermission("browser", { url: SpecialPowers.wrap(principal.URI).spec,
+                                              appId: principal.appId,
+                                              isInBrowserElement: true });
+});
+
+function runTest() {
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('mozbrowser', true);
+  iframe.setAttribute('expecting-system-message', true);
+  iframe.setAttribute('mozapp', 'http://example.org/manifest.webapp');
+
+  iframe.src = browserElementTestHelpers.emptyPage1;
+
+  var childID = null;
+  expectOnlyOneProcessCreated().then(function(chid) {
+    childID = chid;
+    return Promise.all(
+      [expectPriorityChange(childID, 'FOREGROUND'),
+       expectMozbrowserEvent(iframe, 'loadend')]);
+  }).then(function() {
+    var p = expectPriorityChange(childID, 'BACKGROUND_PERCEIVABLE');
+    iframe.setVisible(false);
+    return p;
+  }).then(SimpleTest.finish);
+
+  document.body.appendChild(iframe);
+}
+
+addEventListener('testready', function() {
+  // We don't want this wake lock to time out during the test; if it did, then
+  // we might see BACKGROUND priority instead of BACKGROUND_PERCEIVABLE.  So
+  // set the timeout to a large value.
+  SpecialPowers.pushPrefEnv(
+    {set: [["dom.ipc.systemMessageCPULockTimeoutSec", 99999]]},
+    runTest);
+});
+
+</script>
+</body>
+</html>

From d31b7f65ffa9375a8a07f4841e92f90bd33606e5 Mon Sep 17 00:00:00 2001
From: Justin Lebar <justin.lebar@gmail.com>
Date: Thu, 25 Apr 2013 20:53:27 -0400
Subject: [PATCH 13/13] Bug 861441 - When changing a proces's CPU priority,
 call setpriority() on all threads, not just the main thread. r=gsvelto

It turns out that setpriority() on Linux sets the priority of just one
thread.  If you call setpriority() on a pid, you're setting the priority
of only the main thread in that process.
---
 b2g/app/b2g.js       | 12 +++++--
 hal/gonk/GonkHal.cpp | 82 +++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 88 insertions(+), 6 deletions(-)

diff --git a/b2g/app/b2g.js b/b2g/app/b2g.js
index b1cc016bb85..7abbcf9a41d 100644
--- a/b2g/app/b2g.js
+++ b/b2g/app/b2g.js
@@ -576,12 +576,20 @@ pref("hal.processPriorityManager.gonk.backgroundKillUnderMB", 20);
 pref("hal.processPriorityManager.gonk.notifyLowMemUnderMB", 10);
 
 // Niceness values (i.e., CPU priorities) for B2G processes.
+//
+// Note: The maximum nice value on Linux is 19, but the max value you should
+// use here is 18.  NSPR adds 1 to some threads' nice values, to mark
+// low-priority threads.  If the process priority manager were to renice a
+// process (and all its threads) to 19, all threads would have the same
+// niceness.  Then when we reniced the process to (say) 10, all threads would
+// /still/ have the same niceness; we'd effectively have erased NSPR's thread
+// priorities.
 pref("hal.processPriorityManager.gonk.masterNice", 0);
 pref("hal.processPriorityManager.gonk.foregroundHighNice", 0);
 pref("hal.processPriorityManager.gonk.foregroundNice", 1);
 pref("hal.processPriorityManager.gonk.backgroundPerceivableNice", 10);
-pref("hal.processPriorityManager.gonk.backgroundHomescreenNice", 20);
-pref("hal.processPriorityManager.gonk.backgroundNice", 20);
+pref("hal.processPriorityManager.gonk.backgroundHomescreenNice", 18);
+pref("hal.processPriorityManager.gonk.backgroundNice", 18);
 
 #ifndef DEBUG
 // Enable pre-launching content processes for improved startup time
diff --git a/hal/gonk/GonkHal.cpp b/hal/gonk/GonkHal.cpp
index 9edc40c7fb9..ae85a00273e 100644
--- a/hal/gonk/GonkHal.cpp
+++ b/hal/gonk/GonkHal.cpp
@@ -1061,6 +1061,83 @@ EnsureKernelLowMemKillerParamsSet()
   }
 }
 
+static void
+SetNiceForPid(int aPid, int aNice)
+{
+  errno = 0;
+  int origProcPriority = getpriority(PRIO_PROCESS, aPid);
+  if (errno) {
+    LOG("Unable to get nice for pid=%d; error %d.  SetNiceForPid bailing.",
+        aPid, errno);
+    return;
+  }
+
+  int rv = setpriority(PRIO_PROCESS, aPid, aNice);
+  if (rv) {
+    LOG("Unable to set nice for pid=%d; error %d.  SetNiceForPid bailing.",
+        aPid, errno);
+    return;
+  }
+
+  // On Linux, setpriority(aPid) modifies the priority only of the main
+  // thread of that process.  We have to modify the priorities of all of the
+  // process's threads as well, so iterate over all the threads and increase
+  // each of their priorites by aNice - origProcPriority (and also ensure that
+  // none of the tasks has a lower priority than the main thread).
+  //
+  // This is horribly racy.
+
+  DIR* tasksDir = opendir(nsPrintfCString("/proc/%d/task/", aPid).get());
+  if (!tasksDir) {
+    LOG("Unable to open /proc/%d/task.  SetNiceForPid bailing.", aPid);
+    return;
+  }
+
+  // Be careful not to leak tasksDir; after this point, we must call closedir().
+
+  while (struct dirent* de = readdir(tasksDir)) {
+    char* endptr = nullptr;
+    long tidlong = strtol(de->d_name, &endptr, /* base */ 10);
+    if (*endptr || tidlong < 0 || tidlong > INT32_MAX || tidlong == aPid) {
+      // if dp->d_name was not an integer, was negative (?!) or too large, or
+      // was the same as aPid, we're not interested.
+      //
+      // (The |tidlong == aPid| check is very important; without it, we'll
+      // renice aPid twice, and the second renice will be relative to the
+      // priority set by the first renice.)
+      continue;
+    }
+
+    int tid = static_cast<int>(tidlong);
+
+    errno = 0;
+    // Get and set the task's new priority.
+    int origtaskpriority = getpriority(PRIO_PROCESS, tid);
+    if (errno) {
+      LOG("Unable to get nice for tid=%d (pid=%d); error %d.  This isn't "
+          "necessarily a problem; it could be a benign race condition.",
+          tid, aPid, errno);
+      continue;
+    }
+
+    int newtaskpriority =
+      std::max(origtaskpriority + aNice - origProcPriority, origProcPriority);
+    rv = setpriority(PRIO_PROCESS, tid, newtaskpriority);
+
+    if (rv) {
+      LOG("Unable to set nice for tid=%d (pid=%d); error %d.  This isn't "
+          "necessarily a problem; it could be a benign race condition.",
+          tid, aPid, errno);
+      continue;
+    }
+  }
+
+  LOG("Changed nice for pid %d from %d to %d.",
+      aPid, origProcPriority, aNice);
+
+  closedir(tasksDir);
+}
+
 void
 SetProcessPriority(int aPid, ProcessPriority aPriority)
 {
@@ -1141,10 +1218,7 @@ SetProcessPriority(int aPid, ProcessPriority aPriority)
   if (NS_SUCCEEDED(rv)) {
     HAL_LOG(("Setting nice for pid %d to %d", aPid, nice));
 
-    int success = setpriority(PRIO_PROCESS, aPid, nice);
-    if (success != 0) {
-      HAL_LOG(("Failed to set nice for pid %d to %d", aPid, nice));
-    }
+    SetNiceForPid(aPid, nice);
   }
 }