--- a/media/libcubeb/cubeb-pulse-rs/src/backend/context.rs
+++ b/media/libcubeb/cubeb-pulse-rs/src/backend/context.rs
@@ -17,17 +17,17 @@ use std::mem;
 use std::os::raw::c_void;
 use std::ptr;
 
 fn pa_channel_to_cubeb_channel(channel: pulse::ChannelPosition) -> ffi::cubeb_channel {
     use cubeb_backend::ffi::*;
     use pulse::ChannelPosition;
     assert_ne!(channel, ChannelPosition::Invalid);
     match channel {
-        ChannelPosition::Mono => CHANNEL_MONO,
+        ChannelPosition::Mono => CHANNEL_CENTER,
         ChannelPosition::FrontLeft => CHANNEL_LEFT,
         ChannelPosition::FrontRight => CHANNEL_RIGHT,
         ChannelPosition::FrontCenter => CHANNEL_CENTER,
         ChannelPosition::SideLeft => CHANNEL_LS,
         ChannelPosition::SideRight => CHANNEL_RS,
         ChannelPosition::RearLeft => CHANNEL_RLS,
         ChannelPosition::RearCenter => CHANNEL_RCENTER,
         ChannelPosition::RearRight => CHANNEL_RRS,

--- a/media/libcubeb/gtest/test_mixer.cpp
+++ b/media/libcubeb/gtest/test_mixer.cpp
@@ -84,17 +84,16 @@ audio_input audio_inputs[CUBEB_LAYOUT_MA
   { CUBEB_LAYOUT_QUAD_LFE,      { L, R, LFE, LS, RS } },
   { CUBEB_LAYOUT_3F2,           { L, R, C, LS, RS } },
   { CUBEB_LAYOUT_3F2_LFE,       { L, R, C, LFE, LS, RS } },
   { CUBEB_LAYOUT_3F3R_LFE,      { L, R, C, LFE, RC, LS, RS } },
   { CUBEB_LAYOUT_3F4_LFE,       { L, R, C, LFE, RLS, RRS, LS, RS } }
 };
 
 char const * channel_names[CHANNEL_UNMAPPED + 1] = {
-  "mono",                   // CHANNEL_MONO
   "left",                   // CHANNEL_LEFT
   "right",                  // CHANNEL_RIGHT
   "center",                 // CHANNEL_CENTER
   "left surround",          // CHANNEL_LS
   "right surround",         // CHANNEL_RS
   "rear left surround",     // CHANNEL_RLS
   "rear center",            // CHANNEL_RCENTER
   "rear right surround",    // CHANNEL_RRS

--- a/media/libcubeb/src/cubeb_audiounit.cpp
+++ b/media/libcubeb/src/cubeb_audiounit.cpp
@@ -199,17 +199,17 @@ bool has_output(cubeb_stream * stm)
 {
   return stm->output_stream_params.rate != 0;
 }
 
 cubeb_channel
 channel_label_to_cubeb_channel(UInt32 label)
 {
   switch (label) {
-    case kAudioChannelLabel_Mono: return CHANNEL_MONO;
+    case kAudioChannelLabel_Mono: return CHANNEL_CENTER;
     case kAudioChannelLabel_Left: return CHANNEL_LEFT;
     case kAudioChannelLabel_Right: return CHANNEL_RIGHT;
     case kAudioChannelLabel_Center: return CHANNEL_CENTER;
     case kAudioChannelLabel_LFEScreen: return CHANNEL_LFE;
     case kAudioChannelLabel_LeftSurround: return CHANNEL_LS;
     case kAudioChannelLabel_RightSurround: return CHANNEL_RS;
     case kAudioChannelLabel_RearSurroundLeft: return CHANNEL_RLS;
     case kAudioChannelLabel_RearSurroundRight: return CHANNEL_RRS;
@@ -218,17 +218,16 @@ channel_label_to_cubeb_channel(UInt32 la
     default: return CHANNEL_INVALID;
   }
 }
 
 AudioChannelLabel
 cubeb_channel_to_channel_label(cubeb_channel channel)
 {
   switch (channel) {
-    case CHANNEL_MONO: return kAudioChannelLabel_Mono;
     case CHANNEL_LEFT: return kAudioChannelLabel_Left;
     case CHANNEL_RIGHT: return kAudioChannelLabel_Right;
     case CHANNEL_CENTER: return kAudioChannelLabel_Center;
     case CHANNEL_LFE: return kAudioChannelLabel_LFEScreen;
     case CHANNEL_LS: return kAudioChannelLabel_LeftSurround;
     case CHANNEL_RS: return kAudioChannelLabel_RightSurround;
     case CHANNEL_RLS: return kAudioChannelLabel_RearSurroundLeft;
     case CHANNEL_RRS: return kAudioChannelLabel_RearSurroundRight;

--- a/media/libcubeb/src/cubeb_mixer.cpp
+++ b/media/libcubeb/src/cubeb_mixer.cpp
@@ -4,17 +4,17 @@
  * This program is made available under an ISC-style license.  See the
  * accompanying file LICENSE for details.
  */
 
 #include <cassert>
 #include "cubeb-internal.h"
 #include "cubeb_mixer.h"
 
-#define MASK_MONO         (1 << CHANNEL_MONO)
+#define MASK_MONO         (1 << CHANNEL_CENTER)
 #define MASK_MONO_LFE     (MASK_MONO | (1 << CHANNEL_LFE))
 #define MASK_STEREO       ((1 << CHANNEL_LEFT) | (1 << CHANNEL_RIGHT))
 #define MASK_STEREO_LFE   (MASK_STEREO | (1 << CHANNEL_LFE))
 #define MASK_3F           (MASK_STEREO | (1 << CHANNEL_CENTER))
 #define MASK_3F_LFE       (MASK_3F | (1 << CHANNEL_LFE))
 #define MASK_2F1          (MASK_STEREO | (1 << CHANNEL_RCENTER))
 #define MASK_2F1_LFE      (MASK_2F1 | (1 << CHANNEL_LFE))
 #define MASK_3F1          (MASK_3F | (1 << CHANNEL_RCENTER))

--- a/media/libcubeb/src/cubeb_mixer.h
+++ b/media/libcubeb/src/cubeb_mixer.h
@@ -12,34 +12,33 @@
 #include <stdbool.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
 typedef enum {
   CHANNEL_INVALID = -1,
-  CHANNEL_MONO = 0,
-  CHANNEL_LEFT,
+  CHANNEL_LEFT = 0,
   CHANNEL_RIGHT,
   CHANNEL_CENTER,
   CHANNEL_LS,
   CHANNEL_RS,
   CHANNEL_RLS,
   CHANNEL_RCENTER,
   CHANNEL_RRS,
   CHANNEL_LFE,
   CHANNEL_UNMAPPED,
   CHANNEL_MAX = 256 // Max number of supported channels.
 } cubeb_channel;
 
 static cubeb_channel const CHANNEL_INDEX_TO_ORDER[CUBEB_LAYOUT_MAX][CHANNEL_MAX] = {
   { CHANNEL_INVALID },                                                                                            // UNDEFINED
-  { CHANNEL_MONO },                                                                                               // MONO
-  { CHANNEL_MONO, CHANNEL_LFE },                                                                                  // MONO_LFE
+  { CHANNEL_CENTER },                                                                                             // MONO
+  { CHANNEL_CENTER, CHANNEL_LFE },                                                                                // MONO_LFE
   { CHANNEL_LEFT, CHANNEL_RIGHT },                                                                                // STEREO
   { CHANNEL_LEFT, CHANNEL_RIGHT, CHANNEL_LFE },                                                                   // STEREO_LFE
   { CHANNEL_LEFT, CHANNEL_RIGHT, CHANNEL_CENTER },                                                                // 3F
   { CHANNEL_LEFT, CHANNEL_RIGHT, CHANNEL_CENTER, CHANNEL_LFE },                                                   // 3F_LFE
   { CHANNEL_LEFT, CHANNEL_RIGHT, CHANNEL_RCENTER },                                                               // 2F1
   { CHANNEL_LEFT, CHANNEL_RIGHT, CHANNEL_LFE, CHANNEL_RCENTER },                                                  // 2F1_LFE
   { CHANNEL_LEFT, CHANNEL_RIGHT, CHANNEL_CENTER, CHANNEL_RCENTER },                                               // 3F1
   { CHANNEL_LEFT, CHANNEL_RIGHT, CHANNEL_CENTER, CHANNEL_LFE, CHANNEL_RCENTER },                                  // 3F1_LFE

--- a/media/libcubeb/src/cubeb_pulse.c
+++ b/media/libcubeb/src/cubeb_pulse.c
@@ -513,17 +513,16 @@ cubeb_channel_to_pa_channel(cubeb_channe
 {
   assert(channel != CHANNEL_INVALID);
 
   // This variable may be used for multiple times, so we should avoid to
   // allocate it in stack, or it will be created and removed repeatedly.
   // Use static to allocate this local variable in data space instead of stack.
   static pa_channel_position_t map[CHANNEL_MAX] = {
     // PA_CHANNEL_POSITION_INVALID,      // CHANNEL_INVALID
-    PA_CHANNEL_POSITION_MONO,         // CHANNEL_MONO
     PA_CHANNEL_POSITION_FRONT_LEFT,   // CHANNEL_LEFT
     PA_CHANNEL_POSITION_FRONT_RIGHT,  // CHANNEL_RIGHT
     PA_CHANNEL_POSITION_FRONT_CENTER, // CHANNEL_CENTER
     PA_CHANNEL_POSITION_SIDE_LEFT,    // CHANNEL_LS
     PA_CHANNEL_POSITION_SIDE_RIGHT,   // CHANNEL_RS
     PA_CHANNEL_POSITION_REAR_LEFT,    // CHANNEL_RLS
     PA_CHANNEL_POSITION_REAR_CENTER,  // CHANNEL_RCENTER
     PA_CHANNEL_POSITION_REAR_RIGHT,   // CHANNEL_RRS
@@ -533,17 +532,17 @@ cubeb_channel_to_pa_channel(cubeb_channe
   return map[channel];
 }
 
 static cubeb_channel
 pa_channel_to_cubeb_channel(pa_channel_position_t channel)
 {
   assert(channel != PA_CHANNEL_POSITION_INVALID);
   switch(channel) {
-    case PA_CHANNEL_POSITION_MONO: return CHANNEL_MONO;
+    case PA_CHANNEL_POSITION_MONO: return CHANNEL_CENTER;
     case PA_CHANNEL_POSITION_FRONT_LEFT: return CHANNEL_LEFT;
     case PA_CHANNEL_POSITION_FRONT_RIGHT: return CHANNEL_RIGHT;
     case PA_CHANNEL_POSITION_FRONT_CENTER: return CHANNEL_CENTER;
     case PA_CHANNEL_POSITION_SIDE_LEFT: return CHANNEL_LS;
     case PA_CHANNEL_POSITION_SIDE_RIGHT: return CHANNEL_RS;
     case PA_CHANNEL_POSITION_REAR_LEFT: return CHANNEL_RLS;
     case PA_CHANNEL_POSITION_REAR_CENTER: return CHANNEL_RCENTER;
     case PA_CHANNEL_POSITION_REAR_RIGHT: return CHANNEL_RRS;