def test_reverse_lookup(): """Test that the chrome reverse lookup function works properly.""" c = ChromeManifest(""" content ns1 /dir1/ content ns2 /dir2/foo/ content nsbad1 /dir3 content ns3 jar:foo.jar!/subdir1/ content ns3 jar:zap.jar!/altdir1/ content ns4 jar:bar.jar!/subdir2 """, "chrome.manifest") eq_(c.reverse_lookup(MockPackStack(), "random.js"), None) eq_(c.reverse_lookup(MockPackStack(), "/dir1/x.js"), "chrome://ns1/x.js") eq_(c.reverse_lookup(MockPackStack(), "/dir2/x.js"), None) eq_(c.reverse_lookup(MockPackStack(), "/dir2/foo/x.js"), "chrome://ns2/x.js") eq_(c.reverse_lookup(MockPackStack(), "/dir3/x.js"), "chrome://nsbad1/x.js") eq_(c.reverse_lookup(MockPackStack(["foo.jar"]), "/x.js"), "chrome://ns3/subdir1/x.js") eq_(c.reverse_lookup(MockPackStack(["foo.jar"]), "/zap/x.js"), "chrome://ns3/subdir1/zap/x.js") eq_(c.reverse_lookup(MockPackStack(["bar.jar"]), "/x.js"), "chrome://ns4/subdir2/x.js") eq_(c.reverse_lookup(MockPackStack(["zap.jar"]), "/x.js"), "chrome://ns3/altdir1/x.js")
def test_reverse_lookup(): """Test that the chrome reverse lookup function works properly.""" c = ChromeManifest(""" content ns1 /dir1/ content ns2 /dir2/foo/ content nsbad1 /dir3 content ns3 jar:foo.jar!/subdir1/ content ns3 jar:zap.jar!/altdir1/ content ns4 jar:bar.jar!/subdir2 """, 'chrome.manifest') assert c.reverse_lookup(MockPackStack(), 'random.js') is None assert c.reverse_lookup(MockPackStack(), '/dir1/x.js') == 'chrome://ns1/x.js' assert c.reverse_lookup(MockPackStack(), '/dir2/x.js') is None assert c.reverse_lookup(MockPackStack(), '/dir2/foo/x.js') == 'chrome://ns2/x.js' assert c.reverse_lookup(MockPackStack(), '/dir3/x.js') == 'chrome://nsbad1/x.js' assert c.reverse_lookup(MockPackStack(['foo.jar']), '/x.js') == 'chrome://ns3/subdir1/x.js' assert c.reverse_lookup(MockPackStack(['foo.jar']), '/zap/x.js') == 'chrome://ns3/subdir1/zap/x.js' assert c.reverse_lookup(MockPackStack(['bar.jar']), '/x.js') == 'chrome://ns4/subdir2/x.js' assert c.reverse_lookup(MockPackStack(['zap.jar']), '/x.js') == 'chrome://ns3/altdir1/x.js'
def _get_locales(err, xpi_package): "Returns a list of locales from the chrome.manifest file." # Retrieve the chrome.manifest if it's cached. if err is not None and \ err.get_resource("chrome.manifest"): # pragma: no cover chrome = err.get_resource("chrome.manifest") else: chrome_data = xpi_package.read("chrome.manifest") chrome = ChromeManifest(chrome_data) if err is not None: err.save_resource("chrome.manifest", chrome) pack_locales = chrome.get_triples("locale") locales = {} # Find all of the locales referenced in the chrome.manifest file. for locale in pack_locales: locale_jar = locale["object"].split() location = locale_jar[-1] if not location.startswith("jar:"): continue full_location = location[4:].split("!") locale_desc = {"predicate": locale["predicate"], "path": full_location[0], "target": full_location[1], "name": locale_jar[0]} locale_name = "%s:%s" % (locale["predicate"], locale_jar[0]) if locale_name not in locales: locales[locale_name] = locale_desc return locales
def _list_locales(err, xpi_package=None): 'Returns a raw list of locales from chrome.manifest' chrome = None if xpi_package is not None: # Handle a reference XPI chrome = ChromeManifest(xpi_package, 'chrome.manifest', err) else: # Handle the current XPI chrome = err.get_resource('chrome.manifest') if not chrome: return None return list(chrome.get_entries('locale'))
def test_duplicate_subjects(): """Test that two triplets with the same subject can be retrieved.""" c = ChromeManifest(""" foo bar abc foo bar def foo bam test oof rab cba """, 'chrome.manifest') assert len(list(c.get_triples(subject='foo'))) == 3 assert len(list(c.get_triples(subject='foo', predicate='bar'))) == 2 assert len(list(c.get_triples(subject='foo', predicate='bar', object_='abc'))) == 1
def _list_locales(err, xpi_package=None): "Returns a raw list of locales from chrome.manifest" chrome = None if xpi_package is not None: # Handle a reference XPI chrome = ChromeManifest(xpi_package.read("chrome.manifest"), "chrome.manifest") else: # Handle the current XPI chrome = err.get_resource("chrome.manifest") if not chrome: return None pack_locales = chrome.get_triples("locale") return list(pack_locales)
def test_lines(): """Test that the correct line numbers are given in a chrome.manifest.""" c = ChromeManifest(""" zero foo bar one bar foo two abc def #comment four def abc """.strip(), 'chrome.manifest') assert list(c.get_triples(subject='zero'))[0]['line'] == 1 assert list(c.get_triples(subject='one'))[0]['line'] == 2 assert list(c.get_triples(subject='two'))[0]['line'] == 3 assert list(c.get_triples(subject='four'))[0]['line'] == 5
def test_lines(): """Test that the correct line numbers are given in a chrome.manifest.""" c = ChromeManifest(""" zero foo bar one bar foo two abc def #comment four def abc """.strip(), "chrome.manifest") eq_(list(c.get_triples(subject="zero"))[0]["line"], 1) eq_(list(c.get_triples(subject="one"))[0]["line"], 2) eq_(list(c.get_triples(subject="two"))[0]["line"], 3) eq_(list(c.get_triples(subject="four"))[0]["line"], 5)
def test_duplicate_subjects(): """Test that two triplets with the same subject can be retrieved.""" c = ChromeManifest(""" foo bar abc foo bar def foo bam test oof rab cba """, "chrome.manifest") assert len(list(c.get_triples(subject="foo"))) == 3 assert len(list(c.get_triples(subject="foo", predicate="bar"))) == 2 assert len(list(c.get_triples(subject="foo", predicate="bar", object_="abc"))) == 1
def test_open(): """Open a chrome file and ensure that data can be pulled from it.""" xpi = MockXPI({ 'chrome.manifest': 'tests/resources/chromemanifest/chrome.manifest'}) manifest = ChromeManifest(xpi, 'chrome.manifest') assert manifest is not None g_obj = list(manifest.get_entries('subject', 'predicate')) assert len(g_obj) == 1 assert g_obj[0]['args'][1] == 'object' sub_locale = list(manifest.get_entries('locale')) assert len(sub_locale) == 2
def get_translation_xpi(request, project_slug, lang_code): """ Compile project's XPI in given language """ project = get_object_or_404(Project, slug=project_slug) language = get_object_or_404(Language, code=lang_code) xpi = get_object_or_404(XpiFile, project=project) zip_orig = zipfile.ZipFile(os.path.join(settings.XPI_DIR,xpi.filename), "r") zip_buffer = StringIO() zip_file = zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED) # copy all the contents from original file except META-INF, # to make it unsigned for item in zip_orig.infolist(): if not (item.filename.startswith('META-INF') or item.filename == 'chrome.manifest'): fn = item.filename data = zip_orig.read(item.filename) zip_file.writestr(item, data) # write our localization for resource in Resource.objects.filter(project=project): template = _compile_translation_template(resource, language) zip_file.writestr("tx-locale/%s/%s" % (lang_code, resource.name), template) chrome_str = zip_orig.read("chrome.manifest") manifest = ChromeManifest(chrome_str, "manifest") zip_file.writestr("chrome.manifest", chrome_str +\ "\nlocale %(predicate)s %(code)s tx-locale/%(code)s/\n" % { 'predicate': list(manifest.get_triples("locale"))[0]['predicate'], 'code': lang_code, }) zip_file.close() zip_buffer.flush() zip_contents = zip_buffer.getvalue() response = HttpResponse(mimetype='application/x-xpinstall') response['Content-Disposition'] = 'filename=%s.xpi' % project_slug response.write(zip_contents) return response
def test_marking_overlays_root_package(): """ Tests that '/' resolves correctly as a chrome content package. """ err = ErrorBundle() err.supported_versions = {} manifest = ChromeManifest(""" content ns1 / overlay chrome://foo chrome://ns1/content/main.xul """, 'chrome.manifest') err.save_resource('chrome.manifest', manifest) err.save_resource('chrome.manifest_nopush', manifest) xpi = MockXPI({'main.xul': 'tests/resources/content/script_list.xul'}) content.test_packed_packages(err, xpi) assert not err.failed() marked_scripts = err.get_resource('marked_scripts') eq_(marked_scripts, set(['chrome://ns1/foo.js', 'chrome://ns1/bar.js', 'chrome://asdf/foo.js']))
def test_marking_overlays(): """ Mark an overlay, then test that it marks the scripts within the overlay. """ err = ErrorBundle() err.supported_versions = {} c = ChromeManifest(""" content ns1 foo/ overlay chrome://foo chrome://ns1/content/main.xul """, 'chrome.manifest') err.save_resource('chrome.manifest', c) err.save_resource('chrome.manifest_nopush', c) xpi = MockXPI({'foo/main.xul': 'tests/resources/content/script_list.xul'}) content.test_packed_packages(err, xpi) assert not err.failed() marked_scripts = err.get_resource('marked_scripts') eq_(marked_scripts, set(['chrome://ns1/foo.js', 'chrome://ns1/bar.js', 'chrome://asdf/foo.js']))
def test_open(): """Open a chrome file and ensure that data can be pulled from it.""" chrome = open("tests/resources/chromemanifest/chrome.manifest") chrome_data = chrome.read() manifest = ChromeManifest(chrome_data, "chrome.manifest") assert manifest is not None assert manifest.get_value("locale", "basta")["object"] == "resource" g_obj = list(manifest.get_objects("subject", "predicate")) assert len(g_obj) == 1 assert g_obj[0] == "object" obj_resource = list(manifest.get_triples(None, None, "resource")) assert len(obj_resource) == 2 pred_pred = list(manifest.get_triples(None, "predicate", None)) assert len(pred_pred) == 2 sub_locale = list(manifest.get_triples("locale", None, None)) assert len(sub_locale) == 2
def test_open(): """Open a chrome file and ensure that data can be pulled from it.""" chrome = open('tests/resources/chromemanifest/chrome.manifest') chrome_data = chrome.read() manifest = ChromeManifest(chrome_data, 'chrome.manifest') assert manifest is not None assert manifest.get_value('locale', 'basta')['object'] == 'resource' g_obj = list(manifest.get_objects('subject', 'predicate')) assert len(g_obj) == 1 assert g_obj[0] == 'object' obj_resource = list(manifest.get_triples(None, None, 'resource')) assert len(obj_resource) == 2 pred_pred = list(manifest.get_triples(None, 'predicate', None)) assert len(pred_pred) == 2 sub_locale = list(manifest.get_triples('locale', None, None)) assert len(sub_locale) == 2
def test_overlay_object(): """Test that overlay instructions have all its properties.""" err = ErrorBundle() c = ChromeManifest(""" content namespace /foo/bar overlay namespace /uri/goes/here """, "chrome.manifest") err.save_resource("chrome.manifest", c) c.get_applicable_overlays(err) assert not err.failed() assert not err.notices err = ErrorBundle() c = ChromeManifest(""" content namespace /foo/bar overlay /uri/goes/here """, "chrome.manifest") err.save_resource("chrome.manifest", c) c.get_applicable_overlays(err) assert err.failed() assert not err.notices
def test_reverse_lookup(): """Test that the chrome reverse lookup function works properly.""" c = ChromeManifest( """ content ns1 /dir1/ content ns2 /dir2/foo/ content nsbad1 /dir3 content ns3 jar:foo.jar!/subdir1/ content ns3 jar:zap.jar!/altdir1/ content ns4 jar:bar.jar!/subdir2 """, 'chrome.manifest') assert c.reverse_lookup(MockPackStack(), 'random.js') is None assert c.reverse_lookup(MockPackStack(), '/dir1/x.js') == 'chrome://ns1/x.js' assert c.reverse_lookup(MockPackStack(), '/dir2/x.js') is None assert c.reverse_lookup(MockPackStack(), '/dir2/foo/x.js') == 'chrome://ns2/x.js' assert c.reverse_lookup(MockPackStack(), '/dir3/x.js') == 'chrome://nsbad1/x.js' assert c.reverse_lookup(MockPackStack(['foo.jar']), '/x.js') == 'chrome://ns3/subdir1/x.js' assert c.reverse_lookup(MockPackStack(['foo.jar']), '/zap/x.js') == 'chrome://ns3/subdir1/zap/x.js' assert c.reverse_lookup(MockPackStack(['bar.jar']), '/x.js') == 'chrome://ns4/subdir2/x.js' assert c.reverse_lookup(MockPackStack(['zap.jar']), '/x.js') == 'chrome://ns3/altdir1/x.js'
def chrome_manifest(string): """Returns a mock ChromeManifest object for the given string.""" from validator.chromemanifest import ChromeManifest xpi = OtherMockXPI({'chrome.manifest': string}) return ChromeManifest(xpi, 'chrome.manifest')
def test_conduittoolbar(err, package_contents=None, xpi_manager=None): "Find and blacklist Conduit toolbars" # Ignore non-extension types if err.detected_type in (PACKAGE_ANY, PACKAGE_THEME, PACKAGE_SEARCHPROV): return None # Tests regarding the install.rdf file. if err.get_resource("has_install_rdf"): # Go out and fetch the install.rdf instance object install = err.get_resource("install_rdf") # Define a list of specifications to search for Conduit with parameters = { "http://www.conduit.com/": install.uri("homepageURL"), "Conduit Ltd.": install.uri("creator"), "More than just a toolbar.": install.uri("description"), } # Iterate each specification and test for it. for k, uri_reference in parameters.items(): # Retrieve the value results = install.get_object(None, uri_reference) # If the value exists, test for the appropriate content if results == k: err.reject = True err_mesg = "Conduit value (%s) found in install.rdf" % k return err.warning( ("testcases_conduit", "test_conduittoolbar", "detected_rdf"), "Detected Conduit toolbar.", err_mesg, "install.rdf", ) # Also test for the update URL update_url_value = "https://ffupdate.conduit-services.com/" results = install.get_object(None, install.uri("updateURL")) if results and results.startswith(update_url_value): err.reject = True return err.warning( ("testcases_conduit", "test_conduittoolbar", "detected_updateurl"), "Detected Conduit toolbar.", "Conduit update URL found in install.rdf.", "install.rdf", ) # Do some matching on the files in the package conduit_files = ("components/Conduit*", "searchplugin/conduit*") for file_ in package_contents: for bad_file in conduit_files: # If there's a matching file, it's Conduit if fnmatch.fnmatch(file_, bad_file): err.reject = True return err.warning( ("testcases_conduit", "test_conduittoolbar", "detected_files"), "Detected Conduit toolbar.", "Conduit directory (%s) found." % bad_file, ) # Do some tests on the chrome.manifest file if it exists if "chrome.manifest" in package_contents: # Grab the chrome manifest if err.get_resource("chrome.manifest"): # pragma: no cover # It's cached in the error bundler chrome = err.get_resource("chrome.manifest") else: # Not cached, so we grab it. chrome_data = xpi_manager.read("chrome.manifest") chrome = ChromeManifest(chrome_data) err.save_resource("chrome.manifest", chrome) # Get all styles for customizing the toolbar data = chrome.get_value("style", "chrome://global/content/customizeToolbar.xul") # If the style exists and it contains "ebtoolbarstyle"... if data is not None and data["object"].count("ebtoolbarstyle") > 0: err.reject = True return err.warning( ("testcases_conduit", "test_conduittoolbar", "detected_chrome_manifest"), "Detected Conduit toolbar.", "'ebtoolbarstyle' found in chrome.manifest", "chrome.manifest", line=data["line"], context=chrome.context, )
def populate_chrome_manifest(err, xpi_package): "Loads the chrome.manifest if it's present" if 'chrome.manifest' in xpi_package: chrome_data = xpi_package.read('chrome.manifest') chrome = ChromeManifest(chrome_data, 'chrome.manifest') chrome_recursion_buster = set() # Handle the case of manifests linked from the manifest. def get_linked_manifest(path, from_path, from_chrome, from_triple): if path in chrome_recursion_buster: err.warning( err_id=('submain', 'populate_chrome_manifest', 'recursion'), warning='Linked manifest recursion detected.', description='A chrome registration file links back to ' 'itself. This can cause a multitude of ' 'issues.', filename=path) return # Make sure the manifest is properly linked if path not in xpi_package: err.notice( err_id=('submain', 'populate_chrome_manifest', 'linkerr'), notice='Linked manifest could not be found.', description=('A linked manifest file could not be found ' 'in the package.', 'Path: %s' % path), filename=from_path, line=from_triple['line'], context=from_chrome.context) return chrome_recursion_buster.add(path) manifest = ChromeManifest(xpi_package.read(path), path) for triple in manifest.triples: yield triple if triple['subject'] == 'manifest': subpath = triple['predicate'] # If the path is relative, make it relative to the current # file. if not subpath.startswith('/'): subpath = '%s/%s' % ('/'.join( path.split('/')[:-1]), subpath) subpath = subpath.lstrip('/') for subtriple in get_linked_manifest( subpath, path, manifest, triple): yield subtriple chrome_recursion_buster.discard(path) chrome_recursion_buster.add('chrome.manifest') # Search for linked manifests in the base manifest. for extra_manifest in chrome.get_triples(subject='manifest'): # When one is found, add its triples to our own. for triple in get_linked_manifest(extra_manifest['predicate'], 'chrome.manifest', chrome, extra_manifest): chrome.triples.append(triple) chrome_recursion_buster.discard('chrome.manifest') # Create a reference so we can get the chrome manifest later, but make # it pushable so we don't run chrome manifests in JAR files. err.save_resource('chrome.manifest', chrome, pushable=True) # Create a non-pushable reference for tests that need to access the # chrome manifest from within JAR files. err.save_resource('chrome.manifest_nopush', chrome, pushable=False)
def __init__(self, filename, project=None, release=None, name=None): """ Fills in a list of locales from the chrome.manifest file. """ Bundle.__init__(self, project, release) self.xpi = XPIManager(filename, name=name) # here we will store managers for jarfiles self.jarfiles = {} chrome = ChromeManifest(self.xpi.read("chrome.manifest"), "manifest") locales = list(chrome.get_triples("locale")) if not locales: return None # read the list for locale in locales: code, location = locale["object"].split() # finding out the language of the locale try: lang = self._get_lang(code) except Language.DoesNotExist: self.log("Locale %s SKIPPED" % code, "font-weight:bold") continue # Locales can be bundled in JARs jarred = location.startswith("jar:") if jarred: # We just care about the JAR path location = location[4:] split_location = location.split("!", 2) # Ignore malformed JAR URIs. if len(split_location) < 2: continue jarname, location = split_location # missing file mentioned if jarname not in self.xpi: continue # may be we have already read this one if jarname in self.jarfiles: package = self.jarfiles[jarname] else: jar = StringIO(self.xpi.read(jarname)) package = XPIManager(jar, mode="r", name=jarname) else: package = self.xpi # and now we read files from there location = location.strip('/') result = {} for f in package.package_contents(): f = f.strip("/") if f.startswith(location) and f != location: result[f.split("/")[-1]] = package.read(f) # file with same name in different jars can get overwritten if lang not in self.locales: self.locales[lang] = result else: self.locales[lang].update(result)
def test_incomplete_triplets(): """Test that incomplete triplets are ignored.""" c = ChromeManifest('foo\nbar', 'chrome.manifest') assert not c.triples
def populate_chrome_manifest(err, xpi_package): "Loads the chrome.manifest if it's present" if 'chrome.manifest' in xpi_package: chrome_data = xpi_package.read('chrome.manifest') chrome = ChromeManifest(chrome_data, 'chrome.manifest') chrome_recursion_buster = set() # Handle the case of manifests linked from the manifest. def get_linked_manifest(path, from_path, from_chrome, from_triple): if path in chrome_recursion_buster: err.warning( err_id=('submain', 'populate_chrome_manifest', 'recursion'), warning='Linked manifest recursion detected.', description='A chrome registration file links back to ' 'itself. This can cause a multitude of ' 'issues.', filename=path) return # Make sure the manifest is properly linked if path not in xpi_package: err.notice( err_id=('submain', 'populate_chrome_manifest', 'linkerr'), notice='Linked manifest could not be found.', description=('A linked manifest file could not be found ' 'in the package.', 'Path: %s' % path), filename=from_path, line=from_triple['line'], context=from_chrome.context) return chrome_recursion_buster.add(path) manifest = ChromeManifest(xpi_package.read(path), path) for triple in manifest.triples: yield triple if triple['subject'] == 'manifest': subpath = triple['predicate'] # If the path is relative, make it relative to the current # file. if not subpath.startswith('/'): subpath = '%s/%s' % ( '/'.join(path.split('/')[:-1]), subpath) subpath = subpath.lstrip('/') for subtriple in get_linked_manifest( subpath, path, manifest, triple): yield subtriple chrome_recursion_buster.discard(path) chrome_recursion_buster.add('chrome.manifest') # Search for linked manifests in the base manifest. for extra_manifest in chrome.get_triples(subject='manifest'): # When one is found, add its triples to our own. for triple in get_linked_manifest(extra_manifest['predicate'], 'chrome.manifest', chrome, extra_manifest): chrome.triples.append(triple) chrome_recursion_buster.discard('chrome.manifest') # Create a reference so we can get the chrome manifest later, but make # it pushable so we don't run chrome manifests in JAR files. err.save_resource('chrome.manifest', chrome, pushable=True) # Create a non-pushable reference for tests that need to access the # chrome manifest from within JAR files. err.save_resource('chrome.manifest_nopush', chrome, pushable=False)
def populate_chrome_manifest(err, xpi_package): "Loads the chrome.manifest if it's present" if "chrome.manifest" in xpi_package: chrome_data = xpi_package.read("chrome.manifest") chrome = ChromeManifest(chrome_data, "chrome.manifest") chrome_recursion_buster = set() # Handle the case of manifests linked from the manifest. def get_linked_manifest(path, from_path, from_chrome, from_triple): if path in chrome_recursion_buster: err.warning( err_id=("submain", "populate_chrome_manifest", "recursion"), warning="Linked manifest recursion detected.", description="A chrome registration file links back to " "itself. This can cause a multitude of " "issues.", filename=path) return # Make sure the manifest is properly linked if path not in xpi_package: err.notice(err_id=("submain", "populate_chrome_manifest", "linkerr"), notice="Linked manifest could not be found.", description=[ "A linked manifest file could not be found " "in the package.", "Path: %s" % path ], filename=from_path, line=from_triple["line"], context=from_chrome.context) return chrome_recursion_buster.add(path) manifest = ChromeManifest(xpi_package.read(path), path) for triple in manifest.triples: yield triple if triple["subject"] == "manifest": subpath = triple["predicate"] # If the path is relative, make it relative to the current # file. if not subpath.startswith("/"): subpath = "%s/%s" % ("/".join( path.split("/")[:-1]), subpath) subpath = subpath.lstrip("/") for subtriple in get_linked_manifest( subpath, path, manifest, triple): yield subtriple chrome_recursion_buster.discard(path) chrome_recursion_buster.add("chrome.manifest") # Search for linked manifests in the base manifest. for extra_manifest in chrome.get_triples(subject="manifest"): # When one is found, add its triples to our own. for triple in get_linked_manifest(extra_manifest["predicate"], "chrome.manifest", chrome, extra_manifest): chrome.triples.append(triple) chrome_recursion_buster.discard("chrome.manifest") # Create a reference so we can get the chrome manifest later, but make # it pushable so we don't run chrome manifests in JAR files. err.save_resource("chrome.manifest", chrome, pushable=True) # Create a non-pushable reference for tests that need to access the # chrome manifest from within JAR files. err.save_resource("chrome.manifest_nopush", chrome, pushable=False)
def populate_chrome_manifest(err, xpi_package): "Loads the chrome.manifest if it's present" if "chrome.manifest" in xpi_package: chrome_data = xpi_package.read("chrome.manifest") chrome = ChromeManifest(chrome_data, "chrome.manifest") chrome_recursion_buster = set() # Handle the case of manifests linked from the manifest. def get_linked_manifest(path, from_path, from_chrome, from_triple): if path in chrome_recursion_buster: err.warning( err_id=("submain", "populate_chrome_manifest", "recursion"), warning="Linked manifest recursion detected.", description="A chrome registration file links back to " "itself. This can cause a multitude of " "issues.", filename=path) return # Make sure the manifest is properly linked if path not in xpi_package: err.notice( err_id=("submain", "populate_chrome_manifest", "linkerr"), notice="Linked manifest could not be found.", description=["A linked manifest file could not be found " "in the package.", "Path: %s" % path], filename=from_path, line=from_triple["line"], context=from_chrome.context) return chrome_recursion_buster.add(path) manifest = ChromeManifest(xpi_package.read(path), path) for triple in manifest.triples: yield triple if triple["subject"] == "manifest": for subtriple in get_linked_manifest( triple["predicate"], path, manifest, triple): yield subtriple chrome_recursion_buster.discard(path) chrome_recursion_buster.add("chrome.manifest") # Search for linked manifests in the base manifest. for extra_manifest in chrome.get_triples(subject="manifest"): # When one is found, add its triples to our own. for triple in get_linked_manifest(extra_manifest["predicate"], "chrome.manifest", chrome, extra_manifest): chrome.triples.append(triple) chrome_recursion_buster.discard("chrome.manifest") # Create a reference so we can get the chrome manifest later, but make # it pushable so we don't run chrome manifests in JAR files. err.save_resource("chrome.manifest", chrome, pushable=True) # Create a non-pushable reference for tests that need to access the # chrome manifest from within JAR files. err.save_resource("chrome.manifest_nopush", chrome, pushable=False)