chrome-devtools-frontend 1.0.945884 → 1.0.948295

package/front_end/ui/legacy/components/text_editor/module.json

@@ -1,7 +0,0 @@
-{
-  "resources": [
-    "../../../../third_party/codemirror/codemirror.css",
-    "autocompleteTooltip.css",
-    "cmdevtools.css"
-  ]
-}

package/front_end/ui/legacy/components/text_editor/text_editor-legacy.ts

@@ -1,33 +0,0 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// @ts-nocheck
-
-import * as TextEditorModule from './text_editor.js';
-
-self.TextEditor = self.TextEditor || {};
-TextEditor = TextEditor || {};
-
-/** @constructor */
-TextEditor.CodeMirrorTextEditor = TextEditorModule.CodeMirrorTextEditor.CodeMirrorTextEditor;
-
-/** @constructor */
-TextEditor.CodeMirrorTextEditor.SelectNextOccurrenceController =
-    TextEditorModule.CodeMirrorTextEditor.SelectNextOccurrenceController;
-
-/** @interface */
-TextEditor.TextEditorPositionHandle = TextEditorModule.CodeMirrorTextEditor.TextEditorPositionHandle;
-
-/** @constructor */
-TextEditor.CodeMirrorPositionHandle = TextEditorModule.CodeMirrorTextEditor.CodeMirrorPositionHandle;
-
-/** @constructor */
-TextEditor.TextEditorBookMark = TextEditorModule.CodeMirrorTextEditor.TextEditorBookMark;
-
-/** @constructor */
-TextEditor.CodeMirrorTextEditorFactory = TextEditorModule.CodeMirrorTextEditor.CodeMirrorTextEditorFactory;
-
-/** @constructor */
-TextEditor.TextEditorAutocompleteController =
-    TextEditorModule.TextEditorAutocompleteController.TextEditorAutocompleteController;

package/front_end/ui/legacy/components/text_editor/text_editor.ts

@@ -1,13 +0,0 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import './cm_modes.js';
-
-import * as CodeMirrorTextEditor from './CodeMirrorTextEditor.js';
-import * as TextEditorAutocompleteController from './TextEditorAutocompleteController.js';
-
-export {
-  CodeMirrorTextEditor,
-  TextEditorAutocompleteController,
-};

package/scripts/build/build_release_applications.py

@@ -1,216 +0,0 @@
-#!/usr/bin/env vpython
-# -*- coding: utf-8 -*-
-#
-# Copyright 2016 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-"""
-Builds applications in release mode:
-- Concatenates autostart modules, application modules' module.json descriptors,
-and the application loader into a single script.
-"""
-
-from io import StringIO
-from os import path
-from os.path import join
-import copy
-import os
-import re
-import shutil
-import sys
-import subprocess
-
-from modular_build import read_file, write_file, bail_error
-import modular_build
-import rjsmin
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-
-try:
-    original_sys_path = sys.path
-    sys.path = sys.path + [path.join(os.path.dirname(os.path.realpath(__file__)), '..')]
-    import devtools_paths
-finally:
-    sys.path = original_sys_path
-
-FRONT_END_DIRECTORY = path.join(os.path.dirname(path.abspath(__file__)), '..', '..', 'front_end')
-
-
-def main(argv):
-    try:
-        input_path_flag_index = argv.index('--input_path')
-        input_path = argv[input_path_flag_index + 1]
-        output_path_gen_flag_index = argv.index('--output_path_gen')
-        output_path_gen = argv[output_path_gen_flag_index + 1]
-        application_names = argv[1:input_path_flag_index]
-        use_rollup = '--rollup' in argv
-    except:
-        print('Usage: %s app_1 app_2 ... app_N --input_path <input_path> --output_path <output_path> --rollup true' % argv[0])
-        raise
-
-    loader = modular_build.DescriptorLoader(input_path)
-    for app in application_names:
-        descriptors = loader.load_application(app)
-        builder = ReleaseBuilder(app, descriptors, input_path, output_path_gen,
-                                 use_rollup)
-        builder.build_app()
-
-
-def resource_source_url(url):
-    return '\n/*# sourceURL=' + url + ' */'
-
-
-def minify_js(javascript):
-    return rjsmin.jsmin(javascript)
-
-
-def concatenated_module_filename(module_name, output_dir):
-    return join(output_dir,
-                module_name + '/' + path.basename(module_name) + '_module.js')
-
-
-# Outputs:
-#   <app_name>.js
-#   <module_name>_module.js
-class ReleaseBuilder(object):
-
-    def __init__(self, application_name, descriptors, application_dir,
-                 output_path_gen_dir, use_rollup):
-        self.application_name = application_name
-        self.descriptors = descriptors
-        self.application_dir = application_dir
-        self.output_path_gen_dir = output_path_gen_dir
-        self.use_rollup = use_rollup
-
-    def app_file(self, extension):
-        return path.join('entrypoints', self.application_name,
-                         self.application_name + '.' + extension)
-
-    def autorun_resource_names(self):
-        result = []
-        for module in self.descriptors.sorted_modules():
-            if self.descriptors.application[module].get('type') != 'autostart':
-                continue
-
-            resources = self.descriptors.modules[module].get('resources')
-            if not resources:
-                continue
-            for resource_name in resources:
-                result.append(path.join(module, resource_name))
-        return result
-
-    def build_app(self):
-        self._build_app_script()
-        for module in filter(lambda desc: (not desc.get('type')),
-                             self.descriptors.application.values()):
-            self._concatenate_dynamic_module(module['name'])
-
-    def _build_app_script(self):
-        script_name = self.app_file('js')
-        output = StringIO()
-        self._concatenate_application_script(output)
-        minified_content = minify_js(output.getvalue())
-        write_file(join(self.output_path_gen_dir, script_name),
-                   minified_content)
-        output.close()
-
-    def _release_module_descriptors(self):
-        module_descriptors = self.descriptors.modules
-        result = []
-        for name in module_descriptors:
-            module = copy.copy(module_descriptors[name])
-            module_type = self.descriptors.application[name].get('type')
-            resources = module.get('resources', None)
-            if resources:
-                # Resources are already baked into _module.
-                del module['resources']
-                if not module_type == 'autostart':
-                    # We load the entrypoint of a module no matter what.
-                    # Therefore, we don't need to declare any files for
-                    # the default case. However, if a module still has
-                    # a legacy file, the Runtime performs an array
-                    # contains check and will load that instead.
-                    module_files_to_load = []
-                    declared_module_files = module.get('modules', [])
-                    legacyFileName = path.basename(name) + '-legacy.js'
-                    if legacyFileName in declared_module_files:
-                        module_files_to_load += [legacyFileName]
-                    # Non-autostart modules are vulcanized.
-                    module['modules'] = [path.basename(name) + '_module.js'
-                                         ] + module_files_to_load
-            result.append(module)
-        return json.dumps(result)
-
-    def _write_module_resources(self, resource_names, output):
-        for resource_name in resource_names:
-            resource_name = path.normpath(resource_name).replace('\\', '/')
-            output.write('RootModule.Runtime.cachedResources.set("%s", "' %
-                         resource_name)
-            resource_content = read_file(path.join(self.application_dir, resource_name))
-            if not (resource_name.endswith('.html')
-                    or resource_name.endswith('md')):
-                resource_content += resource_source_url(resource_name)
-            resource_content = resource_content.replace('\\', '\\\\')
-            resource_content = resource_content.replace('\n', '\\n')
-            resource_content = resource_content.replace('"', '\\"')
-            output.write(resource_content)
-            output.write('");\n')
-
-    def _concatenate_autostart_modules(self, output):
-        non_autostart = set()
-        sorted_module_names = self.descriptors.sorted_modules()
-        for name in sorted_module_names:
-            desc = self.descriptors.modules[name]
-            name = desc['name']
-            type = self.descriptors.application[name].get('type')
-            if type == 'autostart':
-                deps = set(desc.get('dependencies', []))
-                non_autostart_deps = deps & non_autostart
-                if len(non_autostart_deps):
-                    bail_error(
-                        'Non-autostart dependencies specified for the autostarted module "%s": %s' % (name, non_autostart_deps))
-            else:
-                non_autostart.add(name)
-
-    def _concatenate_application_script(self, output):
-        output.write('Root.allDescriptors.push(...%s);' % self._release_module_descriptors())
-        if self.descriptors.extends:
-            output.write(
-                'Root.applicationDescriptor.modules.push(...%s);' %
-                json.dumps(list(self.descriptors.application.values())))
-        else:
-            output.write('Root.applicationDescriptor = %s;' % self.descriptors.application_json())
-
-        output.write("import * as RootModule from '../../core/root/root.js';")
-        self._write_module_resources(self.autorun_resource_names(), output)
-
-        output.write(minify_js(read_file(join(self.application_dir, self.app_file('js')))))
-        self._concatenate_autostart_modules(output)
-
-    def _concatenate_dynamic_module(self, module_name):
-        module = self.descriptors.modules[module_name]
-        modules = module.get('modules')
-        resources = self.descriptors.module_resources(module_name)
-        module_dir = join(self.application_dir, module_name)
-        output = StringIO()
-        if resources:
-            relative_file_name = '../core/root/root.js'
-            if "/" in module_name:
-                relative_file_name = (
-                    '../' * module_name.count('/')) + relative_file_name
-            output.write("import * as RootModule from '%s';" %
-                         relative_file_name)
-            self._write_module_resources(resources, output)
-        minified_content = minify_js(output.getvalue())
-        write_file(
-            concatenated_module_filename(module_name,
-                                         self.output_path_gen_dir),
-            minified_content)
-        output.close()
-
-
-if __name__ == '__main__':
-    sys.exit(main(sys.argv))

package/scripts/build/modular_build.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env vpython
-#
-# Copyright 2014 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-"""
-Utilities for the modular DevTools build.
-"""
-
-from __future__ import print_function
-
-import collections
-from os import path
-import os
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-
-
-def read_file(filename):
-    with open(path.normpath(filename), 'rt', encoding='utf-8') as input:
-        return input.read()
-
-
-def write_file(filename, content):
-    if path.exists(filename):
-        os.remove(filename)
-    directory = path.dirname(filename)
-    if not path.exists(directory):
-        os.makedirs(directory)
-    with open(filename, 'wt', encoding='utf-8') as output:
-        output.write(content)
-
-
-def bail_error(message):
-    raise Exception(message)
-
-
-def load_and_parse_json(filename):
-    try:
-        return json.loads(read_file(filename))
-    except:
-        print('ERROR: Failed to parse %s' % filename)
-        raise
-
-class Descriptors:
-
-    def __init__(self, application_name, application_dir,
-                 application_descriptor, module_descriptors, extends, worker):
-        self.application_name = application_name
-        self.application_dir = application_dir
-        self.application = application_descriptor
-        self._cached_sorted_modules = None
-        self.modules = module_descriptors
-        self.extends = extends
-        self.worker = worker
-
-    def application_json(self):
-        result = dict()
-        result['modules'] = list(self.application.values())
-        return json.dumps(result)
-
-    def module_resources(self, name):
-        return [name + '/' + resource for resource in self.modules[name].get('resources', [])]
-
-    def sorted_modules(self):
-        if self._cached_sorted_modules:
-            return self._cached_sorted_modules
-
-        result = []
-
-        # Use dict instead of set for deterministic iteration order.
-        unvisited_modules = {module: None for module in self.modules}
-
-        temp_modules = set()
-
-        def visit(parent, name):
-            if name not in unvisited_modules:
-                return None
-            if name not in self.modules:
-                return (parent, name)
-            if name in temp_modules:
-                bail_error('Dependency cycle found at module "%s"' % name)
-            temp_modules.add(name)
-            deps = self.modules[name].get('dependencies')
-            if deps:
-                for dep_name in deps:
-                    bad_dep = visit(name, dep_name)
-                    if bad_dep:
-                        return bad_dep
-            del unvisited_modules[name]
-            temp_modules.remove(name)
-            result.append(name)
-            return None
-
-        while len(unvisited_modules):
-            for next in unvisited_modules:
-                break
-            failure = visit(None, next)
-            if failure:
-                # failure[0] can never be None
-                bail_error('Unknown module "%s" encountered in dependencies of "%s"' % (failure[1], failure[0]))
-
-        self._cached_sorted_modules = result
-        return result
-
-    def sorted_dependencies_closure(self, module_name):
-        visited = set()
-
-        def sorted_deps_for_module(name):
-            result = []
-            desc = self.modules[name]
-            deps = desc.get('dependencies', [])
-            for dep in deps:
-                result += sorted_deps_for_module(dep)
-            if name not in visited:
-                result.append(name)
-                visited.add(name)
-            return result
-
-        return sorted_deps_for_module(module_name)
-
-
-class DescriptorLoader:
-
-    def __init__(self, application_dir):
-        self.application_dir = application_dir
-
-    def load_application(self, application_descriptor_name):
-        all_module_descriptors = {}
-        result = self._load_application(application_descriptor_name, all_module_descriptors)
-        return result
-
-    def load_applications(self, application_descriptor_names):
-        all_module_descriptors = {}
-        all_application_descriptors = {}
-        for application_descriptor_name in application_descriptor_names:
-            descriptors = {}
-            result = self._load_application(application_descriptor_name, descriptors)
-            for name in descriptors:
-                all_module_descriptors[name] = descriptors[name]
-            for name in result.application:
-                all_application_descriptors[name] = result.application[name]
-        return Descriptors('all', self.application_dir,
-                           all_application_descriptors, all_module_descriptors,
-                           None, False)
-
-    def _load_application(self, application_descriptor_name, all_module_descriptors):
-        module_descriptors = {}
-        application_descriptor_filename = path.join(
-            self.application_dir, 'entrypoints', application_descriptor_name,
-            application_descriptor_name + '.json')
-        descriptor_json = load_and_parse_json(application_descriptor_filename)
-        application_descriptor = {desc['name']: desc for desc in descriptor_json['modules']}
-        extends = descriptor_json['extends'] if 'extends' in descriptor_json else None
-        if extends:
-            extends = self._load_application(extends, all_module_descriptors)
-        worker = True if 'worker' in descriptor_json and descriptor_json['worker'] else False
-
-        for (module_name, module) in application_descriptor.items():
-            if all_module_descriptors.get(module_name):
-                bail_error('Duplicate definition of module "%s" in %s' % (module_name, application_descriptor_filename))
-            module_descriptors[module_name] = self._read_module_descriptor(module_name, application_descriptor_filename)
-            all_module_descriptors[module_name] = module_descriptors[module_name]
-
-        for module in module_descriptors.values():
-            for dep in module.get('dependencies', []):
-                if dep not in all_module_descriptors:
-                    bail_error('Module "%s" (dependency of "%s") not listed in application descriptor %s' %
-                               (dep, module['name'], application_descriptor_filename))
-
-        return Descriptors(application_descriptor_name, self.application_dir,
-                           application_descriptor, module_descriptors, extends,
-                           worker)
-
-    def _read_module_descriptor(self, module_name, application_descriptor_filename):
-        json_filename = path.join(self.application_dir, module_name, 'module.json')
-        if not path.exists(json_filename):
-            bail_error('Module descriptor %s referenced in %s is missing' % (json_filename, application_descriptor_filename))
-        module_json = load_and_parse_json(json_filename)
-        module_json['name'] = module_name
-        return module_json

package/scripts/check_gn.js

@@ -1,119 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const FRONTEND_PATH = path.resolve(__dirname, '..', 'front_end');
-
-const manifestModules = [];
-for (const config of ['inspector', 'devtools_app', 'js_app', 'node_app', 'shell', 'worker_app']) {
-  manifestModules.push(...require(path.resolve(FRONTEND_PATH, 'entrypoints', config, `${config}.json`)).modules);
-}
-
-const gnPath = path.resolve(__dirname, '..', 'BUILD.gn');
-const gnFile = fs.readFileSync(gnPath, 'utf-8');
-const gnLines = gnFile.split('\n');
-
-/**
- * Ensures that all source files (according to the various module.json files) are
- * listed in BUILD.gn.
- */
-function checkAllDevToolsFiles() {
-  return checkGNVariable('all_devtools_files', 'all_devtools_files', moduleJSON => {
-    const resources = moduleJSON.resources || [];
-    return [
-      'module.json',
-      ...resources,
-    ];
-  });
-}
-
-function checkGNVariable(fileName, gnVariable, obtainFiles, obtainRelativePath) {
-  const filePath = path.resolve(__dirname, '..', 'config', 'gni', `${fileName}.gni`);
-  const fileContent = fs.readFileSync(filePath, 'utf-8');
-  const linesToCheck = fileContent.split('\n');
-
-  const errors = [];
-  const excludedFiles =
-      ['axe.js', 'entrypoints/formatter_worker/', 'third_party/lighthouse/', 'third_party/i18n/'].map(path.normalize);
-  const lines = selectGNLines(`${gnVariable} = [`, ']', linesToCheck).map(path.normalize);
-  if (!lines.length) {
-    return [
-      `Could not identify ${gnVariable} list in gn file`,
-      'Please look at: ' + __filename,
-    ];
-  }
-  const gnFiles = new Set(lines);
-  let moduleFiles = [];
-
-  function addModuleFilesForDirectory(moduleJSONPath, buildGNPath, folderName) {
-    const moduleJSON = require(moduleJSONPath);
-    const files = obtainFiles(moduleJSON, folderName)
-                      .map(obtainRelativePath && obtainRelativePath(buildGNPath) || relativePathFromBuildGN)
-                      .filter(file => excludedFiles.every(excludedFile => !file.includes(excludedFile)));
-    moduleFiles = moduleFiles.concat(files);
-
-    function relativePathFromBuildGN(filename) {
-      const relativePath = path.normalize(`front_end/${buildGNPath}/${filename}`);
-      return `"${relativePath}",`;
-    }
-  }
-
-  function traverseDirectoriesForModuleJSONFiles(folderName, buildGNPath) {
-    if (!fs.lstatSync(folderName).isDirectory()) {
-      return;
-    }
-    const moduleJSONPath = path.join(folderName, 'module.json');
-    if (fs.existsSync(moduleJSONPath)) {
-      addModuleFilesForDirectory(moduleJSONPath, buildGNPath, path.basename(folderName));
-    }
-
-    fs.readdirSync(folderName).forEach(nestedModuleName => {
-      traverseDirectoriesForModuleJSONFiles(
-          path.join(folderName, nestedModuleName), `${buildGNPath}/${nestedModuleName}`);
-    });
-  }
-
-  fs.readdirSync(FRONTEND_PATH).forEach(moduleName => {
-    traverseDirectoriesForModuleJSONFiles(path.join(FRONTEND_PATH, moduleName), moduleName);
-  });
-
-  for (const file of moduleFiles) {
-    if (!gnFiles.has(file)) {
-      errors.push(`Missing file in BUILD.gn for ${gnVariable}: ` + file);
-    }
-  }
-
-  return errors;
-}
-
-function selectGNLines(startLine, endLine, linesToCheck = gnLines) {
-  const lines = linesToCheck.map(line => line.trim());
-  const startIndex = lines.indexOf(startLine);
-  if (startIndex === -1) {
-    return [];
-  }
-  const endIndex = lines.indexOf(endLine, startIndex);
-  if (endIndex === -1) {
-    return [];
-  }
-  return lines.slice(startIndex + 1, endIndex);
-}
-
-function main() {
-  const errors = [
-    ...checkAllDevToolsFiles(),
-  ];
-  if (errors.length) {
-    console.log('DevTools BUILD.gn checker detected errors!');
-    console.log(`There's an issue with: ${gnPath}`);
-    console.log(errors.join('\n'));
-    process.exit(1);
-  }
-  console.log('DevTools BUILD.gn checker passed');
-}
-
-main();

package/scripts/json_validator/module.schema.json

@@ -1,19 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-04/schema#",
-  "type": "object",
-  "additionalProperties": false,
-  "properties": {
-    "dependencies": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "resources": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    }
-  }
-}

package/scripts/json_validator/validate_module_json.js

@@ -1,44 +0,0 @@
-// Copyright 2020 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-const fs = require('fs');
-const path = require('path');
-
-const FRONTEND_PATH = path.resolve(__dirname, '..', '..', 'front_end');
-
-const modules = [];
-for (const dir of fs.readdirSync(FRONTEND_PATH)) {
-  if (!fs.lstatSync(path.resolve(FRONTEND_PATH, dir)).isDirectory()) {
-    continue;
-  }
-  if (fs.existsSync(path.resolve(FRONTEND_PATH, dir, 'module.json'))) {
-    modules.push(dir);
-  }
-}
-
-const Ajv = require('ajv');
-const ajv = new Ajv({schemaId: 'id'});
-// This seems to be the most widely supported version of the schema.
-ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json'));
-
-const schema = JSON.parse(fs.readFileSync(path.resolve(__dirname, 'module.schema.json')));
-const validate = ajv.compile(schema);
-
-let totalErrors = 0;
-for (const module of modules) {
-  const moduleObject = JSON.parse(fs.readFileSync(path.resolve(FRONTEND_PATH, module, 'module.json')));
-  const valid = validate(moduleObject);
-  if (!valid) {
-    console.log('Issue with ./front_end/' + module + '/module.json:');
-    totalErrors++;
-    validate.errors.sort((a, b) => b.dataPath.length - a.dataPath.length);
-    const error = validate.errors[0];
-    console.log('  ', error.dataPath, error.message, error.params);
-    console.log('');
-  }
-}
-if (totalErrors) {
-  console.log('module.json errors:', totalErrors);
-}
-process.exit(totalErrors);