[CT] Add ability to run unlanded benchmarks on Chromium Perf

ct/go/worker_scripts/run_chromium_perf/main.go

 // run_chromium_perf is an application that runs the specified benchmark over CT's
 // webpage archives.
 package main
 
 import (
+        "bytes"
         "encoding/csv"
         "flag"
         "fmt"
         "io/ioutil"
         "os"
         "path/filepath"
         "runtime"
         "sync"
         "time"
 
@@ skipping 11 matching lines @@
 const (
         // The number of goroutines that will run in parallel to run benchmarks.
         WORKER_POOL_SIZE = 10
 )
 
 var (
         workerNum                 = flag.Int("worker_num", 1, "The number of this CT worker. It will be in the {1..100} range.")
         pagesetType               = flag.String("pageset_type", util.PAGESET_TYPE_MOBILE_10k, "The type of pagesets to create from the Alexa CSV list. Eg: 10k, Mobile10k, All.")
         chromiumBuildNoPatch      = flag.String("chromium_build_nopatch", "", "The chromium build to use for the nopatch run.")
         chromiumBuildWithPatch    = flag.String("chromium_build_withpatch", "", "The chromium build to use for the withpatch run.")
+        runID                     = flag.String("run_id", "", "The unique run id (typically requester + timestamp).")
         runIDNoPatch              = flag.String("run_id_nopatch", "", "The unique run id (typically requester + timestamp) for the nopatch run.")
         runIDWithPatch            = flag.String("run_id_withpatch", "", "The unique run id (typically requester + timestamp) for the withpatch run.")
         benchmarkName             = flag.String("benchmark_name", "", "The telemetry benchmark to run on this worker.")
         benchmarkExtraArgs        = flag.String("benchmark_extra_args", "", "The extra arguments that are passed to the specified benchmark.")
         browserExtraArgsNoPatch   = flag.String("browser_extra_args_nopatch", "", "The extra arguments that are passed to the browser while running the benchmark during the nopatch run.")
         browserExtraArgsWithPatch = flag.String("browser_extra_args_withpatch", "", "The extra arguments that are passed to the browser while running the benchmark during the withpatch run.")
         repeatBenchmark           = flag.Int("repeat_benchmark", 3, "The number of times the benchmark should be repeated. For skpicture_printer benchmark this value is always 1.")
         runInParallel             = flag.Bool("run_in_parallel", false, "Run the benchmark by bringing up multiple chrome instances in parallel.")
         targetPlatform            = flag.String("target_platform", util.PLATFORM_ANDROID, "The platform the benchmark will run on (Android / Linux).")
         chromeCleanerTimer        = flag.Duration("cleaner_timer", 15*time.Minute, "How often all chrome processes will be killed on this slave.")
@@ skipping 10 matching lines @@
 
         // Validate required arguments.
         if *chromiumBuildNoPatch == "" {
                 glog.Error("Must specify --chromium_build_nopatch")
                 return
         }
         if *chromiumBuildWithPatch == "" {
                 glog.Error("Must specify --chromium_build_withpatch")
                 return
         }
+        if *runID == "" {
+                glog.Error("Must specify --run_id")
+                return
+        }
         if *runIDNoPatch == "" {
                 glog.Error("Must specify --run_id_nopatch")
                 return
         }
         if *runIDWithPatch == "" {
                 glog.Error("Must specify --run_id_withpatch")
                 return
         }
         if *benchmarkName == "" {
                 glog.Error("Must specify --benchmark_name")
@@ skipping 29 matching lines @@
                         util.ADB_ROOT_TIMEOUT, nil, nil))
         }
 
         // Instantiate GsUtil object.
         gs, err := util.NewGsUtil(nil)
         if err != nil {
                 glog.Error(err)
                 return
         }
 
+        // Download the benchmark patch for this run from Google storage.
+        benchmarkPatchName := *runID + ".benchmark.patch"
+        benchmarkPatchLocalPath := filepath.Join(os.TempDir(), benchmarkPatchName)
+        remoteDir := filepath.Join(util.ChromiumPerfRunsDir, *runID)
+        benchmarkPatchRemotePath := filepath.Join(remoteDir, benchmarkPatchName)
+        respBody, err := gs.GetRemoteFileContents(benchmarkPatchRemotePath)
+        if err != nil {
+                glog.Errorf("Could not fetch %s: %s", benchmarkPatchRemotePath, err)
+                return
+        }
+        defer skutil.Close(respBody)
+        buf := new(bytes.Buffer)
+        if _, err := buf.ReadFrom(respBody); err != nil {
+                glog.Errorf("Could not read from %s: %s", benchmarkPatchRemotePath, err)
+                return
+        }
+        if err := ioutil.WriteFile(benchmarkPatchLocalPath, buf.Bytes(), 0666); err != nil {
+                glog.Errorf("Unable to create file %s: %s", benchmarkPatchLocalPath, err)
+                return
+        }
+        defer skutil.Remove(benchmarkPatchLocalPath)
+        // Apply benchmark patch to the local chromium checkout.
+        if buf.Len() > 10 {
+                if err := util.ApplyPatch(benchmarkPatchLocalPath, util.ChromiumSrcDir); err != nil {
+                        glog.Errorf("Could not apply Telemetry's patch in %s: %s", util.ChromiumSrcDir, err)
+                        return
+                }
+        }
+
         // Download the specified chromium builds.
         for _, chromiumBuild := range []string{*chromiumBuildNoPatch, *chromiumBuildWithPatch} {
                 if err := gs.DownloadChromiumBuild(chromiumBuild); err != nil {
                         glog.Error(err)
                         return
                 }
                 //Delete the chromium build to save space when we are done.
                 defer skutil.RemoveAll(filepath.Join(util.ChromiumBuildsDir, chromiumBuild))
         }
 
@@ skipping 120 matching lines @@
 
         // Read the pageset.
         pagesetName := strings.TrimSuffix(pagesetBaseName, filepath.Ext(pagesetBaseName))
         pagesetPath := filepath.Join(pathToPagesets, fileInfoName)
         decodedPageset, err := util.ReadPageset(pagesetPath)
         if err != nil {
                 return fmt.Errorf("Could not read %s: %s", pagesetPath, err)
         }
 
         glog.Infof("===== Processing %s for %s =====", pagesetPath, runID)
+        pagesetName, present := util.BenchmarksToPagesetName[*benchmarkName]
+        if !present {
+                // If it is custom benchmark use the entered benchmark name.
+                pagesetName = *benchmarkName
+        }
         args := []string{
                 filepath.Join(util.TelemetryBinariesDir, util.BINARY_RUN_BENCHMARK),
-                util.BenchmarksToPagesetName[*benchmarkName],
+                pagesetName,
                 "--also-run-disabled-tests",
                 "--user-agent=" + decodedPageset.UserAgent,
                 "--urls-list=" + decodedPageset.UrlsList,
                 "--archive-data-file=" + decodedPageset.ArchiveDataFile,
         }
 
         // Need to capture output for all benchmarks.
         outputDirArgValue := filepath.Join(localOutputDir, pagesetName)
         args = append(args, "--output-dir="+outputDirArgValue)
         // Figure out which browser should be used.
@@ skipping 116 matching lines @@
                 return fmt.Errorf("Could not write to %s: %s", csvPath, err)
         }
         // Write all values.
         for _, row := range values {
                 if err := writer.Write(row); err != nil {
                         return fmt.Errorf("Could not write to %s: %s", csvPath, err)
                 }
         }
         return nil
 }