DevTools: enable backwards-compatibility testing

third_party/WebKit/Source/devtools/scripts/npm_test.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.
 
 var childProcess = require("child_process");
 var fs = require("fs");
 var path = require("path");
 var shell = require("child_process").execSync;
 
 var utils = require("./utils");
 
 var Flags = {
     DEBUG_DEVTOOLS: "--debug-devtools",
     DEBUG_DEVTOOLS_SHORTHAND: "-d",
     FETCH_CONTENT_SHELL: "--fetch-content-shell",
+    COMPAT_PROTOCOL: "--compat-protocol",
+};
+
+var COMPAT_URL_MAPPING = {
+    "1.2": "https://storage.googleapis.com/content-shell-devtools-compat/content_shell_417361.zip",
 };
 
 var IS_DEBUG_ENABLED = utils.includes(process.argv, Flags.DEBUG_DEVTOOLS) ||
     utils.includes(process.argv, Flags.DEBUG_DEVTOOLS_SHORTHAND);
+var COMPAT_PROTOCOL = utils.parseArgs(process.argv)[Flags.COMPAT_PROTOCOL];
 var IS_FETCH_CONTENT_SHELL = utils.includes(process.argv, Flags.FETCH_CONTENT_SHELL);
 
 var CONTENT_SHELL_ZIP = "content-shell.zip";
 var MAX_CONTENT_SHELLS = 10;
 var PLATFORM = getPlatform();
 var PYTHON = process.platform === "win32" ? "python.bat" : "python";
 
 var CHROMIUM_SRC_PATH = path.resolve(__dirname, "..", "..", "..", "..", "..");
 var RELEASE_PATH = path.resolve(CHROMIUM_SRC_PATH, "out", "Release");
 var BLINK_TEST_PATH = path.resolve(CHROMIUM_SRC_PATH, "blink", "tools", "run_layout_tests.py");
 var CACHE_PATH = path.resolve(__dirname, "..", ".test_cache");
 var SOURCE_PATH = path.resolve(__dirname, "..", "front_end");
 
 function main(){
+    if (!utils.isDir(CACHE_PATH))
+        fs.mkdirSync(CACHE_PATH);
+    deleteOldContentShells();
+
+    if (COMPAT_PROTOCOL) {
+        runCompatibilityTests();
+        return;
+    }
     var hasUserCompiledContentShell = utils.isFile(getContentShellBinaryPath(RELEASE_PATH));
     if (!IS_FETCH_CONTENT_SHELL && hasUserCompiledContentShell) {
         var outDir = path.resolve(RELEASE_PATH, "..");
         if (!IS_DEBUG_ENABLED) {
             compileFrontend();
         }
         runTests(outDir, IS_DEBUG_ENABLED);
         return;
     }
-    if (!utils.isDir(CACHE_PATH))
-        fs.mkdirSync(CACHE_PATH);
-    deleteOldContentShells();
+
     findPreviousUploadedPosition(findMostRecentChromiumCommit())
         .then(onUploadedCommitPosition)
         .catch(onError);
 
     function onError(error) {
         console.log("Unable to run tests because of error:", error);
         console.log(`Try removing the .test_cache folder [${CACHE_PATH}] and retrying`);
     }
 }
 main();
 
+function runCompatibilityTests()
+{
+    const folder = `compat-protocol-${COMPAT_PROTOCOL}`;
+    compileFrontend();
+    var outPath = path.resolve(CACHE_PATH, folder, "out");
+    var contentShellDirPath = path.resolve(outPath, "Release");
+    var hasCachedContentShell = utils.isFile(getContentShellBinaryPath(contentShellDirPath));
+    if (hasCachedContentShell) {
+        console.log(`Using cached content shell at: ${outPath}`);
+        copyFrontendToCompatBuildPath(contentShellDirPath, RELEASE_PATH);
+        runTests(outPath, IS_DEBUG_ENABLED);
+        return;
+    }
+    prepareContentShellDirectory(folder)
+        .then(() => downloadContentShell(COMPAT_URL_MAPPING[COMPAT_PROTOCOL], folder))
+        .then(extractContentShell)
+        .then(() => copyFrontendToCompatBuildPath(contentShellDirPath, RELEASE_PATH))
+        .then(() => runTests(outPath, IS_DEBUG_ENABLED));
+}
+
 function compileFrontend()
 {
     console.log("Compiling devtools frontend");
     try {
         shell(`ninja -C ${RELEASE_PATH} devtools_frontend_resources`);
     } catch (err) {
         console.log(err.stdout.toString());
         console.log('ERROR: Cannot compile frontend\n' + err);
         process.exit(1);
     }
 }
 
 function onUploadedCommitPosition(commitPosition)
 {
     var contentShellDirPath = path.resolve(CACHE_PATH, commitPosition, "out", "Release");
     var contentShellResourcesPath = path.resolve(contentShellDirPath, "resources");
     var contentShellPath = path.resolve(CACHE_PATH, commitPosition, "out");
 
     var hasCachedContentShell = utils.isFile(getContentShellBinaryPath(contentShellDirPath));
     if (hasCachedContentShell) {
         console.log(`Using cached content shell at: ${contentShellPath}`);
         copyFrontend(contentShellResourcesPath);
         return runTests(contentShellPath, true);
     }
+    var url = `http://commondatastorage.googleapis.com/chromium-browser-snapshots/${PLATFORM}/${commitPosition}/${CONTENT_SHELL_ZIP}`;
     return prepareContentShellDirectory(commitPosition)
-        .then(downloadContentShell)
+        .then(() => downloadContentShell(url, commitPosition))
         .then(extractContentShell)
         .then(() => copyFrontend(contentShellResourcesPath))
         .then(() => runTests(contentShellPath, true));
 }
 
+function copyFrontendToCompatBuildPath(compatBuildPath, latestBuildPath)
+{
+    var customDevtoolsResourcesPath = path.resolve(compatBuildPath, "resources");
+    var latestDevtoolsInspectorPath  = path.resolve(latestBuildPath, "resources", "inspector");
+    var copiedFrontendPath = path.resolve(customDevtoolsResourcesPath, "inspector");
+    if (utils.isDir(copiedFrontendPath))
+        utils.removeRecursive(copiedFrontendPath);
+    utils.copyRecursive(latestDevtoolsInspectorPath, customDevtoolsResourcesPath);
+}
+
 function copyFrontend(contentShellResourcesPath)
 {
     var devtoolsResourcesPath = path.resolve(contentShellResourcesPath, "inspector");
     var copiedFrontendPath = path.resolve(devtoolsResourcesPath, "front_end");
     var debugFrontendPath = path.resolve(devtoolsResourcesPath, "debug");
     var inspectorBackendCommandsPath = path.resolve(devtoolsResourcesPath, "InspectorBackendCommands.js");
     var supportedCSSPropertiesPath = path.resolve(devtoolsResourcesPath, "SupportedCSSProperties.js");
     utils.removeRecursive(copiedFrontendPath);
     utils.removeRecursive(debugFrontendPath);
     utils.copyRecursive(SOURCE_PATH, devtoolsResourcesPath);
@@ skipping 65 matching lines @@
     }
 
     function onError(error)
     {
         if (error)
             console.log(`Received error: ${error} trying to fetch positions list from url: ${positionsListURL}`);
         throw new Error(`Unable to find a previous upload position for commit position: ${commitPosition}`);
     }
 }
 
-function prepareContentShellDirectory(contentShellCommitPosition)
+function prepareContentShellDirectory(folder)
 {
-    var contentShellPath = path.join(CACHE_PATH, contentShellCommitPosition);
+    var contentShellPath = path.join(CACHE_PATH, folder);
     if (utils.isDir(contentShellPath))
         utils.removeRecursive(contentShellPath);
     fs.mkdirSync(contentShellPath);
-    return Promise.resolve(contentShellCommitPosition);
+    return Promise.resolve(folder);
 }
 
-function downloadContentShell(commitPosition)
+function downloadContentShell(url, folder)
 {
-    var url = `http://commondatastorage.googleapis.com/chromium-browser-snapshots/${PLATFORM}/${commitPosition}/${CONTENT_SHELL_ZIP}`;
     console.log("Downloading content shell from:", url);
     console.log("NOTE: Download is ~35-65 MB depending on OS");
     return utils.fetch(url)
         .then(writeZip)
         .catch(onError);
 
     function writeZip(buffer)
     {
         console.log("Completed download of content shell");
-        var contentShellZipPath = path.join(CACHE_PATH, commitPosition, CONTENT_SHELL_ZIP);
+        var contentShellZipPath = path.join(CACHE_PATH, folder, CONTENT_SHELL_ZIP);
         fs.writeFileSync(contentShellZipPath, buffer);
         return contentShellZipPath;
     }
 
     function onError(error)
     {
         console.log(`Received error: ${error} trying to download content shell from url: ${url}`);
         throw new Error("Unable to download content shell");
     }
 }
@@ skipping 35 matching lines @@
     var testArgs = getInspectorTests().concat([
         "--no-pixel-tests",
         "--build-directory",
         buildDirectoryPath,
     ]);
     if (useDebugDevtools) {
         testArgs.push("--additional-driver-flag=--debug-devtools");
     } else {
         console.log("TIP: You can debug a test using: npm run debug-test inspector/test-name.html")
     }
+    if (COMPAT_PROTOCOL) {
+        testArgs.push(`--platform=linux-devtools-${COMPAT_PROTOCOL}`);
+    }
     if (IS_DEBUG_ENABLED) {
         testArgs.push("--additional-driver-flag=--remote-debugging-port=9222");
         testArgs.push("--time-out-ms=6000000");
         console.log("\n=============================================");
         console.log("Go to: http://localhost:9222/");
         console.log("Click on link and in console execute: test()");
         console.log("=============================================\n");
     }
     var args = [BLINK_TEST_PATH].concat(testArgs).concat(getTestFlags());
     console.log(`Running layout tests with args: ${args}`);
     childProcess.spawn(PYTHON, args, {stdio: "inherit"});
 }
 
 function getTestFlags()
 {
     var flagValues = Object.keys(Flags).map(key => Flags[key]);
     return process.argv
         .slice(2)
-        .filter(arg => !utils.includes(flagValues, arg) && !utils.includes(arg, "inspector"));
+        .filter(arg => {
+            var flagName = utils.includes(arg, "=") ? arg.slice(0, arg.indexOf('=')) : arg;
+            return !utils.includes(flagValues, flagName) && !utils.includes(arg, "inspector")
+        });
 }
 
 function getInspectorTests()
 {
     var specificTests = process.argv.filter(arg => utils.includes(arg, "inspector"));
     if (specificTests.length)
         return specificTests;
     return [
         "inspector*",
         "http/tests/inspector*",
     ];
 }