--- a/python/mozbuild/mozpack/packager/__init__.py
+++ b/python/mozbuild/mozpack/packager/__init__.py
@@ -5,17 +5,16 @@
 from __future__ import absolute_import
 
 from mozbuild.preprocessor import Preprocessor
 import re
 import os
 from mozpack.errors import errors
 from mozpack.chrome.manifest import (
     Manifest,
-    ManifestBinaryComponent,
     ManifestChrome,
     ManifestInterfaces,
     is_manifest,
     parse_manifest,
 )
 import mozpack.path as mozpath
 from collections import deque
 
@@ -241,40 +240,29 @@ class SimplePackager(object):
         # should be packed or unpacked)
         self._addons = {}
         # All manifest paths imported.
         self._manifests = set()
         # All manifest paths included from some other manifest.
         self._included_manifests = {}
         self._closed = False
 
-    # Parsing RDF is complex, and would require an external library to do
-    # properly. Just go with some hackish but probably sufficient regexp
-    UNPACK_ADDON_RE = re.compile(r'''(?:
-        <em:unpack>true</em:unpack>
-        |em:unpack=(?P<quote>["']?)true(?P=quote)
-    )''', re.VERBOSE)
-
     def add(self, path, file):
         '''
         Add the given BaseFile instance with the given path.
         '''
         assert not self._closed
         if is_manifest(path):
             self._add_manifest_file(path, file)
         elif path.endswith('.xpt'):
             self._queue.append(self.formatter.add_interfaces, path, file)
         else:
             self._file_queue.append(self.formatter.add, path, file)
             if mozpath.basename(path) == 'install.rdf':
-                addon = True
-                install_rdf = file.open().read()
-                if self.UNPACK_ADDON_RE.search(install_rdf):
-                    addon = 'unpacked'
-                self._addons[mozpath.dirname(path)] = addon
+                self._addons[mozpath.dirname(path)] = True
 
     def _add_manifest_file(self, path, file):
         '''
         Add the given BaseFile with manifest file contents with the given path.
         '''
         self._manifests.add(path)
         base = ''
         if hasattr(file, 'path'):
@@ -286,22 +274,16 @@ class SimplePackager(object):
             # ManifestResources need to be given after ManifestChrome, so just
             # put all ManifestChrome in a separate queue to make them first.
             if isinstance(e, ManifestChrome):
                 # e.move(e.base) just returns a clone of the entry.
                 self._chrome_queue.append(self.formatter.add_manifest,
                                           e.move(e.base))
             elif not isinstance(e, (Manifest, ManifestInterfaces)):
                 self._queue.append(self.formatter.add_manifest, e.move(e.base))
-            # If a binary component is added to an addon, prevent the addon
-            # from being packed.
-            if isinstance(e, ManifestBinaryComponent):
-                addon = mozpath.basedir(e.base, self._addons)
-                if addon:
-                    self._addons[addon] = 'unpacked'
             if isinstance(e, Manifest):
                 if e.flags:
                     errors.fatal('Flags are not supported on ' +
                                  '"manifest" entries')
                 self._included_manifests[e.path] = path
 
     def get_bases(self, addons=True):
         '''

--- a/python/mozbuild/mozpack/test/test_packager.py
+++ b/python/mozbuild/mozpack/test/test_packager.py
@@ -9,17 +9,16 @@ from mozpack.packager import (
     preprocess_manifest,
     CallDeque,
     Component,
     SimplePackager,
     SimpleManifestSink,
 )
 from mozpack.files import GeneratedFile
 from mozpack.chrome.manifest import (
-    ManifestBinaryComponent,
     ManifestContent,
     ManifestResource,
 )
 from mozunit import MockedOpen
 from mozbuild.preprocessor import Preprocessor
 from mozpack.errors import (
     errors,
     ErrorMessage,
@@ -146,20 +145,17 @@ class TestSimplePackager(unittest.TestCa
         file = GeneratedFileWithPath(os.path.join(curdir, 'foo',
                                                   'baz.manifest'),
                                      'resource baz baz/')
         with errors.context('manifest', 2):
             packager.add('bar/baz.manifest', file)
 
         with errors.context('manifest', 3):
             packager.add('qux/qux.manifest',
-                         GeneratedFile(''.join([
-                            'resource qux qux/\n',
-                            'binary-component qux.so\n',
-                         ])))
+                         GeneratedFile('resource qux qux/\n'))
         bar_xpt = GeneratedFile('bar.xpt')
         qux_xpt = GeneratedFile('qux.xpt')
         foo_html = GeneratedFile('foo_html')
         bar_html = GeneratedFile('bar_html')
         with errors.context('manifest', 4):
             packager.add('foo/bar.xpt', bar_xpt)
         with errors.context('manifest', 5):
             packager.add('foo/bar/foo.html', foo_html)
@@ -180,134 +176,46 @@ class TestSimplePackager(unittest.TestCa
                                      'resource hoge hoge/')
         with errors.context('manifest', 8):
             packager.add('addon/chrome.manifest', file)
 
         install_rdf = GeneratedFile('<RDF></RDF>')
         with errors.context('manifest', 9):
             packager.add('addon/install.rdf', install_rdf)
 
-        with errors.context('manifest', 10):
-            packager.add('addon2/install.rdf', install_rdf)
-            packager.add('addon2/chrome.manifest',
-                         GeneratedFile('binary-component addon2.so'))
-
-        with errors.context('manifest', 11):
-            packager.add('addon3/install.rdf', install_rdf)
-            packager.add('addon3/chrome.manifest', GeneratedFile(
-                'manifest components/components.manifest'))
-            packager.add('addon3/components/components.manifest',
-                         GeneratedFile('binary-component addon3.so'))
-
-        with errors.context('manifest', 12):
-            install_rdf_addon4 = GeneratedFile(
-                '<RDF>\n<...>\n<em:unpack>true</em:unpack>\n<...>\n</RDF>')
-            packager.add('addon4/install.rdf', install_rdf_addon4)
-
-        with errors.context('manifest', 13):
-            install_rdf_addon5 = GeneratedFile(
-                '<RDF>\n<...>\n<em:unpack>false</em:unpack>\n<...>\n</RDF>')
-            packager.add('addon5/install.rdf', install_rdf_addon5)
-
-        with errors.context('manifest', 14):
-            install_rdf_addon6 = GeneratedFile(
-                '<RDF>\n<... em:unpack=true>\n<...>\n</RDF>')
-            packager.add('addon6/install.rdf', install_rdf_addon6)
-
-        with errors.context('manifest', 15):
-            install_rdf_addon7 = GeneratedFile(
-                '<RDF>\n<... em:unpack=false>\n<...>\n</RDF>')
-            packager.add('addon7/install.rdf', install_rdf_addon7)
-
-        with errors.context('manifest', 16):
-            install_rdf_addon8 = GeneratedFile(
-                '<RDF>\n<... em:unpack="true">\n<...>\n</RDF>')
-            packager.add('addon8/install.rdf', install_rdf_addon8)
-
-        with errors.context('manifest', 17):
-            install_rdf_addon9 = GeneratedFile(
-                '<RDF>\n<... em:unpack="false">\n<...>\n</RDF>')
-            packager.add('addon9/install.rdf', install_rdf_addon9)
-
-        with errors.context('manifest', 18):
-            install_rdf_addon10 = GeneratedFile(
-                '<RDF>\n<... em:unpack=\'true\'>\n<...>\n</RDF>')
-            packager.add('addon10/install.rdf', install_rdf_addon10)
-
-        with errors.context('manifest', 19):
-            install_rdf_addon11 = GeneratedFile(
-                '<RDF>\n<... em:unpack=\'false\'>\n<...>\n</RDF>')
-            packager.add('addon11/install.rdf', install_rdf_addon11)
-
         self.assertEqual(formatter.log, [])
 
         with errors.context('dummy', 1):
             packager.close()
         self.maxDiff = None
         # The formatter is expected to reorder the manifest entries so that
         # chrome entries appear before the others.
         self.assertEqual(formatter.log, [
             (('dummy', 1), 'add_base', '', False),
             (('dummy', 1), 'add_base', 'addon', True),
-            (('dummy', 1), 'add_base', 'addon10', 'unpacked'),
-            (('dummy', 1), 'add_base', 'addon11', True),
-            (('dummy', 1), 'add_base', 'addon2', 'unpacked'),
-            (('dummy', 1), 'add_base', 'addon3', 'unpacked'),
-            (('dummy', 1), 'add_base', 'addon4', 'unpacked'),
-            (('dummy', 1), 'add_base', 'addon5', True),
-            (('dummy', 1), 'add_base', 'addon6', 'unpacked'),
-            (('dummy', 1), 'add_base', 'addon7', True),
-            (('dummy', 1), 'add_base', 'addon8', 'unpacked'),
-            (('dummy', 1), 'add_base', 'addon9', True),
             (('dummy', 1), 'add_base', 'qux', False),
             ((os.path.join(curdir, 'foo', 'bar.manifest'), 2),
              'add_manifest', ManifestContent('foo', 'bar', 'bar/')),
             ((os.path.join(curdir, 'foo', 'bar.manifest'), 1),
              'add_manifest', ManifestResource('foo', 'bar', 'bar/')),
             (('bar/baz.manifest', 1),
              'add_manifest', ManifestResource('bar', 'baz', 'baz/')),
             (('qux/qux.manifest', 1),
              'add_manifest', ManifestResource('qux', 'qux', 'qux/')),
-            (('qux/qux.manifest', 2),
-             'add_manifest', ManifestBinaryComponent('qux', 'qux.so')),
             (('manifest', 4), 'add_interfaces', 'foo/bar.xpt', bar_xpt),
             (('manifest', 7), 'add_interfaces', 'foo/qux.xpt', qux_xpt),
             ((os.path.join(curdir, 'addon', 'chrome.manifest'), 1),
              'add_manifest', ManifestResource('addon', 'hoge', 'hoge/')),
-            (('addon2/chrome.manifest', 1), 'add_manifest',
-             ManifestBinaryComponent('addon2', 'addon2.so')),
-            (('addon3/components/components.manifest', 1), 'add_manifest',
-             ManifestBinaryComponent('addon3/components', 'addon3.so')),
             (('manifest', 5), 'add', 'foo/bar/foo.html', foo_html),
             (('manifest', 5), 'add', 'foo/bar/bar.html', bar_html),
             (('manifest', 9), 'add', 'addon/install.rdf', install_rdf),
-            (('manifest', 10), 'add', 'addon2/install.rdf', install_rdf),
-            (('manifest', 11), 'add', 'addon3/install.rdf', install_rdf),
-            (('manifest', 12), 'add', 'addon4/install.rdf',
-             install_rdf_addon4),
-            (('manifest', 13), 'add', 'addon5/install.rdf',
-             install_rdf_addon5),
-            (('manifest', 14), 'add', 'addon6/install.rdf',
-             install_rdf_addon6),
-            (('manifest', 15), 'add', 'addon7/install.rdf',
-             install_rdf_addon7),
-            (('manifest', 16), 'add', 'addon8/install.rdf',
-             install_rdf_addon8),
-            (('manifest', 17), 'add', 'addon9/install.rdf',
-             install_rdf_addon9),
-            (('manifest', 18), 'add', 'addon10/install.rdf',
-             install_rdf_addon10),
-            (('manifest', 19), 'add', 'addon11/install.rdf',
-             install_rdf_addon11),
         ])
 
         self.assertEqual(packager.get_bases(),
-                         set(['', 'addon', 'addon2', 'addon3', 'addon4',
-                              'addon5', 'addon6', 'addon7', 'addon8',
-                              'addon9', 'addon10', 'addon11', 'qux']))
+                         set(['', 'addon', 'qux']))
         self.assertEqual(packager.get_bases(addons=False), set(['', 'qux']))
 
     def test_simple_packager_manifest_consistency(self):
         formatter = MockFormatter()
         # bar/ is detected as an addon because of install.rdf, but top-level
         # includes a manifest inside bar/.
         packager = SimplePackager(formatter)
         packager.add('base.manifest', GeneratedFile(