--- a/chat/components/src/imAccounts.js
+++ b/chat/components/src/imAccounts.js
@@ -562,17 +562,17 @@ imAccount.prototype = {
     if (aPassword &&
         this._connectionErrorReason == Ci.imIAccount.ERROR_MISSING_PASSWORD)
       this._connectionErrorReason = Ci.imIAccount.NO_ERROR;
     else if (!aPassword && this._passwordRequired)
       this._connectionErrorReason = Ci.imIAccount.ERROR_MISSING_PASSWORD;
     this._sendUpdateNotification();
   },
   _handleMasterPasswordException: function(aException) {
-    if (aException.result != Components.results.NS_ERROR_ABORT)
+    if (aException.result != Cr.NS_ERROR_ABORT)
       throw aException;
 
     gUserCanceledMasterPasswordPrompt = true;
     executeSoon(function () { gUserCanceledMasterPasswordPrompt = false; });
   },
 
   get autoLogin() {
     let autoLogin = true;

--- a/chat/components/src/imContacts.js
+++ b/chat/components/src/imContacts.js
@@ -599,17 +599,17 @@ Contact.prototype = {
     return this._buddies.length == 0 ||
            this._buddies.every(b => b._empty);
   },
 
   mergeContact: function(aContact) {
     // Avoid merging the contact with itself or merging into an
     // already removed contact.
     if (aContact.id == this.id || !(this.id in ContactsById))
-      throw Components.results.NS_ERROR_INVALID_ARG;
+      throw Cr.NS_ERROR_INVALID_ARG;
 
     this._ensureNotDummy();
     let contact = ContactsById[aContact.id]; // remove XPConnect wrapper
 
     // Copy all the contact-only tags first, otherwise they would be lost.
     for (let tag of contact.getTags())
       if (!contact._isTagInherited(tag))
         this.addTag(tag);
@@ -638,17 +638,17 @@ Contact.prototype = {
     this._buddies.splice(newPosition, 0, buddy);
     this._updatePositions(Math.min(oldPosition, newPosition),
                           Math.max(oldPosition, newPosition));
     buddy._notifyObservers("position-changed", String(newPosition));
     this._updatePreferredBuddy(buddy);
   },
   adoptBuddy: function(aBuddy) {
     if (aBuddy.contact.id == this.id)
-      throw Components.results.NS_ERROR_INVALID_ARG;
+      throw Cr.NS_ERROR_INVALID_ARG;
 
     let buddy = BuddiesById[aBuddy.id]; // remove XPConnect wrapper
     buddy.contact = this;
     this._updatePreferredBuddy(buddy);
   },
   _massRemove: false,
   _removeBuddy: function(aBuddy) {
     if (this._buddies.length == 1) {
@@ -708,19 +708,19 @@ Contact.prototype = {
     }
     statement.finalize();
   },
 
   detachBuddy: function(aBuddy) {
     // Should return a new contact with the same list of tags.
     let buddy = BuddiesById[aBuddy.id];
     if (buddy.contact.id != this.id)
-      throw Components.results.NS_ERROR_INVALID_ARG;
+      throw Cr.NS_ERROR_INVALID_ARG;
     if (buddy.contact._buddies.length == 1)
-      throw Components.results.NS_ERROR_UNEXPECTED;
+      throw Cr.NS_ERROR_UNEXPECTED;
 
     // Save the list of tags, it may be destoyed if the buddy was the last one.
     let tags = buddy.contact.getTags();
 
     // Create a new dummy contact and use it for the detached buddy.
     buddy.contact = new Contact();
     buddy.contact._notifyObservers("added");
 
@@ -950,17 +950,17 @@ Buddy.prototype = {
   get protocol() { return this._accounts[0].account.protocol; },
   get userName() { return this._name; },
   get normalizedName() { return this._key; },
   _srvAlias: "",
   _contact: null,
   get contact() { return this._contact; },
   set contact(aContact) /* not in imIBuddy */ {
     if (aContact.id == this._contact.id)
-      throw Components.results.NS_ERROR_INVALID_ARG;
+      throw Cr.NS_ERROR_INVALID_ARG;
 
     this._notifyObservers("moved-out-of-contact");
     this._contact._removeBuddy(this);
 
     this._contact = aContact;
     this._contact._buddies.push(this);
 
     // Ensure all the inherited tags are in the new contact.

--- a/chat/components/src/logger.js
+++ b/chat/components/src/logger.js
@@ -214,18 +214,18 @@ LogWriter.prototype = {
   },
   _serialize: function cl_serialize(aString) {
     // TODO cleanup once bug 102699 is fixed
     let doc = getHiddenHTMLWindow().document;
     let div = doc.createElementNS("http://www.w3.org/1999/xhtml", "div");
     div.innerHTML = aString.replace(/\r?\n/g, "<br/>").replace(/<br>/gi, "<br/>");
     const type = "text/plain";
     let encoder =
-      Components.classes["@mozilla.org/layout/documentEncoder;1?type=" + type]
-                .createInstance(Components.interfaces.nsIDocumentEncoder);
+      Cc["@mozilla.org/layout/documentEncoder;1?type=" + type]
+        .createInstance(Ci.nsIDocumentEncoder);
     encoder.init(doc, type, 0);
     encoder.setContainerNode(div);
     encoder.setNodeFixup({fixupNode: function(aNode, aSerializeKids) {
       if (aNode.localName == "a" && aNode.hasAttribute("href")) {
         let url = aNode.getAttribute("href");
         let content = aNode.textContent;
         if (url != content)
           aNode.textContent = content + " (" + url + ")";

--- a/chat/content/browserRequest.js
+++ b/chat/content/browserRequest.js
@@ -1,15 +1,15 @@
 /* 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/. */
 
 ChromeUtils.import("resource:///modules/imServices.jsm");
 
-var wpl = Components.interfaces.nsIWebProgressListener;
+var wpl = Ci.nsIWebProgressListener;
 
 var reporterListener = {
   _isBusy: false,
   get statusMeter() {
     delete this.statusMeter;
     return this.statusMeter = document.getElementById("statusbar-icon");
   },
   get securityButton() {
@@ -21,21 +21,21 @@ var reporterListener = {
     return this.securityLabel = document.getElementById("security-status");
   },
   get securityDisplay() {
     delete this.securityDisplay;
     return this.securityDisplay = document.getElementById("security-display");
   },
 
   QueryInterface: function(aIID) {
-    if (aIID.equals(Components.interfaces.nsIWebProgressListener)   ||
-        aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
-        aIID.equals(Components.interfaces.nsISupports))
+    if (aIID.equals(Ci.nsIWebProgressListener)   ||
+        aIID.equals(Ci.nsISupportsWeakReference) ||
+        aIID.equals(Ci.nsISupports))
       return this;
-    throw Components.results.NS_NOINTERFACE;
+    throw Cr.NS_NOINTERFACE;
   },
   onStateChange: function(/*in nsIWebProgress*/ aWebProgress,
                      /*in nsIRequest*/ aRequest,
                      /*in unsigned long*/ aStateFlags,
                      /*in nsresult*/ aStatus) {
     if (aStateFlags & wpl.STATE_START &&
         aStateFlags & wpl.STATE_IS_NETWORK) {
       this.statusMeter.value = 0;
@@ -114,36 +114,36 @@ function cancelRequest()
 {
   reportUserClosed();
   window.close();
 }
 
 function reportUserClosed()
 {
   let request = window.arguments[0];
-  request.QueryInterface(Components.interfaces.prplIRequestBrowser);
+  request.QueryInterface(Ci.prplIRequestBrowser);
   request.cancelled();
 }
 
 function loadRequestedUrl()
 {
   let request = window.arguments[0];
-  request.QueryInterface(Components.interfaces.prplIRequestBrowser);
+  request.QueryInterface(Ci.prplIRequestBrowser);
   document.getElementById("headerMessage").textContent = request.promptText;
   let account = request.account;
   document.getElementById("headerLabel").value =
     account.protocol.name + " - " + account.name;
   document.getElementById("headerImage").src =
     account.protocol.iconBaseURI + "icon48.png";
 
   let browser = document.getElementById("requestFrame");
   browser.docShell.allowPlugins = false;
 
   if (Services.prefs.getBoolPref("chat.browserRequest.disableJavascript"))
     browser.docShell.allowJavascript = false;
 
   browser.addProgressListener(reporterListener,
-                              Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+                              Ci.nsIWebProgress.NOTIFY_ALL);
   let url = request.url;
   if (url != "")
     browser.setAttribute("src", url);
   request.loaded(window, browser.webProgress);
 }

--- a/chat/content/convbrowser.xml
+++ b/chat/content/convbrowser.xml
@@ -83,17 +83,17 @@
       <property name="docShell"
                 onget="return this._docShell || (this._docShell = this.boxObject.docShell);"
                 readonly="true"/>
 
       <property name="messageManager"
                 readonly="true">
         <getter>
           <![CDATA[
-            var owner = this.QueryInterface(Components.interfaces.nsIFrameLoaderOwner);
+            var owner = this.QueryInterface(Ci.nsIFrameLoaderOwner);
             if (!owner.frameLoader) {
               return null;
             }
             return owner.frameLoader.messageManager;
           ]]>
         </getter>
       </property>
 
@@ -125,18 +125,18 @@
         <![CDATA[
           if (!this._fastFind) {
             if (!("@mozilla.org/typeaheadfind;1" in Components.classes))
               return null;
 
             if (!this.docShell)
               return null;
 
-            this._fastFind = Components.classes["@mozilla.org/typeaheadfind;1"]
-                                       .createInstance(Components.interfaces.nsITypeAheadFind);
+            this._fastFind = Cc["@mozilla.org/typeaheadfind;1"]
+                               .createInstance(Ci.nsITypeAheadFind);
             this._fastFind.init(this.docShell);
           }
           return this._fastFind;
         ]]>
         </getter>
       </property>
 
       <field name="_lastSearchString">null</field>
@@ -195,30 +195,30 @@
       <method name="enableMagicCopy">
         <body>
           <![CDATA[
           this.contentWindow.controllers.insertControllerAt(0, this);
           this.autoCopyEnabled = Services.clipboard.supportsSelectionClipboard() &&
             Services.prefs.getBoolPref("clipboard.autocopy");
           if (this.autoCopyEnabled) {
             this.contentWindow.getSelection()
-                .QueryInterface(Components.interfaces.nsISelectionPrivate)
+                .QueryInterface(Ci.nsISelectionPrivate)
                 .addSelectionListener(this);
           }
           ]]>
         </body>
       </method>
 
       <method name="disableMagicCopy">
         <body>
           <![CDATA[
           this.contentWindow.controllers.removeController(this);
           if (this.autoCopyEnabled) {
              this.contentWindow.getSelection()
-                 .QueryInterface(Components.interfaces.nsISelectionPrivate)
+                 .QueryInterface(Ci.nsISelectionPrivate)
                  .removeSelectionListener(this);
           }
           ]]>
         </body>
       </method>
 
       <field name="autoCopyEnabled">false</field>
       <field name="magicCopyPref" readonly="true">"messenger.conversations.selections.magicCopyEnabled"</field>
@@ -252,17 +252,17 @@
           ]]>
         </body>
       </method>
 
       <method name="addProgressListener">
         <parameter name="aListener"/>
         <body>
           <![CDATA[
-            this.webProgress.addProgressListener(aListener, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+            this.webProgress.addProgressListener(aListener, Ci.nsIWebProgress.NOTIFY_ALL);
           ]]>
         </body>
       </method>
 
       <method name="removeProgressListener">
         <parameter name="aListener"/>
         <body>
           <![CDATA[
@@ -510,18 +510,18 @@
                 // Close any open bubble.
                 this._lastMessage = null;
               }
               // Suppress this message unless it was an error message.
               if (!aMsg.error)
                 return;
             }
 
-            let cs = Components.classes["@mozilla.org/txttohtmlconv;1"]
-                               .getService(Ci.mozITXTToHTMLConv);
+            let cs = Cc["@mozilla.org/txttohtmlconv;1"]
+                       .getService(Ci.mozITXTToHTMLConv);
             /*
              * kStructPhrase creates tags for plaintext-markup like *bold*,
              * /italics/, etc. We always use this; the content filter will
              * filter it out if the user does not want styling.
              */
             let csFlags = cs.kStructPhrase;
             // Automatically find and link freetext URLs
             if (!aMsg.noLinkification)
@@ -863,19 +863,19 @@
       <method name="doCommand">
         <parameter name="aCommand"/>
         <body>
           <![CDATA[
             let selection = this.contentWindow.getSelection();
             if (selection.isCollapsed)
               return;
 
-            Components.classes["@mozilla.org/widget/clipboardhelper;1"]
-                      .getService(Ci.nsIClipboardHelper)
-                      .copyString(serializeSelection(selection));
+            Cc["@mozilla.org/widget/clipboardhelper;1"]
+              .getService(Ci.nsIClipboardHelper)
+              .copyString(serializeSelection(selection));
           ]]>
         </body>
       </method>
 
       <method name="onEvent">
         <parameter name="aCommand"/>
       </method>
 
@@ -886,19 +886,19 @@
         <parameter name="aReason"/>
         <body>
           <![CDATA[
             if (!(aReason & Ci.nsISelectionListener.MOUSEUP_REASON   ||
                   aReason & Ci.nsISelectionListener.SELECTALL_REASON ||
                   aReason & Ci.nsISelectionListener.KEYPRESS_REASON))
               return; // we are still dragging, don't bother with the selection
 
-            Components.classes["@mozilla.org/widget/clipboardhelper;1"]
-                      .getService(Ci.nsIClipboardHelper)
-                      .copyStringToClipboard(serializeSelection(aSelection),
+            Cc["@mozilla.org/widget/clipboardhelper;1"]
+              .getService(Ci.nsIClipboardHelper)
+              .copyStringToClipboard(serializeSelection(aSelection),
                                              Ci.nsIClipboard.kSelectionClipboard);
           ]]>
         </body>
       </method>
 
       <method name="_exposeMethodsToContent">
         <body>
           <![CDATA[
@@ -913,24 +913,24 @@
       <!-- nsIWebProgressListener implementation -->
       <method name="onStateChange">
         <parameter name="aProgress"/>
         <parameter name="aRequest"/>
         <parameter name="aStateFlags"/>
         <parameter name="aStatus"/>
         <body>
           <![CDATA[
-            const WPL = Components.interfaces.nsIWebProgressListener;
+            const WPL = Ci.nsIWebProgressListener;
             if ((aStateFlags & WPL.STATE_IS_DOCUMENT) &&
                 (aStateFlags & WPL.STATE_STOP)) {
               if (!this._loadState) {
                 try {
                   initHTMLDocument(this._conv, this.theme, this.contentDocument);
                 } catch(e) {
-                  Components.utils.reportError(e);
+                  Cu.reportError(e);
                 }
                 this._loadState = 1;
 
                 this._exposeMethodsToContent();
 
                 // A common use case is to click somewhere in the conversation and
                 // start typing a command (often /me). If quick find is enabled, it
                 // will pick up the "/" keypress and open the findbar. See bug 1161930.
@@ -1240,17 +1240,17 @@
                               "_firstNonContextElt"];
 
           var ourFieldValues = {};
           var otherFieldValues = {};
           for (var field of fieldsToSwap) {
             ourFieldValues[field] = this[field];
             otherFieldValues[field] = aOtherBrowser[field];
           }
-          this.QueryInterface(Components.interfaces.nsIFrameLoaderOwner)
+          this.QueryInterface(Ci.nsIFrameLoaderOwner)
               .swapFrameLoaders(aOtherBrowser);
           for (var field of fieldsToSwap) {
             this[field] = otherFieldValues[field];
             aOtherBrowser[field] = ourFieldValues[field];
           }
 
           this._exposeMethodsToContent();
 
@@ -1290,19 +1290,19 @@
             // allowed by our IM filters and exposed.
             if (!uri.schemeIs("http") && !uri.schemeIs("https"))
               return;
 
             event.preventDefault();
             event.stopPropagation();
 
             // loadURI can throw if the default browser is misconfigured.
-            Components.classes["@mozilla.org/uriloader/external-protocol-service;1"]
-                      .getService(Components.interfaces.nsIExternalProtocolService)
-                      .loadURI(uri);
+            Cc["@mozilla.org/uriloader/external-protocol-service;1"]
+              .getService(Ci.nsIExternalProtocolService)
+              .loadURI(uri);
           }
         ]]>
       </handler>
 
       <handler event="keypress" modifiers="shift" keycode="VK_PAGE_UP"
                action="this.docShell.QueryInterface(Components.interfaces.nsITextScroll).scrollByPages(-1);"/>
 
       <handler event="keypress" modifiers="shift" keycode="VK_PAGE_DOWN"

--- a/chat/modules/imContentSink.jsm
+++ b/chat/modules/imContentSink.jsm
@@ -250,18 +250,18 @@ function cleanupNode(aNode, aRules, aTex
   for (let i = 0; i < aNode.childNodes.length; ++i) {
     let node = aNode.childNodes[i];
     if (node.nodeType == node.ELEMENT_NODE &&
         node.namespaceURI == "http://www.w3.org/1999/xhtml") {
       // check if node allowed
       let nodeName = node.localName;
       if (!(nodeName in aRules.tags)) {
         if (nodeName in kForbiddenTags) {
-          Components.utils.reportError("removing a " + nodeName +
-                                       " tag from a message before display");
+          Cu.reportError("removing a " + nodeName +
+                         " tag from a message before display");
         }
         else {
           // this node is not allowed, replace it with its children
           while (node.hasChildNodes())
             aNode.insertBefore(node.removeChild(node.firstChild), node);
         }
         aNode.removeChild(node);
         // We want to process again the node at the index i which is
@@ -335,17 +335,17 @@ function cleanupNode(aNode, aRules, aTex
       let textNodeCount = 1;
       for (let modifier of aTextModifiers)
         for (let n = 0; n < textNodeCount; ++n) {
           let textNode = aNode.childNodes[i + n];
 
           // If we are processing nodes created by one of the previous
           // text modifier function, some of the nodes are likely not
           // text node, skip them.
-          if (!(textNode instanceof Components.interfaces.nsIDOMText))
+          if (!(textNode instanceof Ci.nsIDOMText))
             continue;
 
           let result = modifier(textNode);
           textNodeCount += result;
           n += result;
         }
 
       // newly created nodes should not be filtered, be sure we skip them!
@@ -354,16 +354,16 @@ function cleanupNode(aNode, aRules, aTex
   }
 }
 
 function cleanupImMarkup(aText, aRuleset, aTextModifiers = [])
 {
   if (!gGlobalRuleset)
     initGlobalRuleset();
 
-  let parser = Components.classes["@mozilla.org/xmlextras/domparser;1"]
-                         .createInstance(Components.interfaces.nsIDOMParser);
+  let parser = Cc["@mozilla.org/xmlextras/domparser;1"]
+                 .createInstance(Ci.nsIDOMParser);
   // Wrap the text to be parsed in a <span> to avoid losing leading whitespace.
   let doc = parser.parseFromString("<span>" + aText + "</span>", "text/html");
   let span = doc.querySelector("span");
   cleanupNode(span, aRuleset || gGlobalRuleset, aTextModifiers);
   return span.innerHTML;
 }

--- a/chat/modules/imSmileys.jsm
+++ b/chat/modules/imSmileys.jsm
@@ -44,19 +44,19 @@ var gPrefObserver = {
       throw "bad notification";
 
     gTheme = getTheme();
   }
 };
 
 function getSmileRealURI(aSmile)
 {
-  aSmile = Components.classes["@mozilla.org/intl/texttosuburi;1"]
-                     .getService(Components.interfaces.nsITextToSubURI)
-                     .unEscapeURIForUI("UTF-8", aSmile);
+  aSmile = Cc["@mozilla.org/intl/texttosuburi;1"]
+             .getService(Ci.nsITextToSubURI)
+             .unEscapeURIForUI("UTF-8", aSmile);
   if (aSmile in gTheme.iconsHash)
     return gTheme.baseUri + gTheme.iconsHash[aSmile].filename;
 
   throw "Invalid smile!";
 }
 
 function getSmileyList(aThemeName)
 {
@@ -89,48 +89,48 @@ function getTheme(aName)
   if (name == "default")
     theme.baseUri = "chrome://instantbird-emoticons/skin/";
   else
     theme.baseUri = "chrome://" + theme.name + "/skin/";
   try {
     let channel = Services.io.newChannel2(theme.baseUri + kThemeFile, null, null, null,
                                           Services.scriptSecurityManager.getSystemPrincipal(),
                                           null,
-                                          Components.interfaces.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
-                                          Components.interfaces.nsIContentPolicy.TYPE_IMAGE);
+                                          Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+                                          Ci.nsIContentPolicy.TYPE_IMAGE);
     let stream = channel.open();
     let bytes = NetUtil.readInputStream(stream, stream.available());
     theme.json = JSON.parse(gTextDecoder.decode(bytes));
     stream.close();
     theme.iconsHash = {};
     for (let smiley of theme.json.smileys) {
       for (let textCode of smiley.textCodes)
         theme.iconsHash[textCode] = smiley;
     }
   } catch(e) {
-    Components.utils.reportError(e);
+    Cu.reportError(e);
   }
   return theme;
 }
 
 function getRegexp()
 {
   if (gTheme.regExp) {
     gTheme.regExp.lastIndex = 0;
     return gTheme.regExp;
   }
 
   // return null if smileys are disabled
   if (!gTheme.iconsHash)
     return null;
 
   if ("" in gTheme.iconsHash) {
-    Components.utils.reportError("Emoticon " +
-                                 gTheme.iconsHash[""].filename +
-                                 " matches the empty string!");
+    Cu.reportError("Emoticon " +
+                   gTheme.iconsHash[""].filename +
+                   " matches the empty string!");
     delete gTheme.iconsHash[""];
   }
 
   let emoticonList = [];
   for (let emoticon in gTheme.iconsHash)
     emoticonList.push(emoticon);
 
   let exp = /[[\]{}()*+?.\\^$|]/g;
@@ -205,17 +205,17 @@ function smileTextNode(aNode)
 function smileNode(aNode)
 {
   for (let i = 0; i < aNode.childNodes.length; ++i) {
     let node = aNode.childNodes[i];
     if (node.nodeType == node.ELEMENT_NODE &&
         node.namespaceURI == "http://www.w3.org/1999/xhtml") {
       // we are on a tag, recurse to process its children
       smileNode(node);
-    } else if (node instanceof Components.interfaces.nsIDOMText) {
+    } else if (node instanceof Ci.nsIDOMText) {
       // we are on a text node, process it
       smileTextNode(node);
     }
   }
 }
 
 function smileImMarkup(aDocument, aText)
 {

--- a/chat/modules/imThemes.jsm
+++ b/chat/modules/imThemes.jsm
@@ -48,24 +48,24 @@ function getChromeFile(aURI)
 {
   try {
     let channel = Services.io.newChannel2(aURI, null, null, null,
                                           Services.scriptSecurityManager.getSystemPrincipal(),
                                           null,
                                           Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
                                           Ci.nsIContentPolicy.TYPE_OTHER);
     let stream = channel.open();
-    let sstream = Components.classes["@mozilla.org/scriptableinputstream;1"]
-                            .createInstance(Ci.nsIScriptableInputStream);
+    let sstream = Cc["@mozilla.org/scriptableinputstream;1"]
+                    .createInstance(Ci.nsIScriptableInputStream);
     sstream.init(stream);
     let text = sstream.read(sstream.available());
     sstream.close();
     return text;
   } catch (e) {
-    if (e.result != Components.results.NS_ERROR_FILE_NOT_FOUND)
+    if (e.result != Cr.NS_ERROR_FILE_NOT_FOUND)
       dump("Getting " + aURI + ": " + e + "\n");
     return null;
   }
 }
 
 function HTMLTheme(aBaseURI)
 {
   let files = {
@@ -157,29 +157,29 @@ function getInfoPlistContent(aBaseURI)
 {
   try {
     let channel = Services.io.newChannel2(aBaseURI + "Info.plist", null, null, null,
                                           Services.scriptSecurityManager.getSystemPrincipal(),
                                           null,
                                           Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
                                           Ci.nsIContentPolicy.TYPE_OTHER);
     let stream = channel.open();
-    let parser = Components.classes["@mozilla.org/xmlextras/domparser;1"]
-                           .createInstance(Ci.nsIDOMParser);
+    let parser = Cc["@mozilla.org/xmlextras/domparser;1"]
+                   .createInstance(Ci.nsIDOMParser);
     let doc = parser.parseFromStream(stream, null, stream.available(), "text/xml");
     if (doc.documentElement.localName != "plist")
       throw "Invalid Info.plist file";
     let node = doc.documentElement.firstChild;
     while (node && !(node instanceof Ci.nsIDOMElement))
       node = node.nextSibling;
     if (!node || node.localName != "dict")
       throw "Empty or invalid Info.plist file";
     return plistToJSON(node);
   } catch(e) {
-    Components.utils.reportError(e);
+    Cu.reportError(e);
     return null;
   }
 }
 
 function getChromeBaseURI(aThemeName)
 {
   if (DEFAULT_THEMES.includes(aThemeName))
     return "chrome://messenger-messagestyles/skin/" + aThemeName + "/";
@@ -212,50 +212,50 @@ function getCurrentTheme()
   if (gCurrentTheme && gCurrentTheme.name == name &&
       gCurrentTheme.variant == variant)
     return gCurrentTheme;
 
   try {
     gCurrentTheme = getThemeByName(name);
     gCurrentTheme.variant = variant;
   } catch(e) {
-    Components.utils.reportError(e);
+    Cu.reportError(e);
     gCurrentTheme = getThemeByName(DEFAULT_THEME);
     gCurrentTheme.variant = "default";
   }
 
   return gCurrentTheme;
 }
 
 function getDirectoryEntries(aDir)
 {
   let ios = Services.io;
   let uri = ios.newURI(aDir);
-  let cr = Components.classes["@mozilla.org/chrome/chrome-registry;1"]
-                     .getService(Ci.nsIXULChromeRegistry);
+  let cr = Cc["@mozilla.org/chrome/chrome-registry;1"]
+             .getService(Ci.nsIXULChromeRegistry);
   while (uri.scheme == "chrome")
     uri = cr.convertChromeURL(uri);
 
   // remove any trailing file name added by convertChromeURL
   let spec = uri.spec.replace(/[^\/]+$/, "");
   uri = ios.newURI(spec);
 
   let results = [];
   if (uri.scheme == "jar") {
     uri.QueryInterface(Ci.nsIJARURI);
     let strEntry = uri.JAREntry;
     if (!strEntry)
       return [];
 
-    let zr = Components.classes["@mozilla.org/libjar/zip-reader;1"]
-                       .createInstance(Ci.nsIZipReader);
+    let zr = Cc["@mozilla.org/libjar/zip-reader;1"]
+               .createInstance(Ci.nsIZipReader);
     let jarFile = uri.JARFile;
     if (jarFile instanceof Ci.nsIJARURI) {
-      let innerZr = Components.classes["@mozilla.org/libjar/zip-reader;1"]
-                              .createInstance(Ci.nsIZipReader);
+      let innerZr = Cc["@mozilla.org/libjar/zip-reader;1"]
+                      .createInstance(Ci.nsIZipReader);
       innerZr.open(jarFile.JARFile.QueryInterface(Ci.nsIFileURL).file);
       zr.openInner(innerZr, jarFile.JAREntry);
     }
     else
       zr.open(jarFile.QueryInterface(Ci.nsIFileURL).file);
 
     if (!zr.hasEntry(strEntry) || !zr.getEntry(strEntry).isDirectory) {
       zr.close();
@@ -461,18 +461,18 @@ function replaceKeywordsInHTML(aHTML, aR
   let previousIndex = 0;
   let result = "";
   let match;
   while ((match = kReplacementRegExp.exec(aHTML))) {
     let content = "";
     if (match[1] in aReplacements)
       content = aReplacements[match[1]](aReplacementArg, match[3]);
     else
-      Components.utils.reportError("Unknown replacement string %" +
-                                   match[1] + "% in message styles.");
+      Cu.reportError("Unknown replacement string %" +
+                     match[1] + "% in message styles.");
     result += aHTML.substring(previousIndex, match.index) + content;
     previousIndex = kReplacementRegExp.lastIndex;
   }
 
   return result + aHTML.slice(previousIndex);
 }
 
 function isNextMessage(aTheme, aMsg, aPreviousMsg)
@@ -652,18 +652,18 @@ function getEllipsis()
 
 function _serializeDOMObject(aDocument, aInitFunction)
 {
   // This shouldn't really be a constant, as we want to support
   // text/html too in the future.
   const type = "text/plain";
 
   let encoder =
-    Components.classes["@mozilla.org/layout/documentEncoder;1?type=" + type]
-              .createInstance(Ci.nsIDocumentEncoder);
+    Cc["@mozilla.org/layout/documentEncoder;1?type=" + type]
+      .createInstance(Ci.nsIDocumentEncoder);
   encoder.init(aDocument, type, Ci.nsIDocumentEncoder.OutputPreformatted);
   aInitFunction(encoder);
   let result = encoder.encodeToString();
   return result;
 }
 
 function serializeRange(aRange)
 {

--- a/chat/protocols/jsTest/jsTestProtocol.js
+++ b/chat/protocols/jsTest/jsTestProtocol.js
@@ -45,17 +45,17 @@ Account.prototype = {
     this.reportConnected();
     setTimeout((function() {
       this._conv = new Conversation(this);
       this._conv.writeMessage("jstest", "You are now talking to /dev/null", {system: true});
     }).bind(this), 0);
   },
   _conv: null,
   disconnect: function(aSilent) {
-    this.reportDisconnecting(Components.interfaces.prplIAccount.NO_ERROR, "");
+    this.reportDisconnecting(Ci.prplIAccount.NO_ERROR, "");
     if (!aSilent)
       this._conv.writeMessage("jstest", "You have disconnected.", {system: true});
     if (this._conv) {
       this._conv._setDisconnected();
       delete this._conv;
     }
     this.reportDisconnected();
   },

--- a/common/bindings/preferences.xml
+++ b/common/bindings/preferences.xml
@@ -70,17 +70,17 @@
         <body>
         <![CDATA[
           // Value changed, synthesize an event
           try {
             var event = document.createEvent("Events");
             event.initEvent("change", true, true);
             aPreference.dispatchEvent(event);
           } catch (e) {
-            Components.utils.reportError(e);
+            Cu.reportError(e);
           }
         ]]>
         </body>
       </method>
 
       <field name="service">
         Components.classes["@mozilla.org/preferences-service;1"]
                   .getService(Components.interfaces.nsIPrefService);
@@ -144,18 +144,18 @@
           return;
 
         this.preferences.rootBranchInternal
             .addObserver(this.name, this.preferences);
         // In non-instant apply mode, we must try and use the last saved state
         // from any previous opens of a child dialog instead of the value from
         // preferences, to pick up any edits a user may have made.
 
-        var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
-                    .getService(Components.interfaces.nsIScriptSecurityManager);
+        var secMan = Cc["@mozilla.org/scriptsecuritymanager;1"]
+                    .getService(Ci.nsIScriptSecurityManager);
         if (this.preferences.type == "child" &&
             !this.instantApply && window.opener &&
             secMan.isSystemPrincipal(window.opener.document.nodePrincipal)) {
           var pdoc = window.opener.document;
 
           // Try to find a preference element for the same preference.
           var preference = null;
           var parentPreferences = pdoc.getElementsByTagName("preferences");
@@ -335,18 +335,18 @@
         </getter>
       </property>
 
       <field name="batching">false</field>
 
       <method name="_reportUnknownType">
         <body>
         <![CDATA[
-          var consoleService = Components.classes["@mozilla.org/consoleservice;1"]
-                                         .getService(Components.interfaces.nsIConsoleService);
+          var consoleService = Cc["@mozilla.org/consoleservice;1"]
+                                 .getService(Ci.nsIConsoleService);
           var msg = "<preference> with id='" + this.id + "' and name='" +
                     this.name + "' has unknown type '" + this.type + "'.";
           consoleService.logStringMessage(msg);
         ]]>
         </body>
       </method>
 
       <property name="valueFromPreferences">
@@ -357,29 +357,29 @@
             switch (this.type) {
             case "int":
               return this._branch.getIntPref(this.name);
             case "bool":
               var val = this._branch.getBoolPref(this.name);
               return this.inverted ? !val : val;
             case "wstring":
               return this._branch
-                         .getComplexValue(this.name, Components.interfaces.nsIPrefLocalizedString)
+                         .getComplexValue(this.name, Ci.nsIPrefLocalizedString)
                          .data;
             case "string":
             case "unichar":
               return this._branch.getStringPref(this.name);
             case "fontname":
               var family = this._branch.getStringPref(this.name);
-              var fontEnumerator = Components.classes["@mozilla.org/gfx/fontenumerator;1"]
-                                             .createInstance(Components.interfaces.nsIFontEnumerator);
+              var fontEnumerator = Cc["@mozilla.org/gfx/fontenumerator;1"]
+                                     .createInstance(Ci.nsIFontEnumerator);
               return fontEnumerator.getStandardFamilyName(family);
             case "file":
               var f = this._branch
-                          .getComplexValue(this.name, Components.interfaces.nsIFile);
+                          .getComplexValue(this.name, Ci.nsIFile);
               return f;
             default:
               this._reportUnknownType();
             }
           } catch (e) { }
           return null;
         ]]>
         </getter>
@@ -399,39 +399,39 @@
           switch (this.type) {
           case "int":
             this.preferences.rootBranch.setIntPref(this.name, val);
             break;
           case "bool":
             this.preferences.rootBranch.setBoolPref(this.name, this.inverted ? !val : val);
             break;
           case "wstring":
-            var pls = Components.classes["@mozilla.org/pref-localizedstring;1"]
-                                .createInstance(Components.interfaces.nsIPrefLocalizedString);
+            var pls = Cc["@mozilla.org/pref-localizedstring;1"]
+                        .createInstance(Ci.nsIPrefLocalizedString);
             pls.data = val;
             this.preferences.rootBranch
-                .setComplexValue(this.name, Components.interfaces.nsIPrefLocalizedString, pls);
+                .setComplexValue(this.name, Ci.nsIPrefLocalizedString, pls);
             break;
           case "string":
           case "unichar":
           case "fontname":
             this.preferences.rootBranch.setStringPref(this.name, val);
             break;
           case "file":
             var lf;
             if (typeof(val) == "string") {
-              lf = Components.classes["@mozilla.org/file/local;1"]
-                             .createInstance(Components.interfaces.nsIFile);
+              lf = Cc["@mozilla.org/file/local;1"]
+                     .createInstance(Ci.nsIFile);
               lf.persistentDescriptor = val;
               if (!lf.exists())
                 lf.initWithPath(val);
             } else
-              lf = val.QueryInterface(Components.interfaces.nsIFile);
+              lf = val.QueryInterface(Ci.nsIFile);
             this.preferences.rootBranch
-                .setComplexValue(this.name, Components.interfaces.nsIFile, lf);
+                .setComplexValue(this.name, Ci.nsIFile, lf);
             break;
           default:
             this._reportUnknownType();
           }
           if (!this.batching)
             this.preferences.service.savePrefFile(null);
           return val;
         ]]>
@@ -453,17 +453,17 @@
             // Value changed, synthesize an event
             try {
               var event = document.createEvent("Events");
               event.initEvent("syncfrompreference", true, true);
               var f = new Function("event",
                                    aElement.getAttribute("onsyncfrompreference"));
               rv = f.call(aElement, event);
             } catch (e) {
-              Components.utils.reportError(e);
+              Cu.reportError(e);
             }
           }
           var val = rv;
           if (val === undefined)
             val = this.instantApply ? this.valueFromPreferences : this.value;
           // if the preference is marked for reset, show default value in UI
           if (val === undefined)
             val = this.defaultValue;
@@ -508,17 +508,17 @@
               var event = document.createEvent("Events");
               event.initEvent("synctopreference", true, true);
               var f = new Function("event",
                                    aElement.getAttribute("onsynctopreference"));
               var rv = f.call(aElement, event);
               if (rv !== undefined)
                 return rv;
             } catch (e) {
-              Components.utils.reportError(e);
+              Cu.reportError(e);
             }
           }
 
           /**
            * Read the value of an attribute from an element, assuming the
            * attribute is a property on the element's node API. If the property
            * is not present in the API, then assume its value is contained in
            * an attribute, as is the case before a binding has been attached.
@@ -635,18 +635,18 @@
         <children/>
       </xul:hbox>
     </content>
     <implementation implements="nsITimerCallback">
       <constructor>
       <![CDATA[
         if (this.type != "child") {
           if (!this._instantApplyInitialized) {
-            let psvc = Components.classes["@mozilla.org/preferences-service;1"]
-                                 .getService(Components.interfaces.nsIPrefBranch);
+            let psvc = Cc["@mozilla.org/preferences-service;1"]
+                         .getService(Ci.nsIPrefBranch);
             this.instantApply = psvc.getBoolPref("browser.preferences.instantApply");
           }
           if (this.instantApply) {
             var docElt = document.documentElement;
             var acceptButton = docElt.getButton("accept");
             acceptButton.hidden = true;
             var cancelButton  = docElt.getButton("cancel");
             if (/Mac/.test(navigator.platform)) {
@@ -809,17 +809,17 @@
             if (aTarget.hasAttribute("on" + aEventName)) {
               var fn = new Function("event", aTarget.getAttribute("on" + aEventName));
               var rv = fn.call(aTarget, event);
               if (!rv)
                 cancel = true;
             }
             return !cancel;
           } catch (e) {
-            Components.utils.reportError(e);
+            Cu.reportError(e);
           }
           return false;
         ]]>
         </body>
       </method>
 
       <field name="_initialized">false</field>
       <method name="_selectPane">
@@ -894,18 +894,18 @@
           }
         ]]>
         </body>
       </method>
 
       <property name="_shouldAnimate">
         <getter>
         <![CDATA[
-          var psvc = Components.classes["@mozilla.org/preferences-service;1"]
-                               .getService(Components.interfaces.nsIPrefBranch);
+          var psvc = Cc["@mozilla.org/preferences-service;1"]
+                       .getService(Ci.nsIPrefBranch);
           return psvc.getBoolPref("browser.preferences.animateFadeIn",
                                   /Mac/.test(navigator.platform));
         ]]>
         </getter>
       </property>
 
       <method name="animate">
         <parameter name="aOldPane"/>
@@ -972,39 +972,39 @@
         </body>
       </method>
 
       <method name="_setUpAnimationTimer">
         <parameter name="aStartHeight"/>
         <body>
         <![CDATA[
           if (!this._animateTimer)
-            this._animateTimer = Components.classes["@mozilla.org/timer;1"]
-                                           .createInstance(Components.interfaces.nsITimer);
+            this._animateTimer = Cc["@mozilla.org/timer;1"]
+                                   .createInstance(Ci.nsITimer);
           else
             this._animateTimer.cancel();
           this._currentHeight = aStartHeight;
 
           this._animateTimer.initWithCallback(this, this._animateDelay,
-                                              Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
+                                              Ci.nsITimer.TYPE_REPEATING_SLACK);
         ]]>
         </body>
       </method>
 
       <method name="_setUpFadeTimer">
         <body>
         <![CDATA[
           if (!this._fadeTimer)
-            this._fadeTimer = Components.classes["@mozilla.org/timer;1"]
-                                        .createInstance(Components.interfaces.nsITimer);
+            this._fadeTimer = Cc["@mozilla.org/timer;1"]
+                                .createInstance(Ci.nsITimer);
           else
             this._fadeTimer.cancel();
 
           this._fadeTimer.initWithCallback(this, this._fadeDelay,
-                                           Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
+                                           Ci.nsITimer.TYPE_REPEATING_SLACK);
         ]]>
         </body>
       </method>
 
       <field name="_animateTimer">null</field>
       <field name="_fadeTimer">null</field>
       <field name="_animateDelay">15</field>
       <field name="_animateIncrement">40</field>
@@ -1037,18 +1037,18 @@
 
       <method name="openWindow">
         <parameter name="aWindowType"/>
         <parameter name="aURL"/>
         <parameter name="aFeatures"/>
         <parameter name="aParams"/>
         <body>
         <![CDATA[
-          var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
-                             .getService(Components.interfaces.nsIWindowMediator);
+          var wm = Cc["@mozilla.org/appshell/window-mediator;1"]
+                     .getService(Ci.nsIWindowMediator);
           var win = aWindowType ? wm.getMostRecentWindow(aWindowType) : null;
           if (win) {
             if ("initWithParams" in win)
               win.initWithParams(aParams);
             win.focus();
           } else {
             var features = "resizable,dialog=no,centerscreen" + (aFeatures != "" ? ("," + aFeatures) : "");
             var parentWindow = (this.instantApply || !window.opener || window.opener.closed) ? window : window.opener;
@@ -1061,18 +1061,18 @@
     </implementation>
     <handlers>
       <handler event="dialogaccept">
       <![CDATA[
         if (!this._fireEvent("beforeaccept", this)) {
           return false;
         }
 
-        var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
-                    .getService(Components.interfaces.nsIScriptSecurityManager);
+        var secMan = Cc["@mozilla.org/scriptsecuritymanager;1"]
+                    .getService(Ci.nsIScriptSecurityManager);
         if (this.type == "child" && window.opener &&
             secMan.isSystemPrincipal(window.opener.document.nodePrincipal)) {
           var pdocEl = window.opener.document.documentElement;
           if (pdocEl.instantApply) {
             let panes = this.preferencePanes;
             for (let i = 0; i < panes.length; ++i)
               panes[i].writePreferences(true);
           } else {
@@ -1118,18 +1118,18 @@
               }
             }
           }
         } else {
           let panes = this.preferencePanes;
           for (var i = 0; i < panes.length; ++i)
             panes[i].writePreferences(false);
 
-          let psvc = Components.classes["@mozilla.org/preferences-service;1"]
-                               .getService(Components.interfaces.nsIPrefService);
+          let psvc = Cc["@mozilla.org/preferences-service;1"]
+                       .getService(Ci.nsIPrefService);
           psvc.savePrefFile(null);
         }
 
         return true;
       ]]>
       </handler>
       <handler event="command">
         if (event.originalTarget.hasAttribute("pane")) {
@@ -1188,18 +1188,18 @@
           var preferences = this.preferences;
           for (var i = 0; i < preferences.length; ++i) {
             var preference = preferences[i];
             preference.batching = true;
             preference.valueFromPreferences = preference.value;
             preference.batching = false;
           }
           if (aFlushToDisk) {
-            var psvc = Components.classes["@mozilla.org/preferences-service;1"]
-                                 .getService(Components.interfaces.nsIPrefService);
+            var psvc = Cc["@mozilla.org/preferences-service;1"]
+                         .getService(Ci.nsIPrefService);
             psvc.savePrefFile(null);
           }
         ]]>
         </body>
       </method>
 
       <property name="src"
                 onget="return this.getAttribute('src');"