DevTools: move from Common module - Geometry and CSSShadowModel

third_party/WebKit/Source/devtools/scripts/extract_module/extract_module.js

 // 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.
 'use strict';
 const fs = require('fs');
 const path = require('path');
 
 const utils = require('../utils');
 
 const FRONTEND_PATH = path.resolve(__dirname, '..', '..', 'front_end');
 const BUILD_GN_PATH = path.resolve(__dirname, '..', '..', 'BUILD.gn');
 const SPECIAL_CASE_NAMESPACES_PATH = path.resolve(__dirname, '..', 'special_case_namespaces.json');
 
 const APPLICATION_DESCRIPTORS = [
   'inspector.json',
+  'toolbox.json',
   'unit_test_runner.json',
+  'formatter_worker.json',
+  'heap_snapshot_worker.json',
+  'utility_shared_worker.json',
 ];
 
 // Replace based on specified transformation
-const MODULES_TO_REMOVE = ['components_lazy', 'ui_lazy'];
+const MODULES_TO_REMOVE = [];
 
 const JS_FILES_MAPPING = [
-  {file: 'components_lazy/CookiesTable.js', new: 'cookie_table'},
-  {file: 'ui/BezierEditor.js', new: 'inline_editor'},
-  {file: 'ui/BezierUI.js', new: 'inline_editor'},
-  {file: 'ui/ColorSwatch.js', new: 'inline_editor'},
-  {file: 'ui/CSSShadowEditor.js', new: 'inline_editor'},
-  {file: 'ui/SwatchPopoverHelper.js', new: 'inline_editor'},
-  {file: 'components/Spectrum.js', new: 'color_picker'},
-
-  // Cannot extract dom_ui because of cyclic dependency with components
-  // {file: 'components/DOMPresentationUtils.js', new: 'dom_ui'},
-  {file: 'components/ExecutionContextSelector.js', existing: 'main'},
-  {file: 'components_lazy/FilmStripModel.js', existing: 'sdk'},
-  {file: 'components_lazy/FilmStripView.js', existing: 'perf_ui'},
-  {file: 'components/ShortcutsScreen.js', existing: 'ui'},
-  {file: 'ui_lazy/DataGrid.js', new: 'data_grid'},
-  {file: 'ui_lazy/ViewportDataGrid.js', new: 'data_grid'},
-  {file: 'ui_lazy/SortableDataGrid.js', new: 'data_grid'},
-  {file: 'ui_lazy/ShowMoreDataGridNode.js', new: 'data_grid'},
-  {file: 'ui_lazy/ChartViewport.js', existing: 'perf_ui'},
-  {file: 'ui_lazy/FlameChart.js', existing: 'perf_ui'},
-  {file: 'ui_lazy/OverviewGrid.js', existing: 'perf_ui'},
-  {file: 'ui_lazy/PieChart.js', existing: 'perf_ui'},
-  {file: 'ui_lazy/TimelineGrid.js', existing: 'perf_ui'},
-  {file: 'ui_lazy/TimelineOverviewPane.js', existing: 'perf_ui'},
+  {file: 'common/CSSShadowModel.js', existing: 'inline_editor'},
+  {file: 'common/Geometry.js', existing: 'ui'},
+  // {file: 'module/file.js', existing: 'module'}
 ];
 
 const MODULE_MAPPING = {
-  cookie_table: {
-    dependencies: ['ui', 'sdk', 'data_grid'],
-    dependents: ['resources', 'network'],
-    applications: ['inspector.json'],
-    autostart: false,
-  },
-  inline_editor: {
-    dependencies: ['ui'],
-    dependents: ['sources', 'elements', 'resources'],
-    applications: ['inspector.json', 'unit_test_runner.json'],
-    autostart: false,
-  },
-  color_picker: {
-    dependencies: ['ui', 'sdk'],
-    dependents: ['sources', 'elements'],
-    applications: ['inspector.json'],
-    autostart: false,
-  },
-  data_grid: {
-    dependencies: ['ui'],
-    dependents: ['network', 'profiler', 'resources', 'console', 'timeline'],
-    applications: ['inspector.json', 'unit_test_runner.json'],
-    autostart: false,
-  },
+  // heap_snapshot_model: {
+  //   dependencies: [],
+  //   dependents: ['heap_snapshot_worker', 'profiler'],
+  //   applications: ['inspector.json'], // need to manually add to heap snapshot worker b/c it's autostart
+  //   autostart: false,
+  // },
 };
 
 const NEW_DEPENDENCIES_BY_EXISTING_MODULES = {
-  resources: ['components'],
+  // resources: ['components'],
 };
 
 const REMOVE_DEPENDENCIES_BY_EXISTING_MODULES = {
 };
 
 const DEPENDENCIES_BY_MODULE = Object.keys(MODULE_MAPPING).reduce((acc, module) => {
   acc[module] = MODULE_MAPPING[module].dependencies;
   return acc;
 }, {});
 
@@ skipping 17 matching lines @@
   const targetToOriginalFilesMap = JS_FILES_MAPPING.reduce((acc, f) => {
     let components = f.file.split('/');
     components[0] = f.new || f.existing;
     acc.set(components.join('/'), f.file);
     return acc;
   }, new Map());
 
   const cssFilesMapping = findCSSFiles();
   const identifiersByFile = calculateIdentifiers();
   const identifierMap = mapIdentifiers(identifiersByFile, cssFilesMapping);
+  console.log('identifierMap', identifierMap);
   const extensionMap = removeFromExistingModuleDescriptors(modules, identifierMap, cssFilesMapping);
 
   // Find out which files are moving extensions
   for (let e of extensionMap.keys()) {
     for (let [f, identifiers] of identifiersByFile) {
       if (identifiers.includes(e))
         console.log(`extension: ${e} in file: ${f}`);
     }
   }
 
@@ skipping 69 matching lines @@
   function scrapeIdentifiers(content, fileObj) {
     let identifiers = [];
     let lines = content.split('\n');
     for (let line of lines) {
       let match = line.match(new RegExp(`^([a-z_A-Z0-9\.]+)\\s=`)) || line.match(new RegExp(`^([a-z_A-Z0-9\.]+);`));
       if (!match)
         continue;
       let name = match[1];
 
       var currentModule = fileObj.file.split('/')[0];
-      if (name.split('.')[0] !== mapModuleToNamespace(currentModule))
+      if (name.split('.')[0] !== mapModuleToNamespace(currentModule)) {
         console.log(`POSSIBLE ISSUE: identifier: ${name} found in ${currentModule}`);
-      else
+        // one-off
+        if (name.includes('UI.')) {
+          console.log(`including ${name} anyways`);
+          identifiers.push(name)
+        }
+      } else {
         identifiers.push(name);
+      }
     }
     return identifiers;
   }
 }
 
 function moveFiles(cssFilesMapping) {
   for (let fileObj of JS_FILES_MAPPING) {
     let sourceFilePath = path.resolve(FRONTEND_PATH, fileObj.file);
     let targetFilePath = getMappedFilePath(fileObj);
     let moduleDir = path.resolve(targetFilePath, '..');
@@ skipping 44 matching lines @@
     linesToInsert: newNonAutostartModules,
   });
 
   for (let pair of partialPathMapping.entries())
     newContent = newContent.replace(pair[0], pair[1]);
 
   newContent = addContentToLinesInSortedOrder({
     content: newContent,
     startLine: 'all_devtools_files = [',
     endLine: ']',
-    linesToInsert: newSourcesToAdd,
+    linesToInsert: newSourcesToAdd.concat([...newModuleSet].map(module => `"front_end/${module}/module.json",`)),
   });
 
   fs.writeFileSync(BUILD_GN_PATH, newContent);
 
   function calculatePartialPathMapping() {
     let partialPathMapping = new Map();
     for (let fileObj of JS_FILES_MAPPING) {
       let components = fileObj.file.split('/');
       let sourceModule = components[0];
       let targetModule = fileObj.existing || fileObj.new;
       components[0] = targetModule;
       partialPathMapping.set(`"front_end/${fileObj.file}",\n`, '');
       newSourcesToAdd.push(`"front_end/${components.join('/')}",`);
       if (cssFilesMapping.has(fileObj.file)) {
         for (let cssFile of cssFilesMapping.get(fileObj.file)) {
           partialPathMapping.set(`"front_end/${sourceModule}/${cssFile}",\n`, '');
           newSourcesToAdd.push(`"front_end/${targetModule}/${cssFile}",`);
         }
       }
     }
     return partialPathMapping;
   }
 
   function top(array) {
     return array[array.length - 1];
   }
 
   function addContentToLinesInSortedOrder({content, startLine, endLine, linesToInsert}) {
+    if (linesToInsert.length === 0)
+      return content;
     let lines = content.split('\n');
     let seenStartLine = false;
     let contentStack = linesToInsert.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase())).reverse();
     for (var i = 0; i < lines.length; i++) {
       let line = lines[i].trim();
       let nextLine = lines[i + 1].trim();
       if (line === startLine)
         seenStartLine = true;
 
       if (line === endLine && seenStartLine)
@@ skipping 77 matching lines @@
   }
 
   function write(filePath) {
     let content = fs.readFileSync(filePath).toString();
     let newContent = content;
     for (let key of identifierMap.keys()) {
       let originalIdentifier = key;
       let newIdentifier = identifierMap.get(key);
       newContent = newContent.replaceAll(originalIdentifier, newIdentifier);
     }
-    // one-off
-    if (filePath.includes('LayoutTests/http/tests/inspector-unit/filtered-item-selection-dialog-filtering.js'))
-      newContent = newContent.replaceAll('ui_lazy', 'quick_open');
-    if (filePath.includes('LayoutTests/inspector/components/cookies-table.html'))
-      newContent = newContent.replaceAll('components_lazy', 'cookie_table');
-    if (filePath.includes('LayoutTests/inspector/components/datagrid-autosize.html'))
-      newContent = newContent.replaceAll('ui_lazy', 'data_grid');
-    if (filePath.includes('LayoutTests/inspector/components/datagrid-test.js'))
-      newContent = newContent.replaceAll('ui_lazy', 'data_grid');
 
     if (content !== newContent)
       fs.writeFileSync(filePath, newContent);
   }
 }
 
 function removeFromExistingModuleDescriptors(modules, identifierMap, cssFilesMapping) {
   let extensionMap = new Map();
   let moduleFileMap = new Map();
 
@@ skipping 231 matching lines @@
       if (dependents.includes(existingModule))
         newDeps.push(newModule);
     }
     return newDeps;
   }
 }
 
 function updateApplicationDescriptor(descriptorFileName, newModuleSet) {
   let descriptorPath = path.join(FRONTEND_PATH, descriptorFileName);
   let newModules = [...newModuleSet].filter(m => APPLICATIONS_BY_MODULE[m].includes(descriptorFileName));
+  if (newModules.length === 0)
+      return;
   let includeNewModules = (acc, line) => {
     if (line.includes('{') && line.endsWith('}')) {
       line += ',';
       acc.push(line);
       return acc.concat(newModules.map((m, i) => {
         // Need spacing to preserve indentation
         let string;
         if (MODULE_MAPPING[m].autostart)
           string = `        { "name": "${m}", "type": "autostart"}`;
         else
@@ skipping 39 matching lines @@
   return string.split("")
     .map(function (char) {
       var charCode = char.charCodeAt(0);
       return charCode > 127 ? unicodeCharEscape(charCode) : char;
     })
     .join("");
 }
 
 if (require.main === module)
   extractModule();