Add m-esr52 at 52.6.0

7 files changed, 2290 insertions, 0 deletions

diff --git a/netwerk/mime/moz.build b/netwerk/mime/moz.build
new file mode 100644
index 000000000..11ea2c4ea
--- /dev/null
+++ b/netwerk/mime/moz.build
@@ -0,0 +1,26 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPIDL_SOURCES += [
+    'nsIMIMEHeaderParam.idl',
+    'nsIMIMEInfo.idl',
+    'nsIMIMEService.idl',
+]
+
+XPIDL_MODULE = 'mimetype'
+
+EXPORTS += [
+    'nsMimeTypes.h',
+]
+
+SOURCES += [
+    'nsMIMEHeaderParamImpl.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
+
+if CONFIG['GNU_CXX']:
+    CXXFLAGS += ['-Wno-error=shadow']
diff --git a/netwerk/mime/nsIMIMEHeaderParam.idl b/netwerk/mime/nsIMIMEHeaderParam.idl
new file mode 100644
index 000000000..ffe8403d6
--- /dev/null
+++ b/netwerk/mime/nsIMIMEHeaderParam.idl
@@ -0,0 +1,207 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+/*
+ * This interface allows any module to access the routine 
+ * for MIME header parameter parsing (RFC 2231/5987)
+ */
+
+#include "nsISupports.idl"
+
+[scriptable, uuid(9c9252a1-fdaf-40a2-9c2b-a3dc45e28dde)]
+interface nsIMIMEHeaderParam : nsISupports {
+
+  /** 
+   * Given the value of a single header field  (such as
+   * Content-Disposition and Content-Type) and the name of a parameter
+   * (e.g. filename, name, charset), returns the value of the parameter.
+   * The value is obtained by decoding RFC 2231/5987-style encoding,
+   * RFC 2047-style encoding, and converting to UniChar(UTF-16)
+   * from charset specified in RFC 2231/2047 encoding, UTF-8, 
+   * <code>aFallbackCharset</code>, the locale charset as fallback if
+   * <code>TryLocaleCharset</code> is set, and null-padding as last resort
+   * if all else fails.
+   *
+   * <p> 
+   * This method internally invokes <code>getParameterInternal</code>, 
+   * However, it does not stop at decoding RFC 2231 (the task for
+   * <code>getParameterInternal</code> but tries to cope
+   * with several non-standard-compliant cases mentioned below.
+   *
+   * <p>
+   * Note that a lot of MUAs put RFC 2047-encoded parameters. Unfortunately,
+   * this includes Mozilla as of 2003-05-30. Even more standard-ignorant MUAs,
+   * web servers and application servers put 'raw 8bit characters'. This will
+   * try to cope with all these cases as gracefully as possible. Additionally,
+   * it returns the language tag if the parameter is encoded per RFC 2231 and 
+   * includes lang.
+   *
+   * <p>
+   * Note that GetParameterHTTP skips some of the workarounds used for
+   * mail (MIME) header fields, and thus SHOULD be used from non-mail
+   * code.
+   *
+   *
+   * @param  aHeaderVal        a header string to get the value of a parameter 
+   *                           from.
+   * @param  aParamName        the name of a MIME header parameter (e.g. 
+   *                           filename, name, charset). If empty,  returns 
+   *                           the first (possibly) _unnamed_ 'parameter'.
+   * @param  aFallbackCharset  fallback charset to try if  the string after
+   *                           RFC 2231/2047 decoding or the raw 8bit 
+   *                           string is not UTF-8
+   * @param  aTryLocaleCharset If set, makes yet another attempt 
+   *                           with the locale charset.
+   * @param  aLang             If non-null, assigns it to a pointer 
+   *                           to a string containing the value of language 
+   *                           obtained from RFC 2231 parsing. Caller has to 
+   *                           free it.
+   * @return the value of <code>aParamName</code> in Unichar(UTF-16).
+   */
+  AString getParameter(in ACString aHeaderVal,
+                       in string aParamName,
+                       in ACString aFallbackCharset,
+                       in boolean aTryLocaleCharset, 
+                       out string aLang);
+
+
+  /**
+   * Like getParameter, but disabling encodings and workarounds specific to
+   * MIME (as opposed to HTTP).
+   */
+  AString getParameterHTTP(in ACString aHeaderVal,
+                           in string aParamName,
+                           in ACString aFallbackCharset,
+                           in boolean aTryLocaleCharset, 
+                           out string aLang);
+
+  /** 
+   * Given the value of a header field parameter using the encoding
+   * defined in RFC 5987, decode the value into a Unicode string, and extract
+   * the optional language parameter.
+   *
+   * <p> 
+   * This function is purposefully picky; it will abort for all (most?)
+   * invalid inputs. This is by design. In particular, it does not support
+   * any character encodings other than UTF-8, in order not to promote
+   * non-interoperable usage.
+   *
+   * <p>
+   * Code that parses HTTP header fields (as opposed to MIME header fields)
+   * should use this function.
+   *
+   * @param  aParamVal         a header field parameter to decode.
+   * @param  aLang             will be set to the language part (possibly
+   *                           empty).
+   * @return the decoded parameter value.
+   */
+  AString decodeRFC5987Param(in ACString aParamVal, 
+                             out ACString aLang);
+
+  /** 
+   * Given the value of a single header field  (such as
+   * Content-Disposition and Content-Type) and the name of a parameter
+   * (e.g. filename, name, charset), returns the value of the parameter 
+   * after decoding RFC 2231-style encoding. 
+   * <p>
+   * For <strong>internal use only</strong>. The only other place where 
+   * this needs to be  invoked  is  |MimeHeaders_get_parameter| in 
+   * mailnews/mime/src/mimehdrs.cpp defined as 
+   * char * MimeHeaders_get_parameter (const char *header_value, 
+   *                                   const char *parm_name,
+   *                                   char **charset, char **language)
+   *
+   * Otherwise, this method would have been made static.
+   *
+   * @param  aHeaderVal  a header string to get the value of a parameter from.
+   * @param  aParamName  the name of a MIME header parameter (e.g. 
+   *                     filename, name, charset). If empty,  returns 
+   *                     the first (possibly) _unnamed_ 'parameter'.
+   * @param  aCharset    If non-null, it gets assigned a new pointer
+   *                     to a string containing the value of charset obtained
+   *                     from RFC 2231 parsing. Caller has to free it.
+   * @param  aLang       If non-null, it gets assigned a new pointer
+   *                     to a string containing the value of language obtained
+   *                     from RFC 2231 parsing. Caller has to free it.
+   * @return             the value of <code>aParamName</code> after
+   *                     RFC 2231 decoding but without charset conversion.
+   */
+
+  [noscript]
+  string getParameterInternal(in string aHeaderVal,
+                              in string aParamName,
+                              out string aCharset,
+                              out string aLang);
+
+
+  /** 
+   * Given a header value, decodes RFC 2047-style encoding and
+   * returns the decoded header value in UTF-8 if either it's
+   * RFC-2047-encoded or aDefaultCharset is given. Otherwise,
+   * returns the input header value (in whatever encoding) 
+   * as it is except that  RFC 822 (using backslash) quotation and 
+   * CRLF (if aEatContinuation is set) are stripped away
+   * <p>
+   * For internal use only. The only other place where this needs to be 
+   * invoked  is  <code>MIME_DecodeMimeHeader</code> in 
+   * mailnews/mime/src/mimehdrs.cpp defined as
+   * char * Mime_DecodeMimeHeader(char *header_val, const char *charset, 
+   *                              bool override, bool eatcontinuation)
+   *
+   * @param aHeaderVal       a header value to decode
+   * @param aDefaultCharset  MIME charset to use in place of MIME charset
+   *                         specified in RFC 2047 style encoding
+   *                         when <code>aOverrideCharset</code> is set.
+   * @param aOverrideCharset When set, overrides MIME charset specified 
+   *                         in RFC 2047 style encoding with <code>aDefaultCharset</code>
+   * @param aEatContinuation When set, removes CR/LF
+   * @return                 decoded header value
+   */
+  [noscript]
+  ACString decodeRFC2047Header(in string aHeaderVal,
+                               in string aDefaultCharset,
+                               in boolean aOverrideCharset,
+                               in boolean aEatContinuation);
+
+
+  /** 
+   * Given a header parameter, decodes RFC 2047 style encoding (if it's 
+   * not obtained from RFC 2231 encoding),  converts it to
+   * UTF-8 and returns the result in UTF-8 if an attempt to extract 
+   * charset info. from a few different sources succeeds.
+   * Otherwise,  returns the input header value (in whatever encoding) 
+   * as it is except that  RFC 822 (using backslash) quotation is
+   * stripped off.
+   * <p>
+   * For internal use only. The only other place where this needs to be 
+   * invoked  is  <code>mime_decode_filename</code> in 
+   * mailnews/mime/src/mimehdrs.cpp defined as
+   * char * mime_decode_filename(char *name, const char *charset, 
+   *                             MimeDisplayOptions *opt) 
+   *
+   * @param aParamValue      the value of a parameter to decode and convert
+   * @param aCharset         charset obtained from RFC 2231 decoding  in which 
+   *                         <code>aParamValue</code> is encoded. If null,
+   *                         indicates that it needs to try RFC 2047, instead. 
+   * @param aDefaultCharset  MIME charset to use when aCharset is null and
+   *                         cannot be obtained per RFC 2047 (most likely 
+   *                         because 'bare' string is  used.)  Besides, it 
+   *                         overrides aCharset/MIME charset obtained from 
+   *                         RFC 2047 if <code>aOverrideCharset</code>  is set.
+   * @param aOverrideCharset When set, overrides MIME charset specified 
+   *                         in RFC 2047 style encoding with 
+   *                         <code>aDefaultCharset</code>
+   * @return                 decoded parameter 
+   */
+
+  [noscript]
+   ACString decodeParameter(in ACString aParamValue,
+                            in string aCharset,
+                            in string aDefaultCharset,
+                            in boolean aOverrideCharset);
+};
+
diff --git a/netwerk/mime/nsIMIMEInfo.idl b/netwerk/mime/nsIMIMEInfo.idl
new file mode 100644
index 000000000..64172e14e
--- /dev/null
+++ b/netwerk/mime/nsIMIMEInfo.idl
@@ -0,0 +1,365 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+interface nsIFile;
+interface nsIUTF8StringEnumerator;
+interface nsIHandlerApp;
+interface nsIArray;
+interface nsIMutableArray;
+interface nsIInterfaceRequestor;
+
+typedef long nsHandlerInfoAction;
+
+/**
+ * nsIHandlerInfo gives access to the information about how a given protocol
+ * scheme or MIME-type is handled.
+ */
+[scriptable, uuid(325e56a7-3762-4312-aec7-f1fcf84b4145)] 
+interface nsIHandlerInfo : nsISupports {
+    /**
+     * The type of this handler info.  For MIME handlers, this is the MIME type.
+     * For protocol handlers, it's the scheme.
+     * 
+     * @return String representing the type.
+     */
+    readonly attribute ACString type;
+
+    /**
+     * A human readable description of the handler type
+     */
+    attribute AString description;
+
+    /**
+     * The application the user has said they want associated with this content
+     * type. This is not always guaranteed to be set!!
+     */
+    attribute nsIHandlerApp preferredApplicationHandler;
+
+    /**
+     * Applications that can handle this content type.
+     *
+     * The list will include the preferred handler, if any.  Elements of this
+     * array are nsIHandlerApp objects, and this attribute will always reference
+     * an array, whether or not there are any possible handlers.  If there are
+     * no possible handlers, the array will contain no elements, so just check
+     * its length (nsIArray::length) to see if there are any possible handlers.
+     */
+    readonly attribute nsIMutableArray possibleApplicationHandlers;
+
+    /**
+     * Indicates whether a default application handler exists,
+     * i.e. whether launchWithFile with action = useSystemDefault is possible
+     * and defaultDescription will contain usable information.
+     */
+    readonly attribute boolean hasDefaultHandler;
+
+    /**
+     * A pretty name description of the associated default application. Only
+     * usable if hasDefaultHandler is true.
+     */
+    readonly attribute AString defaultDescription;
+
+    /**
+     * Launches the application with the specified URI, in a way that
+     * depends on the value of preferredAction. preferredAction must be
+     * useHelperApp or useSystemDefault.
+     *  
+     * @note Only the URI scheme is used to determine how to launch.  This is
+     * essentially a pass-by-value operation.  This means that in the case of
+     * a file: URI, the handler that is registered for file: will be launched
+     * and our code will not make any decision based on the content-type or
+     * extension, though the invoked file: handler is free to do so. 
+     *
+     * @param aURI
+     *        The URI to launch this application with
+     *
+     * @param aWindowContext 
+     *        The window to parent the dialog against, and, if a web handler
+     *        is chosen, it is loaded in this window as well.  See 
+     *        nsIHandlerApp.launchWithURI for more details.
+     *
+     * @throw NS_ERROR_INVALID_ARG if preferredAction is not valid for this
+     * call. Other exceptions may be thrown.
+     */
+    void launchWithURI(in nsIURI aURI, 
+                       [optional] in nsIInterfaceRequestor aWindowContext);
+
+    /**
+     * preferredAction is how the user specified they would like to handle
+     * this content type: save to disk, use specified helper app, use OS
+     * default handler or handle using navigator; possible value constants
+     * listed below
+     */
+    attribute nsHandlerInfoAction preferredAction;
+
+    const long saveToDisk = 0;
+    /**
+     * Used to indicate that we know nothing about what to do with this.  You
+     * could consider this to be not initialized.
+     */
+    const long alwaysAsk = 1;
+    const long useHelperApp = 2;
+    const long handleInternally = 3;
+    const long useSystemDefault = 4;
+
+    /**
+     * alwaysAskBeforeHandling: if true, we should always give the user a
+     * dialog asking how to dispose of this content.
+     */
+    attribute boolean alwaysAskBeforeHandling;
+};
+
+/**
+ * nsIMIMEInfo extends nsIHandlerInfo with a bunch of information specific to
+ * MIME content-types. There is a one-to-many relationship between MIME types
+ * and file extensions. This means that a MIMEInfo object may have multiple
+ * file extensions associated with it.  However, the reverse is not true.
+ *
+ * MIMEInfo objects are generally retrieved from the MIME Service
+ * @see nsIMIMEService
+ */
+[scriptable, uuid(1c21acef-c7a1-40c6-9d40-a20480ee53a1)]
+interface nsIMIMEInfo : nsIHandlerInfo {
+    /**
+     * Gives you an array of file types associated with this type.
+     *
+     * @return Number of elements in the array.
+     * @return Array of extensions.
+     */
+    nsIUTF8StringEnumerator getFileExtensions();
+
+    /**
+     * Set File Extensions. Input is a comma delimited list of extensions.
+     */
+    void setFileExtensions(in AUTF8String aExtensions);
+ 
+    /**
+     * Returns whether or not the given extension is
+     * associated with this MIME info.
+     *
+     * @return TRUE if the association exists. 
+     */
+    boolean extensionExists(in AUTF8String aExtension);
+
+    /**
+     * Append a given extension to the set of extensions
+     */
+    void appendExtension(in AUTF8String aExtension);
+
+    /**
+     * Returns the first extension association in
+     * the internal set of extensions.
+     *
+     * @return The first extension.
+     */
+    attribute AUTF8String primaryExtension;
+    
+    /**
+     * The MIME type of this MIMEInfo.
+     * 
+     * @return String representing the MIME type.
+     * 
+     * @deprecated  use nsIHandlerInfo::type instead.
+     */
+    readonly attribute ACString MIMEType;
+
+    /**
+     * Returns whether or not these two nsIMIMEInfos are logically
+     * equivalent.
+     *
+     * @returns PR_TRUE if the two are considered equal
+     */
+    boolean equals(in nsIMIMEInfo aMIMEInfo);
+
+    /** 
+     * Returns a list of nsILocalHandlerApp objects containing
+     * handlers associated with this mimeinfo. Implemented per 
+     * platform using information in this object to generate the
+     * best list. Typically used for an "open with" style user 
+     * option.
+     * 
+     * @return nsIArray of nsILocalHandlerApp
+     */
+    readonly attribute nsIArray possibleLocalHandlers;
+
+    /**
+     * Launches the application with the specified file, in a way that
+     * depends on the value of preferredAction. preferredAction must be
+     * useHelperApp or useSystemDefault.
+     *
+     * @param aFile The file to launch this application with.
+     *
+     * @throw NS_ERROR_INVALID_ARG if action is not valid for this function.
+     * Other exceptions may be thrown.
+     */
+    void launchWithFile(in nsIFile aFile);
+};
+
+/**
+ * nsIHandlerApp represents an external application that can handle content
+ * of some sort (either a MIME type or a protocol).
+ *
+ * FIXME: now that we've made nsIWebHandlerApp inherit from nsIHandlerApp,
+ * we should also try to make nsIWebContentHandlerInfo inherit from or possibly
+ * be replaced by nsIWebHandlerApp (bug 394710).
+ */
+[scriptable, uuid(8BDF20A4-9170-4548-AF52-78311A44F920)]
+interface nsIHandlerApp : nsISupports {
+
+    /**
+     * Human readable name for the handler
+     */
+    attribute AString name;
+
+    /**
+     * Detailed description for this handler. Suitable for
+     * a tooltip or short informative sentence.
+     */
+    attribute AString detailedDescription;
+
+    /**
+     * Whether or not the given handler app is logically equivalent to the
+     * invokant (i.e. they represent the same app).
+     * 
+     * Two apps are the same if they are both either local or web handlers
+     * and their executables/URI templates and command line parameters are
+     * the same.
+     *
+     * @param aHandlerApp the handler app to compare to the invokant
+     *
+     * @returns true if the two are logically equivalent, false otherwise
+     */
+    boolean equals(in nsIHandlerApp aHandlerApp);
+
+    /**
+     * Launches the application with the specified URI.
+     *
+     * @param aURI
+     *        The URI to launch this application with
+     *
+     * @param aWindowContext 
+     *
+     *        Currently only relevant to web-handler apps.  If given, this
+     *        represents the docshell to load the handler in and is passed
+     *        through to nsIURILoader.openURI.  If this parameter is null or
+     *        not present, the web handler app implementation will attempt to 
+     *        find/create a place to load the handler and do so.  As of this
+     *        writing, it tries to load the web handler in a new window using
+     *        nsIBrowserDOMWindow.openURI.  In the future, it may attempt to 
+     *        have a more comprehensive strategy which could include handing
+     *        off to the system default browser (bug 394479).
+     */
+    void launchWithURI(in nsIURI aURI, 
+                       [optional] in nsIInterfaceRequestor aWindowContext);
+
+};
+
+/**
+ * nsILocalHandlerApp is a local OS-level executable
+ */
+[scriptable, uuid(D36B6329-52AE-4f45-80F4-B2536AE5F8B2)]
+interface nsILocalHandlerApp : nsIHandlerApp {
+
+    /**
+     * Pointer to the executable file used to handle content
+     */
+    attribute nsIFile executable;
+
+    /**
+     * Returns the current number of command line parameters.
+     */
+    readonly attribute unsigned long parameterCount;
+
+    /**
+     * Clears the current list of command line parameters.
+     */
+    void clearParameters();
+
+    /**
+     * Appends a command line parameter to the command line
+     * parameter list.
+     *
+     * @param param the parameter to add.
+     */
+    void appendParameter(in AString param);
+
+    /**
+     * Retrieves a specific command line parameter.
+     *
+     * @param param the index of the parameter to return.
+     *
+     * @return the parameter string.
+     *
+     * @throw NS_ERROR_INVALID_ARG if the index is out of range.
+     */
+    AString getParameter(in unsigned long parameterIndex);
+
+    /**
+     * Checks to see if a parameter exists in the command line
+     * parameter list.
+     *
+     * @param param the parameter to search for.
+     *
+     * @return TRUE if the parameter exists in the current list. 
+     */
+    boolean parameterExists(in AString param);
+};
+
+/**
+ * nsIWebHandlerApp is a web-based handler, as speced by the WhatWG HTML5
+ * draft.  Currently, only GET-based handlers are supported.  At some point, 
+ * we probably want to work with WhatWG to spec out and implement POST-based
+ * handlers as well.
+ */
+[scriptable, uuid(7521a093-c498-45ce-b462-df7ba0d882f6)]
+interface nsIWebHandlerApp : nsIHandlerApp {
+
+    /**
+     * Template used to construct the URI to GET.  Template is expected to have
+     * a %s in it, and the escaped URI to be handled is inserted in place of 
+     * that %s, as per the HTML5 spec.
+     */
+    attribute AUTF8String uriTemplate;
+};
+
+/**
+ * nsIDBusHandlerApp represents local applications launched by DBus a message
+ * invoking a method taking a single string argument descibing a URI
+ */
+[scriptable, uuid(1ffc274b-4cbf-4bb5-a635-05ad2cbb6534)]
+interface nsIDBusHandlerApp : nsIHandlerApp {
+
+    /**
+     * Service defines the dbus service that should handle this protocol.
+     * If its not set,  NS_ERROR_FAILURE will be returned by LaunchWithURI
+     */
+    attribute AUTF8String service;
+    
+    /**
+     * Objpath defines the object path of the dbus service that should handle 
+     * this protocol. If its not set,  NS_ERROR_FAILURE will be returned 
+     * by LaunchWithURI
+     */
+    attribute AUTF8String objectPath;
+
+    /**
+     * DBusInterface defines the interface of the dbus service that should 
+     * handle this protocol. If its not set,  NS_ERROR_FAILURE will be  
+     * returned by LaunchWithURI
+     */
+    attribute AUTF8String dBusInterface;
+    
+    /**
+     * Method defines the dbus method that should be invoked to handle this 
+     * protocol. If its not set,  NS_ERROR_FAILURE will be returned by 
+     * LaunchWithURI
+     */
+    attribute AUTF8String method;
+    
+};
+
diff --git a/netwerk/mime/nsIMIMEService.idl b/netwerk/mime/nsIMIMEService.idl
new file mode 100644
index 000000000..704269c3c
--- /dev/null
+++ b/netwerk/mime/nsIMIMEService.idl
@@ -0,0 +1,75 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIFile;
+interface nsIMIMEInfo;
+interface nsIURI;
+
+%{C++
+#define NS_MIMESERVICE_CID                           \
+{ /* 03af31da-3109-11d3-8cd0-0060b0fc14a3 */         \
+    0x03af31da,                                      \
+    0x3109,                                          \
+    0x11d3,                                          \
+    {0x8c, 0xd0, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3} \
+}
+%}
+
+/**
+ * The MIME service is responsible for mapping file extensions to MIME-types
+ * (see RFC 2045). It also provides access to nsIMIMEInfo interfaces and
+ * acts as a general convenience wrapper of nsIMIMEInfo interfaces.
+ *
+ * The MIME service maintains a database with a <b>one</b> MIME type <b>to many</b>
+ * file extensions rule. Adding the same file extension to multiple MIME types
+ * is illegal and behavior is undefined.
+ *
+ * @see nsIMIMEInfo
+ */
+[scriptable, main_process_scriptable_only, uuid(5b3675a1-02db-4f8f-a560-b34736635f47)]
+interface nsIMIMEService : nsISupports {
+    /**
+     * Retrieves an nsIMIMEInfo using both the extension
+     * and the type of a file. The type is given preference
+     * during the lookup. One of aMIMEType and aFileExt
+     * can be an empty string. At least one of aMIMEType and aFileExt
+     * must be nonempty.
+     */
+    nsIMIMEInfo getFromTypeAndExtension(in ACString aMIMEType, in AUTF8String aFileExt);
+
+    /**
+     * Retrieves a ACString representation of the MIME type
+     * associated with this file extension.
+     *
+     * @param  A file extension (excluding the dot ('.')).
+     * @return The MIME type, if any.
+     */
+    ACString getTypeFromExtension(in AUTF8String aFileExt);
+
+    /**
+     * Retrieves a ACString representation of the MIME type
+     * associated with this URI. The association is purely
+     * file extension to MIME type based. No attempt to determine
+     * the type via server headers or byte scanning is made.
+     *
+     * @param  The URI the user wants MIME info on.
+     * @return The MIME type, if any.
+     */
+    ACString getTypeFromURI(in nsIURI aURI);
+    
+    //
+    ACString getTypeFromFile(in nsIFile aFile);
+
+    /**
+     * Given a Type/Extension combination, returns the default extension
+     * for this type. This may be identical to the passed-in extension.
+     *
+     * @param aMIMEType The Type to get information on. Must not be empty.
+     * @param aFileExt  File Extension. Can be empty.
+     */
+    AUTF8String getPrimaryExtension(in ACString aMIMEType, in AUTF8String aFileExt);
+};
diff --git a/netwerk/mime/nsMIMEHeaderParamImpl.cpp b/netwerk/mime/nsMIMEHeaderParamImpl.cpp
new file mode 100644
index 000000000..8d668f64f
--- /dev/null
+++ b/netwerk/mime/nsMIMEHeaderParamImpl.cpp
@@ -0,0 +1,1346 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=4 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string.h>
+#include "prmem.h"
+#include "prprf.h"
+#include "plstr.h"
+#include "plbase64.h"
+#include "nsCRT.h"
+#include "nsMemory.h"
+#include "nsTArray.h"
+#include "nsCOMPtr.h"
+#include "nsEscape.h"
+#include "nsIUTF8ConverterService.h"
+#include "nsUConvCID.h"
+#include "nsIServiceManager.h"
+#include "nsMIMEHeaderParamImpl.h"
+#include "nsReadableUtils.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsError.h"
+#include "nsIUnicodeDecoder.h"
+#include "mozilla/dom/EncodingUtils.h"
+
+using mozilla::dom::EncodingUtils;
+
+// static functions declared below are moved from mailnews/mime/src/comi18n.cpp
+  
+static char *DecodeQ(const char *, uint32_t);
+static bool Is7bitNonAsciiString(const char *, uint32_t);
+static void CopyRawHeader(const char *, uint32_t, const char *, nsACString &);
+static nsresult DecodeRFC2047Str(const char *, const char *, bool, nsACString&);
+static nsresult internalDecodeParameter(const nsACString&, const char*,
+                                        const char*, bool, bool, nsACString&);
+
+// XXX The chance of UTF-7 being used in the message header is really
+// low, but in theory it's possible. 
+#define IS_7BIT_NON_ASCII_CHARSET(cset)            \
+    (!nsCRT::strncasecmp((cset), "ISO-2022", 8) || \
+     !nsCRT::strncasecmp((cset), "HZ-GB", 5)    || \
+     !nsCRT::strncasecmp((cset), "UTF-7", 5))   
+
+NS_IMPL_ISUPPORTS(nsMIMEHeaderParamImpl, nsIMIMEHeaderParam)
+
+NS_IMETHODIMP 
+nsMIMEHeaderParamImpl::GetParameter(const nsACString& aHeaderVal, 
+                                    const char *aParamName,
+                                    const nsACString& aFallbackCharset, 
+                                    bool aTryLocaleCharset, 
+                                    char **aLang, nsAString& aResult)
+{
+  return DoGetParameter(aHeaderVal, aParamName, MIME_FIELD_ENCODING,
+                        aFallbackCharset, aTryLocaleCharset, aLang, aResult);
+}
+
+NS_IMETHODIMP 
+nsMIMEHeaderParamImpl::GetParameterHTTP(const nsACString& aHeaderVal, 
+                                        const char *aParamName,
+                                        const nsACString& aFallbackCharset, 
+                                        bool aTryLocaleCharset, 
+                                        char **aLang, nsAString& aResult)
+{
+  return DoGetParameter(aHeaderVal, aParamName, HTTP_FIELD_ENCODING,
+                        aFallbackCharset, aTryLocaleCharset, aLang, aResult);
+}
+
+// XXX : aTryLocaleCharset is not yet effective.
+nsresult 
+nsMIMEHeaderParamImpl::DoGetParameter(const nsACString& aHeaderVal, 
+                                      const char *aParamName,
+                                      ParamDecoding aDecoding,
+                                      const nsACString& aFallbackCharset, 
+                                      bool aTryLocaleCharset, 
+                                      char **aLang, nsAString& aResult)
+{
+    aResult.Truncate();
+    nsresult rv;
+
+    // get parameter (decode RFC 2231/5987 when applicable, as specified by
+    // aDecoding (5987 being a subset of 2231) and return charset.)
+    nsXPIDLCString med;
+    nsXPIDLCString charset;
+    rv = DoParameterInternal(PromiseFlatCString(aHeaderVal).get(), aParamName, 
+                             aDecoding, getter_Copies(charset), aLang, 
+                             getter_Copies(med));
+    if (NS_FAILED(rv))
+        return rv; 
+
+    // convert to UTF-8 after charset conversion and RFC 2047 decoding 
+    // if necessary.
+    
+    nsAutoCString str1;
+    rv = internalDecodeParameter(med, charset.get(), nullptr, false,
+                                 // was aDecoding == MIME_FIELD_ENCODING
+                                 // see bug 875615
+                                 true,
+                                 str1);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!aFallbackCharset.IsEmpty())
+    {
+        nsAutoCString charset;
+        EncodingUtils::FindEncodingForLabel(aFallbackCharset, charset);
+        nsAutoCString str2;
+        nsCOMPtr<nsIUTF8ConverterService> 
+          cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID));
+        if (cvtUTF8 &&
+            NS_SUCCEEDED(cvtUTF8->ConvertStringToUTF8(str1, 
+                PromiseFlatCString(aFallbackCharset).get(), false,
+                                   !charset.EqualsLiteral("UTF-8"),
+                                   1, str2))) {
+          CopyUTF8toUTF16(str2, aResult);
+          return NS_OK;
+        }
+    }
+
+    if (IsUTF8(str1)) {
+      CopyUTF8toUTF16(str1, aResult);
+      return NS_OK;
+    }
+
+    if (aTryLocaleCharset && !NS_IsNativeUTF8()) 
+      return NS_CopyNativeToUnicode(str1, aResult);
+
+    CopyASCIItoUTF16(str1, aResult);
+    return NS_OK;
+}
+
+// remove backslash-encoded sequences from quoted-strings
+// modifies string in place, potentially shortening it
+void RemoveQuotedStringEscapes(char *src)
+{
+  char *dst = src;
+
+  for (char *c = src; *c; ++c)
+  {
+    if (c[0] == '\\' && c[1])
+    {
+      // skip backslash if not at end
+      ++c;
+    }
+    *dst++ = *c;
+  }
+  *dst = 0;
+}
+
+// true is character is a hex digit
+bool IsHexDigit(char aChar)
+{
+  char c = aChar;
+
+  return (c >= 'a' && c <= 'f') ||
+         (c >= 'A' && c <= 'F') ||
+         (c >= '0' && c <= '9');
+}
+
+// validate that a C String containing %-escapes is syntactically valid
+bool IsValidPercentEscaped(const char *aValue, int32_t len)
+{
+  for (int32_t i = 0; i < len; i++) {
+    if (aValue[i] == '%') {
+      if (!IsHexDigit(aValue[i + 1]) || !IsHexDigit(aValue[i + 2])) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// Support for continuations (RFC 2231, Section 3)
+
+// only a sane number supported
+#define MAX_CONTINUATIONS 999
+
+// part of a continuation
+
+class Continuation {
+  public:
+    Continuation(const char *aValue, uint32_t aLength,
+                 bool aNeedsPercentDecoding, bool aWasQuotedString) {
+      value = aValue;
+      length = aLength;
+      needsPercentDecoding = aNeedsPercentDecoding;
+      wasQuotedString = aWasQuotedString;
+    }
+    Continuation() {
+      // empty constructor needed for nsTArray
+      value = 0L;
+      length = 0;
+      needsPercentDecoding = false;
+      wasQuotedString = false;
+    }
+    ~Continuation() = default;
+
+    const char *value;
+    uint32_t length;
+    bool needsPercentDecoding;
+    bool wasQuotedString;
+};
+
+// combine segments into a single string, returning the allocated string
+// (or nullptr) while emptying the list 
+char *combineContinuations(nsTArray<Continuation>& aArray)
+{
+  // Sanity check
+  if (aArray.Length() == 0)
+    return nullptr;
+
+  // Get an upper bound for the length
+  uint32_t length = 0;
+  for (uint32_t i = 0; i < aArray.Length(); i++) {
+    length += aArray[i].length;
+  }
+
+  // Allocate
+  char *result = (char *) moz_xmalloc(length + 1);
+
+  // Concatenate
+  if (result) {
+    *result = '\0';
+
+    for (uint32_t i = 0; i < aArray.Length(); i++) {
+      Continuation cont = aArray[i];
+      if (! cont.value) break;
+
+      char *c = result + strlen(result);
+      strncat(result, cont.value, cont.length);
+      if (cont.needsPercentDecoding) {
+        nsUnescape(c);
+      }
+      if (cont.wasQuotedString) {
+        RemoveQuotedStringEscapes(c);
+      }
+    }
+
+    // return null if empty value
+    if (*result == '\0') {
+      free(result);
+      result = nullptr;
+    }
+  } else {
+    // Handle OOM
+    NS_WARNING("Out of memory\n");
+  }
+
+  return result;
+}
+
+// add a continuation, return false on error if segment already has been seen
+bool addContinuation(nsTArray<Continuation>& aArray, uint32_t aIndex,
+                     const char *aValue, uint32_t aLength,
+                     bool aNeedsPercentDecoding, bool aWasQuotedString)
+{
+  if (aIndex < aArray.Length() && aArray[aIndex].value) {
+    NS_WARNING("duplicate RC2231 continuation segment #\n");
+    return false;
+  }
+
+  if (aIndex > MAX_CONTINUATIONS) {
+    NS_WARNING("RC2231 continuation segment # exceeds limit\n");
+    return false;
+  }
+
+  if (aNeedsPercentDecoding && aWasQuotedString) {
+    NS_WARNING("RC2231 continuation segment can't use percent encoding and quoted string form at the same time\n");
+    return false;
+  }
+
+  Continuation cont(aValue, aLength, aNeedsPercentDecoding, aWasQuotedString);
+
+  if (aArray.Length() <= aIndex) {
+    aArray.SetLength(aIndex + 1);
+  }
+  aArray[aIndex] = cont;
+
+  return true;
+}
+
+// parse a segment number; return -1 on error
+int32_t parseSegmentNumber(const char *aValue, int32_t aLen)
+{
+  if (aLen < 1) {
+    NS_WARNING("segment number missing\n");
+    return -1;
+  }
+
+  if (aLen > 1 && aValue[0] == '0') {
+    NS_WARNING("leading '0' not allowed in segment number\n");
+    return -1;
+  }
+
+  int32_t segmentNumber = 0;
+
+  for (int32_t i = 0; i < aLen; i++) {
+    if (! (aValue[i] >= '0' && aValue[i] <= '9')) {
+      NS_WARNING("invalid characters in segment number\n");
+      return -1;
+    }
+
+    segmentNumber *= 10;
+    segmentNumber += aValue[i] - '0';
+    if (segmentNumber > MAX_CONTINUATIONS) {
+      NS_WARNING("Segment number exceeds sane size\n");
+      return -1;
+    }
+  }
+
+  return segmentNumber;
+}
+
+// validate a given octet sequence for compliance with the specified
+// encoding
+bool IsValidOctetSequenceForCharset(nsACString& aCharset, const char *aOctets)
+{
+  nsCOMPtr<nsIUTF8ConverterService> cvtUTF8(do_GetService
+    (NS_UTF8CONVERTERSERVICE_CONTRACTID));
+  if (!cvtUTF8) {
+    NS_WARNING("Can't get UTF8ConverterService\n");
+    return false;
+  }
+
+  nsAutoCString tmpRaw;
+  tmpRaw.Assign(aOctets);
+  nsAutoCString tmpDecoded;
+
+  nsresult rv = cvtUTF8->ConvertStringToUTF8(tmpRaw,
+                                             PromiseFlatCString(aCharset).get(),
+                                             false, false, 1, tmpDecoded);
+
+  if (rv != NS_OK) {
+    // we can't decode; charset may be unsupported, or the octet sequence
+    // is broken (illegal or incomplete octet sequence contained)
+    NS_WARNING("RFC2231/5987 parameter value does not decode according to specified charset\n");
+    return false;
+  }
+
+  return true;
+}
+
+// moved almost verbatim from mimehdrs.cpp
+// char *
+// MimeHeaders_get_parameter (const char *header_value, const char *parm_name,
+//                            char **charset, char **language)
+//
+// The format of these header lines  is
+// <token> [ ';' <token> '=' <token-or-quoted-string> ]*
+NS_IMETHODIMP 
+nsMIMEHeaderParamImpl::GetParameterInternal(const char *aHeaderValue, 
+                                            const char *aParamName,
+                                            char **aCharset,
+                                            char **aLang,
+                                            char **aResult)
+{
+  return DoParameterInternal(aHeaderValue, aParamName, MIME_FIELD_ENCODING,
+                             aCharset, aLang, aResult);
+}
+
+
+nsresult 
+nsMIMEHeaderParamImpl::DoParameterInternal(const char *aHeaderValue, 
+                                           const char *aParamName,
+                                           ParamDecoding aDecoding,
+                                           char **aCharset,
+                                           char **aLang,
+                                           char **aResult)
+{
+
+  if (!aHeaderValue ||  !*aHeaderValue || !aResult)
+    return NS_ERROR_INVALID_ARG;
+
+  *aResult = nullptr;
+
+  if (aCharset) *aCharset = nullptr;
+  if (aLang) *aLang = nullptr;
+
+  nsAutoCString charset;
+
+  // change to (aDecoding != HTTP_FIELD_ENCODING) when we want to disable
+  // them for HTTP header fields later on, see bug 776324
+  bool acceptContinuations = true;
+
+  const char *str = aHeaderValue;
+
+  // skip leading white space.
+  for (; *str &&  nsCRT::IsAsciiSpace(*str); ++str)
+    ;
+  const char *start = str;
+  
+  // aParamName is empty. return the first (possibly) _unnamed_ 'parameter'
+  // For instance, return 'inline' in the following case:
+  // Content-Disposition: inline; filename=.....
+  if (!aParamName || !*aParamName) 
+    {
+      for (; *str && *str != ';' && !nsCRT::IsAsciiSpace(*str); ++str)
+        ;
+      if (str == start)
+        return NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY;
+
+      *aResult = (char *) nsMemory::Clone(start, (str - start) + 1);
+      NS_ENSURE_TRUE(*aResult, NS_ERROR_OUT_OF_MEMORY);
+      (*aResult)[str - start] = '\0';  // null-terminate
+      return NS_OK;
+    }
+
+  /* Skip forward to first ';' */
+  for (; *str && *str != ';' && *str != ','; ++str)
+    ;
+  if (*str)
+    str++;
+  /* Skip over following whitespace */
+  for (; *str && nsCRT::IsAsciiSpace(*str); ++str)
+    ;
+
+  // Some broken http servers just specify parameters
+  // like 'filename' without specifying disposition
+  // method. Rewind to the first non-white-space
+  // character.
+  
+  if (!*str)
+    str = start;
+
+  // RFC2231 - The legitimate parm format can be:
+  // A. title=ThisIsTitle 
+  // B. title*=us-ascii'en-us'This%20is%20wierd.
+  // C. title*0*=us-ascii'en'This%20is%20wierd.%20We
+  //    title*1*=have%20to%20support%20this.
+  //    title*2="Else..."
+  // D. title*0="Hey, what you think you are doing?"
+  //    title*1="There is no charset and lang info."
+  // RFC5987: only A and B
+  
+  // collect results for the different algorithms (plain filename,
+  // RFC5987/2231-encoded filename, + continuations) separately and decide
+  // which to use at the end
+  char *caseAResult = nullptr;
+  char *caseBResult = nullptr;
+  char *caseCDResult = nullptr;
+
+  // collect continuation segments
+  nsTArray<Continuation> segments;
+
+
+  // our copies of the charset parameter, kept separately as they might
+  // differ for the two formats
+  nsDependentCSubstring charsetB, charsetCD;
+
+  nsDependentCSubstring lang;
+
+  int32_t paramLen = strlen(aParamName);
+
+  while (*str) {
+    // find name/value
+
+    const char *nameStart = str;
+    const char *nameEnd = nullptr;
+    const char *valueStart = str;
+    const char *valueEnd = nullptr;
+    bool isQuotedString = false;
+
+    NS_ASSERTION(!nsCRT::IsAsciiSpace(*str), "should be after whitespace.");
+
+    // Skip forward to the end of this token. 
+    for (; *str && !nsCRT::IsAsciiSpace(*str) && *str != '=' && *str != ';'; str++)
+      ;
+    nameEnd = str;
+
+    int32_t nameLen = nameEnd - nameStart;
+
+    // Skip over whitespace, '=', and whitespace
+    while (nsCRT::IsAsciiSpace(*str)) ++str;
+    if (!*str) {
+      break;
+    }
+    if (*str++ != '=') {
+      // don't accept parameters without "="
+      goto increment_str;
+    }
+    while (nsCRT::IsAsciiSpace(*str)) ++str;
+
+    if (*str != '"') {
+      // The value is a token, not a quoted string.
+      valueStart = str;
+      for (valueEnd = str;
+           *valueEnd && !nsCRT::IsAsciiSpace (*valueEnd) && *valueEnd != ';';
+           valueEnd++)
+        ;
+      str = valueEnd;
+    } else {
+      isQuotedString = true;
+      
+      ++str;
+      valueStart = str;
+      for (valueEnd = str; *valueEnd; ++valueEnd) {
+        if (*valueEnd == '\\' && *(valueEnd + 1))
+          ++valueEnd;
+        else if (*valueEnd == '"')
+          break;
+      }
+      str = valueEnd;
+      // *valueEnd != null means that *valueEnd is quote character.
+      if (*valueEnd)
+        str++;
+    }
+
+    // See if this is the simplest case (case A above),
+    // a 'single' line value with no charset and lang.
+    // If so, copy it and return.
+    if (nameLen == paramLen &&
+        !nsCRT::strncasecmp(nameStart, aParamName, paramLen)) {
+
+      if (caseAResult) {
+        // we already have one caseA result, ignore subsequent ones
+        goto increment_str;
+      }
+
+      // if the parameter spans across multiple lines we have to strip out the
+      //     line continuation -- jht 4/29/98 
+      nsAutoCString tempStr(valueStart, valueEnd - valueStart);
+      tempStr.StripChars("\r\n");
+      char *res = ToNewCString(tempStr);
+      NS_ENSURE_TRUE(res, NS_ERROR_OUT_OF_MEMORY);
+      
+      if (isQuotedString)
+        RemoveQuotedStringEscapes(res);
+
+      caseAResult = res;
+      // keep going, we may find a RFC 2231/5987 encoded alternative
+    }
+    // case B, C, and D
+    else if (nameLen > paramLen &&
+             !nsCRT::strncasecmp(nameStart, aParamName, paramLen) &&
+             *(nameStart + paramLen) == '*') {
+
+      // 1st char past '*'       
+      const char *cp = nameStart + paramLen + 1; 
+
+      // if param name ends in "*" we need do to RFC5987 "ext-value" decoding
+      bool needExtDecoding = *(nameEnd - 1) == '*';      
+
+      bool caseB = nameLen == paramLen + 1;
+      bool caseCStart = (*cp == '0') && needExtDecoding;
+
+      // parse the segment number
+      int32_t segmentNumber = -1;
+      if (!caseB) {
+        int32_t segLen = (nameEnd - cp) - (needExtDecoding ? 1 : 0);
+        segmentNumber = parseSegmentNumber(cp, segLen);
+
+        if (segmentNumber == -1) {
+          acceptContinuations = false;
+          goto increment_str;
+        }
+      }
+
+      // CaseB and start of CaseC: requires charset and optional language
+      // in quotes (quotes required even if lang is blank)
+      if (caseB || (caseCStart && acceptContinuations)) {
+        // look for single quotation mark(')
+        const char *sQuote1 = PL_strchr(valueStart, 0x27);
+        const char *sQuote2 = sQuote1 ? PL_strchr(sQuote1 + 1, 0x27) : nullptr;
+
+        // Two single quotation marks must be present even in
+        // absence of charset and lang. 
+        if (!sQuote1 || !sQuote2) {
+          NS_WARNING("Mandatory two single quotes are missing in header parameter\n");
+        }
+
+        const char *charsetStart = nullptr;
+        int32_t charsetLength = 0;
+        const char *langStart = nullptr;
+        int32_t langLength = 0;
+        const char *rawValStart = nullptr;
+        int32_t rawValLength = 0;
+
+        if (sQuote2 && sQuote1) {
+          // both delimiters present: charSet'lang'rawVal
+          rawValStart = sQuote2 + 1;
+          rawValLength = valueEnd - rawValStart;
+
+          langStart = sQuote1 + 1;
+          langLength = sQuote2 - langStart;
+
+          charsetStart = valueStart;
+          charsetLength = sQuote1 - charsetStart;
+        }
+        else if (sQuote1) {
+          // one delimiter; assume charset'rawVal
+          rawValStart = sQuote1 + 1;
+          rawValLength = valueEnd - rawValStart;
+
+          charsetStart = valueStart;
+          charsetLength = sQuote1 - valueStart;
+        }
+        else {
+          // no delimiter: just rawVal
+          rawValStart = valueStart;
+          rawValLength = valueEnd - valueStart;
+        }
+
+        if (langLength != 0) {
+          lang.Assign(langStart, langLength);
+        }
+
+        // keep the charset for later
+        if (caseB) {
+          charsetB.Assign(charsetStart, charsetLength);
+        } else {
+          // if caseCorD
+          charsetCD.Assign(charsetStart, charsetLength);
+        }
+
+        // non-empty value part
+        if (rawValLength > 0) {
+          if (!caseBResult && caseB) {
+            if (!IsValidPercentEscaped(rawValStart, rawValLength)) {
+              goto increment_str;
+            }
+
+            // allocate buffer for the raw value
+            char *tmpResult = (char *) nsMemory::Clone(rawValStart, rawValLength + 1);
+            if (!tmpResult) {
+              goto increment_str;
+            }
+            *(tmpResult + rawValLength) = 0;
+
+            nsUnescape(tmpResult);
+            caseBResult = tmpResult;
+          } else {
+            // caseC
+            bool added = addContinuation(segments, 0, rawValStart,
+                                         rawValLength, needExtDecoding,
+                                         isQuotedString);
+
+            if (!added) {
+              // continuation not added, stop processing them
+              acceptContinuations = false;
+            }
+          }
+        }
+      }  // end of if-block :  title*0*=  or  title*= 
+      // caseD: a line of multiline param with no need for unescaping : title*[0-9]=
+      // or 2nd or later lines of a caseC param : title*[1-9]*= 
+      else if (acceptContinuations && segmentNumber != -1) {
+        uint32_t valueLength = valueEnd - valueStart;
+
+        bool added = addContinuation(segments, segmentNumber, valueStart,
+                                     valueLength, needExtDecoding,
+                                     isQuotedString);
+
+        if (!added) {
+          // continuation not added, stop processing them
+          acceptContinuations = false;
+        }
+      } // end of if-block :  title*[0-9]= or title*[1-9]*=
+    }
+
+    // str now points after the end of the value.
+    //   skip over whitespace, ';', whitespace.
+increment_str:      
+    while (nsCRT::IsAsciiSpace(*str)) ++str;
+    if (*str == ';') {
+      ++str;
+    } else {
+      // stop processing the header field; either we are done or the
+      // separator was missing
+      break;
+    }
+    while (nsCRT::IsAsciiSpace(*str)) ++str;
+  }
+
+  caseCDResult = combineContinuations(segments);
+
+  if (caseBResult && !charsetB.IsEmpty()) {
+    // check that the 2231/5987 result decodes properly given the
+    // specified character set
+    if (!IsValidOctetSequenceForCharset(charsetB, caseBResult))
+      caseBResult = nullptr;
+  }
+
+  if (caseCDResult && !charsetCD.IsEmpty()) {
+    // check that the 2231/5987 result decodes properly given the
+    // specified character set
+    if (!IsValidOctetSequenceForCharset(charsetCD, caseCDResult))
+      caseCDResult = nullptr;
+  }
+
+  if (caseBResult) {
+    // prefer simple 5987 format over 2231 with continuations
+    *aResult = caseBResult;
+    caseBResult = nullptr;
+    charset.Assign(charsetB);
+  }
+  else if (caseCDResult) {
+    // prefer 2231/5987 with or without continuations over plain format
+    *aResult = caseCDResult;
+    caseCDResult = nullptr;
+    charset.Assign(charsetCD);
+  }
+  else if (caseAResult) {
+    *aResult = caseAResult;
+    caseAResult = nullptr;
+  }
+
+  // free unused stuff
+  free(caseAResult);
+  free(caseBResult);
+  free(caseCDResult);
+
+  // if we have a result
+  if (*aResult) {
+    // then return charset and lang as well
+    if (aLang && !lang.IsEmpty()) {
+      uint32_t len = lang.Length();
+      *aLang = (char *) nsMemory::Clone(lang.BeginReading(), len + 1);
+      if (*aLang) {
+        *(*aLang + len) = 0;
+      }
+   }
+    if (aCharset && !charset.IsEmpty()) {
+      uint32_t len = charset.Length();
+      *aCharset = (char *) nsMemory::Clone(charset.BeginReading(), len + 1);
+      if (*aCharset) {
+        *(*aCharset + len) = 0;
+      }
+    }
+  }
+
+  return *aResult ? NS_OK : NS_ERROR_INVALID_ARG;
+}
+
+nsresult
+internalDecodeRFC2047Header(const char* aHeaderVal, const char* aDefaultCharset,
+                            bool aOverrideCharset, bool aEatContinuations,
+                            nsACString& aResult)
+{
+  aResult.Truncate();
+  if (!aHeaderVal)
+    return NS_ERROR_INVALID_ARG;
+  if (!*aHeaderVal)
+    return NS_OK;
+
+
+  // If aHeaderVal is RFC 2047 encoded or is not a UTF-8 string  but
+  // aDefaultCharset is specified, decodes RFC 2047 encoding and converts
+  // to UTF-8. Otherwise, just strips away CRLF. 
+  if (PL_strstr(aHeaderVal, "=?") || 
+      (aDefaultCharset && (!IsUTF8(nsDependentCString(aHeaderVal)) || 
+      Is7bitNonAsciiString(aHeaderVal, strlen(aHeaderVal))))) {
+    DecodeRFC2047Str(aHeaderVal, aDefaultCharset, aOverrideCharset, aResult);
+  } else if (aEatContinuations && 
+             (PL_strchr(aHeaderVal, '\n') || PL_strchr(aHeaderVal, '\r'))) {
+    aResult = aHeaderVal;
+  } else {
+    aEatContinuations = false;
+    aResult = aHeaderVal;
+  }
+
+  if (aEatContinuations) {
+    nsAutoCString temp(aResult);
+    temp.ReplaceSubstring("\n\t", " ");
+    temp.ReplaceSubstring("\r\t", " ");
+    temp.StripChars("\r\n");
+    aResult = temp;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMIMEHeaderParamImpl::DecodeRFC2047Header(const char* aHeaderVal, 
+                                           const char* aDefaultCharset, 
+                                           bool aOverrideCharset, 
+                                           bool aEatContinuations,
+                                           nsACString& aResult)
+{
+  return internalDecodeRFC2047Header(aHeaderVal, aDefaultCharset,
+                                     aOverrideCharset, aEatContinuations,
+                                     aResult);
+}
+
+// true if the character is allowed in a RFC 5987 value
+// see RFC 5987, Section 3.2.1, "attr-char"
+bool IsRFC5987AttrChar(char aChar)
+{
+  char c = aChar;
+
+  return (c >= 'a' && c <= 'z') ||
+         (c >= 'A' && c <= 'Z') ||
+         (c >= '0' && c <= '9') ||
+         (c == '!' || c == '#' || c == '$' || c == '&' ||
+          c == '+' || c == '-' || c == '.' || c == '^' ||
+          c == '_' || c == '`' || c == '|' || c == '~');
+}
+
+// percent-decode a value
+// returns false on failure
+bool PercentDecode(nsACString& aValue)
+{
+  char *c = (char *) moz_xmalloc(aValue.Length() + 1);
+  if (!c) {
+    return false;
+  }
+
+  strcpy(c, PromiseFlatCString(aValue).get());
+  nsUnescape(c);
+  aValue.Assign(c);
+  free(c);
+
+  return true;
+}
+
+// Decode a parameter value using the encoding defined in RFC 5987
+// 
+// charset  "'" [ language ] "'" value-chars
+NS_IMETHODIMP 
+nsMIMEHeaderParamImpl::DecodeRFC5987Param(const nsACString& aParamVal,
+                                          nsACString& aLang,
+                                          nsAString& aResult)
+{
+  nsAutoCString charset;
+  nsAutoCString language;
+  nsAutoCString value;
+
+  uint32_t delimiters = 0;
+  const nsCString& encoded = PromiseFlatCString(aParamVal);
+  const char *c = encoded.get();
+
+  while (*c) {
+    char tc = *c++;
+
+    if (tc == '\'') {
+      // single quote
+      delimiters++;
+    } else if (((unsigned char)tc) >= 128) {
+      // fail early, not ASCII
+      NS_WARNING("non-US-ASCII character in RFC5987-encoded param");
+      return NS_ERROR_INVALID_ARG;
+    } else {
+      if (delimiters == 0) {
+        // valid characters are checked later implicitly
+        charset.Append(tc);
+      } else if (delimiters == 1) {
+        // no value checking for now
+        language.Append(tc);
+      } else if (delimiters == 2) {
+        if (IsRFC5987AttrChar(tc)) {
+          value.Append(tc);
+        } else if (tc == '%') {
+          if (!IsHexDigit(c[0]) || !IsHexDigit(c[1])) {
+            // we expect two more characters
+            NS_WARNING("broken %-escape in RFC5987-encoded param");
+            return NS_ERROR_INVALID_ARG;
+          }
+          value.Append(tc);
+          // we consume two more
+          value.Append(*c++);
+          value.Append(*c++);
+        } else {
+          // character not allowed here
+          NS_WARNING("invalid character in RFC5987-encoded param");
+          return NS_ERROR_INVALID_ARG;
+        }      
+      }
+    }
+  }
+
+  if (delimiters != 2) {
+    NS_WARNING("missing delimiters in RFC5987-encoded param");
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // abort early for unsupported encodings
+  if (!charset.LowerCaseEqualsLiteral("utf-8")) {
+    NS_WARNING("unsupported charset in RFC5987-encoded param");
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // percent-decode
+  if (!PercentDecode(value)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  // return the encoding
+  aLang.Assign(language);
+
+  // finally convert octet sequence to UTF-8 and be done
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIUTF8ConverterService> cvtUTF8 =
+    do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString utf8;
+  rv = cvtUTF8->ConvertStringToUTF8(value, charset.get(), true, false, 1, utf8);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  CopyUTF8toUTF16(utf8, aResult);
+  return NS_OK;
+}
+
+nsresult 
+internalDecodeParameter(const nsACString& aParamValue, const char* aCharset,
+                        const char* aDefaultCharset, bool aOverrideCharset,
+                        bool aDecode2047, nsACString& aResult)
+{
+  aResult.Truncate();
+  // If aCharset is given, aParamValue was obtained from RFC2231/5987 
+  // encoding and we're pretty sure that it's in aCharset.
+  if (aCharset && *aCharset)
+  {
+    nsCOMPtr<nsIUTF8ConverterService> cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID));
+    if (cvtUTF8)
+      return cvtUTF8->ConvertStringToUTF8(aParamValue, aCharset,
+          true, true, 1, aResult);
+  }
+
+  const nsAFlatCString& param = PromiseFlatCString(aParamValue);
+  nsAutoCString unQuoted;
+  nsACString::const_iterator s, e;
+  param.BeginReading(s);
+  param.EndReading(e);
+
+  // strip '\' when used to quote CR, LF, '"' and '\'
+  for ( ; s != e; ++s) {
+    if ((*s == '\\')) {
+      if (++s == e) {
+        --s; // '\' is at the end. move back and append '\'.
+      }
+      else if (*s != nsCRT::CR && *s != nsCRT::LF && *s != '"' && *s != '\\') {
+        --s; // '\' is not foll. by CR,LF,'"','\'. move back and append '\'
+      }
+      // else : skip '\' and append the quoted character.
+    }
+    unQuoted.Append(*s);
+  }
+
+  aResult = unQuoted;
+  nsresult rv = NS_OK;
+  
+  if (aDecode2047) {
+    nsAutoCString decoded;
+
+    // Try RFC 2047 encoding, instead.
+    rv = internalDecodeRFC2047Header(unQuoted.get(), aDefaultCharset,
+                                     aOverrideCharset, true, decoded);
+
+    if (NS_SUCCEEDED(rv) && !decoded.IsEmpty())
+      aResult = decoded;
+  }
+    
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMIMEHeaderParamImpl::DecodeParameter(const nsACString& aParamValue,
+                                       const char* aCharset,
+                                       const char* aDefaultCharset,
+                                       bool aOverrideCharset,
+                                       nsACString& aResult)
+{
+  return internalDecodeParameter(aParamValue, aCharset, aDefaultCharset,
+                                 aOverrideCharset, true, aResult);
+}
+
+#define ISHEXCHAR(c) \
+        ((0x30 <= uint8_t(c) && uint8_t(c) <= 0x39)  ||  \
+         (0x41 <= uint8_t(c) && uint8_t(c) <= 0x46)  ||  \
+         (0x61 <= uint8_t(c) && uint8_t(c) <= 0x66))
+
+// Decode Q encoding (RFC 2047).
+// static
+char *DecodeQ(const char *in, uint32_t length)
+{
+  char *out, *dest = 0;
+
+  out = dest = (char *)PR_Calloc(length + 1, sizeof(char));
+  if (dest == nullptr)
+    return nullptr;
+  while (length > 0) {
+    unsigned c = 0;
+    switch (*in) {
+    case '=':
+      // check if |in| in the form of '=hh'  where h is [0-9a-fA-F].
+      if (length < 3 || !ISHEXCHAR(in[1]) || !ISHEXCHAR(in[2]))
+        goto badsyntax;
+      PR_sscanf(in + 1, "%2X", &c);
+      *out++ = (char) c;
+      in += 3;
+      length -= 3;
+      break;
+
+    case '_':
+      *out++ = ' ';
+      in++;
+      length--;
+      break;
+
+    default:
+      if (*in & 0x80) goto badsyntax;
+      *out++ = *in++;
+      length--;
+    }
+  }
+  *out++ = '\0';
+
+  for (out = dest; *out ; ++out) {
+    if (*out == '\t')
+      *out = ' ';
+  }
+
+  return dest;
+
+ badsyntax:
+  PR_Free(dest);
+  return nullptr;
+}
+
+// check if input is HZ (a 7bit encoding for simplified Chinese : RFC 1842)) 
+// or has  ESC which may be an  indication that  it's in one of many ISO 
+// 2022 7bit  encodings (e.g. ISO-2022-JP(-2)/CN : see RFC 1468, 1922, 1554).
+// static
+bool Is7bitNonAsciiString(const char *input, uint32_t len)
+{
+  int32_t c;
+
+  enum { hz_initial, // No HZ seen yet
+         hz_escaped, // Inside an HZ ~{ escape sequence 
+         hz_seen, // Have seen at least one complete HZ sequence 
+         hz_notpresent // Have seen something that is not legal HZ
+  } hz_state;
+
+  hz_state = hz_initial;
+  while (len) {
+    c = uint8_t(*input++);
+    len--;
+    if (c & 0x80) return false;
+    if (c == 0x1B) return true;
+    if (c == '~') {
+      switch (hz_state) {
+      case hz_initial:
+      case hz_seen:
+        if (*input == '{') {
+          hz_state = hz_escaped;
+        } else if (*input == '~') {
+          // ~~ is the HZ encoding of ~.  Skip over second ~ as well
+          hz_state = hz_seen;
+          input++;
+          len--;
+        } else {
+          hz_state = hz_notpresent;
+        }
+        break;
+
+      case hz_escaped:
+        if (*input == '}') hz_state = hz_seen;
+        break;
+      default:
+        break;
+      }
+    }
+  }
+  return hz_state == hz_seen;
+}
+
+#define REPLACEMENT_CHAR "\357\277\275" // EF BF BD (UTF-8 encoding of U+FFFD)
+
+// copy 'raw' sequences of octets in aInput to aOutput.
+// If aDefaultCharset is specified, the input is assumed to be in the
+// charset and converted to UTF-8. Otherwise, a blind copy is made.
+// If aDefaultCharset is specified, but the conversion to UTF-8
+// is not successful, each octet is replaced by Unicode replacement
+// chars. *aOutput is advanced by the number of output octets.
+// static
+void CopyRawHeader(const char *aInput, uint32_t aLen, 
+                   const char *aDefaultCharset, nsACString &aOutput)
+{
+  int32_t c;
+
+  // If aDefaultCharset is not specified, make a blind copy.
+  if (!aDefaultCharset || !*aDefaultCharset) {
+    aOutput.Append(aInput, aLen);
+    return;
+  }
+
+  // Copy as long as it's US-ASCII.  An ESC may indicate ISO 2022
+  // A ~ may indicate it is HZ
+  while (aLen && (c = uint8_t(*aInput++)) != 0x1B && c != '~' && !(c & 0x80)) {
+    aOutput.Append(char(c));
+    aLen--;
+  }
+  if (!aLen) {
+    return;
+  }
+  aInput--;
+
+  // skip ASCIIness/UTF8ness test if aInput is supected to be a 7bit non-ascii
+  // string and aDefaultCharset is a 7bit non-ascii charset.
+  bool skipCheck = (c == 0x1B || c == '~') && 
+                     IS_7BIT_NON_ASCII_CHARSET(aDefaultCharset);
+
+  // If not UTF-8, treat as default charset
+  nsCOMPtr<nsIUTF8ConverterService> 
+    cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID));
+  nsAutoCString utf8Text;
+  if (cvtUTF8 &&
+      NS_SUCCEEDED(
+      cvtUTF8->ConvertStringToUTF8(Substring(aInput, aInput + aLen), 
+                                   aDefaultCharset, skipCheck, true, 1,
+                                   utf8Text))) {
+    aOutput.Append(utf8Text);
+  } else { // replace each octet with Unicode replacement char in UTF-8.
+    for (uint32_t i = 0; i < aLen; i++) {
+      c = uint8_t(*aInput++);
+      if (c & 0x80)
+        aOutput.Append(REPLACEMENT_CHAR);
+      else
+        aOutput.Append(char(c));
+    }
+  }
+}
+
+nsresult DecodeQOrBase64Str(const char *aEncoded, size_t aLen, char aQOrBase64,
+                            const char *aCharset, nsACString &aResult)
+{
+  char *decodedText;
+  NS_ASSERTION(aQOrBase64 == 'Q' || aQOrBase64 == 'B', "Should be 'Q' or 'B'");
+  if(aQOrBase64 == 'Q')
+    decodedText = DecodeQ(aEncoded, aLen);
+  else if (aQOrBase64 == 'B') {
+    decodedText = PL_Base64Decode(aEncoded, aLen, nullptr);
+  } else {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  if (!decodedText) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIUTF8ConverterService>
+    cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID, &rv));
+  nsAutoCString utf8Text;
+  if (NS_SUCCEEDED(rv)) {
+    // skip ASCIIness/UTF8ness test if aCharset is 7bit non-ascii charset.
+    rv = cvtUTF8->ConvertStringToUTF8(nsDependentCString(decodedText),
+                                      aCharset,
+                                      IS_7BIT_NON_ASCII_CHARSET(aCharset),
+                                      true, 1, utf8Text);
+  }
+  PR_Free(decodedText);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  aResult.Append(utf8Text);
+
+  return NS_OK;
+}
+
+static const char especials[] = R"(()<>@,;:\"/[]?.=)";
+
+// |decode_mime_part2_str| taken from comi18n.c
+// Decode RFC2047-encoded words in the input and convert the result to UTF-8.
+// If aOverrideCharset is true, charset in RFC2047-encoded words is 
+// ignored and aDefaultCharset is assumed, instead. aDefaultCharset
+// is also used to convert raw octets (without RFC 2047 encoding) to UTF-8.
+//static
+nsresult DecodeRFC2047Str(const char *aHeader, const char *aDefaultCharset, 
+                          bool aOverrideCharset, nsACString &aResult)
+{
+  const char *p, *q = nullptr, *r;
+  const char *begin; // tracking pointer for where we are in the input buffer
+  int32_t isLastEncodedWord = 0;
+  const char *charsetStart, *charsetEnd;
+  nsAutoCString prevCharset, curCharset;
+  nsAutoCString encodedText;
+  char prevEncoding = '\0', curEncoding;
+  nsresult rv;
+
+  begin = aHeader;
+
+  // To avoid buffer realloc, if possible, set capacity in advance. No 
+  // matter what,  more than 3x expansion can never happen for all charsets
+  // supported by Mozilla. SCSU/BCSU with the sliding window set to a
+  // non-BMP block may be exceptions, but Mozilla does not support them. 
+  // Neither any known mail/news program use them. Even if there's, we're
+  // safe because we don't use a raw *char any more.
+  aResult.SetCapacity(3 * strlen(aHeader));
+
+  while ((p = PL_strstr(begin, "=?")) != 0) {
+    if (isLastEncodedWord) {
+      // See if it's all whitespace.
+      for (q = begin; q < p; ++q) {
+        if (!PL_strchr(" \t\r\n", *q)) break;
+      }
+    }
+
+    if (!isLastEncodedWord || q < p) {
+      if (!encodedText.IsEmpty()) {
+        rv = DecodeQOrBase64Str(encodedText.get(), encodedText.Length(),
+                                prevEncoding, prevCharset.get(), aResult);
+        if (NS_FAILED(rv)) {
+          aResult.Append(encodedText);
+        }
+        encodedText.Truncate();
+        prevCharset.Truncate();
+        prevEncoding = '\0';
+      }
+      // copy the part before the encoded-word
+      CopyRawHeader(begin, p - begin, aDefaultCharset, aResult);
+      begin = p;
+    }
+
+    p += 2;
+
+    // Get charset info
+    charsetStart = p;
+    charsetEnd = 0;
+    for (q = p; *q != '?'; q++) {
+      if (*q <= ' ' || PL_strchr(especials, *q)) {
+        goto badsyntax;
+      }
+
+      // RFC 2231 section 5
+      if (!charsetEnd && *q == '*') {
+        charsetEnd = q; 
+      }
+    }
+    if (!charsetEnd) {
+      charsetEnd = q;
+    }
+
+    q++;
+    curEncoding = nsCRT::ToUpper(*q);
+    if (curEncoding != 'Q' && curEncoding != 'B')
+      goto badsyntax;
+
+    if (q[1] != '?')
+      goto badsyntax;
+
+    // loop-wise, keep going until we hit "?=".  the inner check handles the
+    //  nul terminator should the string terminate before we hit the right
+    //  marker.  (And the r[1] will never reach beyond the end of the string
+    //  because *r != '?' is true if r is the nul character.)
+    for (r = q + 2; *r != '?' || r[1] != '='; r++) {
+      if (*r < ' ') goto badsyntax;
+    }
+    if (r == q + 2) {
+        // it's empty, skip
+        begin = r + 2;
+        isLastEncodedWord = 1;
+        continue;
+    }
+
+    curCharset.Assign(charsetStart, charsetEnd - charsetStart);
+    // Override charset if requested.  Never override labeled UTF-8.
+    // Use default charset instead of UNKNOWN-8BIT
+    if ((aOverrideCharset && 0 != nsCRT::strcasecmp(curCharset.get(), "UTF-8"))
+    || (aDefaultCharset && 0 == nsCRT::strcasecmp(curCharset.get(), "UNKNOWN-8BIT"))
+    ) {
+      curCharset = aDefaultCharset;
+    }
+
+    const char *R;
+    R = r;
+    if (curEncoding == 'B') {
+      // bug 227290. ignore an extraneous '=' at the end.
+      // (# of characters in B-encoded part has to be a multiple of 4)
+      int32_t n = r - (q + 2);
+      R -= (n % 4 == 1 && !PL_strncmp(r - 3, "===", 3)) ? 1 : 0;
+    }
+    // Bug 493544. Don't decode the encoded text until it ends
+    if (R[-1] != '='
+      && (prevCharset.IsEmpty()
+        || (curCharset == prevCharset && curEncoding == prevEncoding))
+    ) {
+      encodedText.Append(q + 2, R - (q + 2));
+      prevCharset = curCharset;
+      prevEncoding = curEncoding;
+
+      begin = r + 2;
+      isLastEncodedWord = 1;
+      continue;
+    }
+
+    bool bDecoded; // If the current line has been decoded.
+    bDecoded = false;
+    if (!encodedText.IsEmpty()) {
+      if (curCharset == prevCharset && curEncoding == prevEncoding) {
+        encodedText.Append(q + 2, R - (q + 2));
+        bDecoded = true;
+      }
+      rv = DecodeQOrBase64Str(encodedText.get(), encodedText.Length(),
+                              prevEncoding, prevCharset.get(), aResult);
+      if (NS_FAILED(rv)) {
+        aResult.Append(encodedText);
+      }
+      encodedText.Truncate();
+      prevCharset.Truncate();
+      prevEncoding = '\0';
+    }
+    if (!bDecoded) {
+      rv = DecodeQOrBase64Str(q + 2, R - (q + 2), curEncoding,
+                              curCharset.get(), aResult);
+      if (NS_FAILED(rv)) {
+        aResult.Append(encodedText);
+      }
+    }
+
+    begin = r + 2;
+    isLastEncodedWord = 1;
+    continue;
+
+  badsyntax:
+    if (!encodedText.IsEmpty()) {
+      rv = DecodeQOrBase64Str(encodedText.get(), encodedText.Length(),
+                              prevEncoding, prevCharset.get(), aResult);
+      if (NS_FAILED(rv)) {
+        aResult.Append(encodedText);
+      }
+      encodedText.Truncate();
+      prevCharset.Truncate();
+    }
+    // copy the part before the encoded-word
+    aResult.Append(begin, p - begin);
+    begin = p;
+    isLastEncodedWord = 0;
+  }
+
+  if (!encodedText.IsEmpty()) {
+    rv = DecodeQOrBase64Str(encodedText.get(), encodedText.Length(),
+                            prevEncoding, prevCharset.get(), aResult);
+    if (NS_FAILED(rv)) {
+      aResult.Append(encodedText);
+    }
+  }
+
+  // put the tail back
+  CopyRawHeader(begin, strlen(begin), aDefaultCharset, aResult);
+
+  nsAutoCString tempStr(aResult);
+  tempStr.ReplaceChar('\t', ' ');
+  aResult = tempStr;
+
+  return NS_OK;
+}
diff --git a/netwerk/mime/nsMIMEHeaderParamImpl.h b/netwerk/mime/nsMIMEHeaderParamImpl.h
new file mode 100644
index 000000000..8918ee327
--- /dev/null
+++ b/netwerk/mime/nsMIMEHeaderParamImpl.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "nsIMIMEHeaderParam.h"
+
+#ifndef __nsmimeheaderparamimpl_h___
+#define __nsmimeheaderparamimpl_h___
+class nsMIMEHeaderParamImpl : public nsIMIMEHeaderParam
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMIMEHEADERPARAM
+
+  nsMIMEHeaderParamImpl() {}
+private:
+  virtual ~nsMIMEHeaderParamImpl() {}
+  enum ParamDecoding {
+    MIME_FIELD_ENCODING = 1,
+    HTTP_FIELD_ENCODING
+  }; 
+
+  nsresult DoGetParameter(const nsACString& aHeaderVal, 
+                          const char *aParamName,
+                          ParamDecoding aDecoding,
+                          const nsACString& aFallbackCharset, 
+                          bool aTryLocaleCharset, 
+                          char **aLang, 
+                          nsAString& aResult);
+
+  nsresult DoParameterInternal(const char *aHeaderValue, 
+                               const char *aParamName,
+                               ParamDecoding aDecoding,
+                               char **aCharset,
+                               char **aLang,
+                               char **aResult);
+
+};
+
+#endif 
+
diff --git a/netwerk/mime/nsMimeTypes.h b/netwerk/mime/nsMimeTypes.h
new file mode 100644
index 000000000..098499a14
--- /dev/null
+++ b/netwerk/mime/nsMimeTypes.h
@@ -0,0 +1,229 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+/*
+ * This interface allows any module to access the encoder/decoder 
+ * routines for RFC822 headers. This will allow any mail/news module
+ * to call on these routines.
+ */
+#ifndef nsMimeTypes_h_
+#define nsMimeTypes_h_
+
+/* Defines for various MIME content-types and encodings.
+   Whenever you type in a content-type, you should use one of these defines
+   instead, to help catch typos, and make central management of them easier.
+ */
+
+#define ANY_WILDCARD                        "*/*"
+#define AUDIO_WILDCARD                      "audio/*"
+#define IMAGE_WILDCARD                      "image/*"
+
+#define APPLICATION_APPLEFILE               "application/applefile"
+#define APPLICATION_BINHEX                  "application/mac-binhex40"
+#define APPLICATION_MACBINARY               "application/x-macbinary"
+#define APPLICATION_COMPRESS                "application/x-compress"
+#define APPLICATION_COMPRESS2               "application/compress"
+#define APPLICATION_FORTEZZA_CKL            "application/x-fortezza-ckl"
+#define APPLICATION_FORTEZZA_KRL            "application/x-fortezza-krl"
+#define APPLICATION_GZIP                    "application/x-gzip"
+#define APPLICATION_GZIP2                   "application/gzip"
+#define APPLICATION_GZIP3                   "application/x-gunzip"
+#define APPLICATION_BROTLI                  "application/brotli"
+#define APPLICATION_ZIP                     "application/zip"
+#define APPLICATION_HTTP_INDEX_FORMAT       "application/http-index-format"
+#define APPLICATION_ECMASCRIPT              "application/ecmascript"
+#define APPLICATION_JAVASCRIPT              "application/javascript"
+#define APPLICATION_XJAVASCRIPT             "application/x-javascript"
+#define APPLICATION_JSON                    "application/json"
+#define APPLICATION_NETSCAPE_REVOCATION     "application/x-netscape-revocation"
+#define APPLICATION_NS_PROXY_AUTOCONFIG     "application/x-ns-proxy-autoconfig"
+#define APPLICATION_NS_JAVASCRIPT_AUTOCONFIG        "application/x-javascript-config"
+#define APPLICATION_OCTET_STREAM            "application/octet-stream"
+#define APPLICATION_PGP                     "application/pgp"
+#define APPLICATION_PGP2                    "application/x-pgp-message"
+#define APPLICATION_POSTSCRIPT              "application/postscript"
+#define APPLICATION_PDF                     "application/pdf"
+#define APPLICATION_PRE_ENCRYPTED           "application/pre-encrypted"
+#define APPLICATION_RDF                     "application/rdf+xml"
+#define APPLICATION_UUENCODE                "application/x-uuencode"
+#define APPLICATION_UUENCODE2               "application/x-uue"
+#define APPLICATION_UUENCODE3               "application/uuencode"
+#define APPLICATION_UUENCODE4               "application/uue"
+#define APPLICATION_X509_CA_CERT            "application/x-x509-ca-cert"
+#define APPLICATION_X509_SERVER_CERT        "application/x-x509-server-cert"
+#define APPLICATION_X509_EMAIL_CERT         "application/x-x509-email-cert"
+#define APPLICATION_X509_USER_CERT          "application/x-x509-user-cert"
+#define APPLICATION_X509_CRL                "application/x-pkcs7-crl"
+#define APPLICATION_XPKCS7_MIME             "application/x-pkcs7-mime"
+#define APPLICATION_PKCS7_MIME              "application/pkcs7-mime"
+#define APPLICATION_XPKCS7_SIGNATURE        "application/x-pkcs7-signature"
+#define APPLICATION_PKCS7_SIGNATURE         "application/pkcs7-signature"
+#define APPLICATION_WWW_FORM_URLENCODED     "application/x-www-form-urlencoded"
+#define APPLICATION_OLEOBJECT               "application/oleobject"
+#define APPLICATION_OLEOBJECT2              "application/x-oleobject"
+#define APPLICATION_JAVAARCHIVE             "application/java-archive"
+#define APPLICATION_MARIMBA                 "application/marimba"
+#define APPLICATION_WEB_MANIFEST            "application/manifest+json"
+#define APPLICATION_XMARIMBA                "application/x-marimba"
+#define APPLICATION_XPINSTALL               "application/x-xpinstall"
+#define APPLICATION_XML                     "application/xml"
+#define APPLICATION_XHTML_XML               "application/xhtml+xml"
+#define APPLICATION_XSLT_XML                "application/xslt+xml"
+#define APPLICATION_MATHML_XML              "application/mathml+xml"
+#define APPLICATION_RDF_XML                 "application/rdf+xml"
+#define APPLICATION_WAPXHTML_XML            "application/vnd.wap.xhtml+xml"
+#define APPLICATION_PACKAGE                 "application/package"
+
+#define AUDIO_BASIC                         "audio/basic"
+#define AUDIO_OGG                           "audio/ogg"
+#define AUDIO_WAV                           "audio/x-wav"
+#define AUDIO_WEBM                          "audio/webm"
+#define AUDIO_MP3                           "audio/mpeg"
+#define AUDIO_MP4                           "audio/mp4"
+#define AUDIO_AMR                           "audio/amr"
+#define AUDIO_FLAC                          "audio/flac"
+#define AUDIO_3GPP                          "audio/3gpp"
+#define AUDIO_3GPP2                         "audio/3gpp2"
+#define AUDIO_MIDI                          "audio/x-midi"
+#define AUDIO_MATROSKA                      "audio/x-matroska"
+#define AUDIO_FLAC                          "audio/flac"
+
+#define BINARY_OCTET_STREAM                 "binary/octet-stream"
+
+#define IMAGE_GIF                           "image/gif"
+#define IMAGE_JPEG                          "image/jpeg"
+#define IMAGE_JPG                           "image/jpg"
+#define IMAGE_PJPEG                         "image/pjpeg"
+#define IMAGE_PNG                           "image/png"
+#define IMAGE_APNG                          "image/apng"
+#define IMAGE_X_PNG                         "image/x-png"
+#define IMAGE_PPM                           "image/x-portable-pixmap"
+#define IMAGE_XBM                           "image/x-xbitmap"
+#define IMAGE_XBM2                          "image/x-xbm"
+#define IMAGE_XBM3                          "image/xbm"
+#define IMAGE_ART                           "image/x-jg"
+#define IMAGE_TIFF                          "image/tiff"
+#define IMAGE_BMP                           "image/bmp"
+#define IMAGE_BMP_MS                        "image/x-ms-bmp"
+#define IMAGE_ICO                           "image/x-icon"
+#define IMAGE_ICO_MS                        "image/vnd.microsoft.icon"
+#define IMAGE_ICON_MS                       "image/icon"
+#define IMAGE_MNG                           "video/x-mng"
+#define IMAGE_JNG                           "image/x-jng"
+#define IMAGE_SVG_XML                       "image/svg+xml"
+
+#define MESSAGE_EXTERNAL_BODY               "message/external-body"
+#define MESSAGE_NEWS                        "message/news"
+#define MESSAGE_RFC822                      "message/rfc822"
+
+#define MULTIPART_ALTERNATIVE               "multipart/alternative"
+#define MULTIPART_APPLEDOUBLE               "multipart/appledouble"
+#define MULTIPART_DIGEST                    "multipart/digest"
+#define MULTIPART_FORM_DATA                 "multipart/form-data"
+#define MULTIPART_HEADER_SET                "multipart/header-set"
+#define MULTIPART_MIXED                     "multipart/mixed"
+#define MULTIPART_PARALLEL                  "multipart/parallel"
+#define MULTIPART_SIGNED                    "multipart/signed"
+#define MULTIPART_RELATED                   "multipart/related"
+#define MULTIPART_MIXED_REPLACE             "multipart/x-mixed-replace"
+#define MULTIPART_BYTERANGES                "multipart/byteranges"
+
+#define SUN_ATTACHMENT                      "x-sun-attachment"
+
+#define TEXT_ENRICHED                       "text/enriched"
+#define TEXT_CALENDAR                       "text/calendar"
+#define TEXT_HTML                           "text/html"
+#define TEXT_MDL                            "text/mdl"
+#define TEXT_PLAIN                          "text/plain"
+#define TEXT_RICHTEXT                       "text/richtext"
+#define TEXT_VCARD                          "text/vcard"
+#define TEXT_CSS                            "text/css"
+#define TEXT_JSSS                           "text/jsss"
+#define TEXT_JSON                           "text/json"
+#define TEXT_XML                            "text/xml"
+#define TEXT_RDF                            "text/rdf"
+#define TEXT_VTT                            "text/vtt"
+#define TEXT_XUL                            "application/vnd.mozilla.xul+xml"
+#define TEXT_ECMASCRIPT                     "text/ecmascript"
+#define TEXT_JAVASCRIPT                     "text/javascript"
+#define TEXT_XSL                            "text/xsl"
+#define TEXT_EVENT_STREAM                   "text/event-stream"
+#define TEXT_CACHE_MANIFEST                 "text/cache-manifest"
+
+#define VIDEO_MPEG                          "video/mpeg"
+#define VIDEO_MP4                           "video/mp4"
+#define VIDEO_QUICKTIME                     "video/quicktime"
+#define VIDEO_RAW                           "video/x-raw-yuv"
+#define VIDEO_OGG                           "video/ogg"
+#define VIDEO_WEBM                          "video/webm"
+#define VIDEO_3GPP                          "video/3gpp"
+#define VIDEO_3GPP2                         "video/3gpp2"
+#define VIDEO_MPEG_TS                       "video/mp2t"
+#define VIDEO_AVI                           "video/avi"
+#define VIDEO_MATROSKA                      "video/x-matroska"
+#define APPLICATION_OGG                     "application/ogg"
+
+/* x-uuencode-apple-single. QuickMail made me do this. */
+#define UUENCODE_APPLE_SINGLE               "x-uuencode-apple-single"
+
+/* The standard MIME message-content-encoding values:
+ */
+#define ENCODING_7BIT                       "7bit"
+#define ENCODING_8BIT                       "8bit"
+#define ENCODING_BINARY                     "binary"
+#define ENCODING_BASE64                     "base64"
+#define ENCODING_QUOTED_PRINTABLE           "quoted-printable"
+
+/* Some nonstandard encodings.  Note that the names are TOTALLY RANDOM,
+   and code that looks for these in network-provided data must look for
+   all the possibilities.
+ */
+#define ENCODING_COMPRESS                   "x-compress"
+#define ENCODING_COMPRESS2                  "compress"
+#define ENCODING_ZLIB                       "x-zlib"
+#define ENCODING_ZLIB2                      "zlib"
+#define ENCODING_GZIP                       "x-gzip"
+#define ENCODING_GZIP2                      "gzip"
+#define ENCODING_DEFLATE                    "x-deflate"
+#define ENCODING_DEFLATE2                   "deflate"
+#define ENCODING_UUENCODE                   "x-uuencode"
+#define ENCODING_UUENCODE2                  "x-uue"
+#define ENCODING_UUENCODE3                  "uuencode"
+#define ENCODING_UUENCODE4                  "uue"
+#define ENCODING_YENCODE                    "x-yencode"
+
+/* Some names of parameters that various MIME headers include.
+ */
+#define PARAM_PROTOCOL                      "protocol"
+#define PARAM_MICALG                        "micalg"
+#define PARAM_MICALG_MD2                    "rsa-md2"
+#define PARAM_MICALG_MD5                    "rsa-md5"
+#define PARAM_MICALG_MD5_2                  "md5"
+#define PARAM_MICALG_SHA1                   "sha1"
+#define PARAM_MICALG_SHA1_2                 "sha-1"
+#define PARAM_MICALG_SHA1_3                 "rsa-sha1"
+#define PARAM_MICALG_SHA1_4                 "rsa-sha-1"
+#define PARAM_MICALG_SHA1_5                 "rsa-sha"
+#define PARAM_MICALG_SHA256                 "sha-256"
+#define PARAM_MICALG_SHA256_2               "sha256"
+#define PARAM_MICALG_SHA256_3               "2.16.840.1.101.3.4.2.1"
+#define PARAM_MICALG_SHA384                 "sha-384"
+#define PARAM_MICALG_SHA384_2               "sha384"
+#define PARAM_MICALG_SHA384_3               "2.16.840.1.101.3.4.2.2"
+#define PARAM_MICALG_SHA512                 "sha-512"
+#define PARAM_MICALG_SHA512_2               "sha512"
+#define PARAM_MICALG_SHA512_3               "2.16.840.1.101.3.4.2.3"
+#define PARAM_X_MAC_CREATOR                 "x-mac-creator"
+#define PARAM_X_MAC_TYPE                    "x-mac-type"
+#define PARAM_FORMAT                        "format"
+
+#define UNKNOWN_CONTENT_TYPE                "application/x-unknown-content-type"
+#define APPLICATION_GUESS_FROM_EXT          "application/x-vnd.mozilla.guess-from-ext"
+#define VIEWSOURCE_CONTENT_TYPE             "application/x-view-source"
+
+#define APPLICATION_DIRECTORY				        "application/directory" /* text/x-vcard is synonym */
+#define APPLICATION_CACHED_XUL              "mozilla.application/cached-xul"
+
+#endif /* nsMimeTypes_h_ */