Message manager overview

In multiprocess Firefox there are two processes:

• the chrome process, also called the parent process, runs the browser UI (chrome) code and code inserted by extensions
• the content process, also called the child process, runs all web content. In future versions of multiprocess Firefox different tabs may run in different processes, but for now, all content tabs share a single content process.

Message managers are designed to enable chrome-privileged JavaScript code in one process to communicate with chrome-privileged JavaScript code in a different process. At the top level, there are two different sorts of message managers:

• Frame message managers: these enable chrome process code to load a script into a browser frame (essentially, a single browser tab) in the content process. These scripts are called frame scripts, and as the name suggests, they are scoped to a specific browser frame. If chrome code wants to run code in the content process so it can access web content, this is usually the sort of message manager to use.
• Process message managers: these correspond to process boundaries, and enable code running in the parent (chrome) process to communicate with code running in the child (content) process. From Firefox 38 onwards, they also enable code running in the parent process to load process scripts into the child process. These are like frame scripts, except they are global to the child process. Process scripts are most likely to be useful when an extension wants to run some code only once in the content process, to access some global service: for example, to register an observer or a content policy.

Frame message managers

In multiprocess Firefox, when chrome code needs to interact with web content, it needs to:

• factor the code that needs direct access to content into separate scripts, which are called "frame scripts"
• use a frame message manager to load these frame scripts into the content process
• use the frame message manager API to communicate with the frame script

So fundamentally, frame message managers enable chrome code to:

• load a script into a frame (essentially, a single browser tab) in the content process. These scripts are called "frame scripts".
• communicate with frame scripts using message-passing APIs

There are various types of frame message managers, as depicted in this diagram:

This diagram shows the setup when there are 2 browser windows open, one with 2 tabs open and one with 1 tab open.

Chrome process

In the chrome process, there's a hierarchy of frame message managers: the global frame message manager, window message managers, and browser message managers.

Global frame message manager

// chrome script
let globalMM = Cc["@mozilla.org/globalmessagemanager;1"]
  .getService(Ci.nsIMessageListenerManager);

Window message manager

// chrome script
let windowMM = window.messageManager;

Browser message manager

// chrome script
let browserMM = gBrowser.selectedBrowser.messageManager;

Content process

Content frame message manager

Process message managers

Process message managers correspond to process boundaries, and enable code running in different processes to communicate. Multiprocess Firefox has the concept of:

• a "parent process"
• "child processes" which are processes spawned by the parent process.

For practical purposes, in multiprocess Firefox the parent process is the chrome process, and child processes are content processes. 

In each child process, there's a single child process message manager (CPMM). There's also an additional child-in-process message manager (CIPMM) in the parent process.

For each child process message manager, there's a parent process message manager (PPMM) in the parent process.

There's also a single global parent process message manager (GPPMM) in the parent process, that provides access to all the parent process message managers. The diagram below shows the setup that would result from having two child processes:

With the GPPMM, you can broadcast messages to the CIPMM and all CPMMs. With a PPMM, you can send a message to its corresponding CPMM. With a CPMM, you can send messages to the parent process: these messages are received first by the corresponding PPMM, then by the GPPMM.

From Firefox 38 onwards, you can also use a parent process message manager to load a script into a child process. This is the recommended way to load a script that executes just once per child process, which is something you might want to do if you are interacting with some global service (for example, adding listeners to observer notifications or registering a content policy).

Parent process

Global parent process message manager

// parent process
let ppmm = Cc["@mozilla.org/parentprocessmessagemanager;1"]
           .getService(Ci.nsIMessageBroadcaster);

Parent process message manager

// parent process
let ppmm = Services.ppmm.getChildAt(1);

Child process

Child process message manager

// child process script
let cpmm = Cc["@mozilla.org/childprocessmessagemanager;1"]
           .getService(Ci.nsISyncMessageSender);