[wpr-go] Add support install test root CA on Android

web_page_replay_go/src/wpr.go

 // 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.
 
 // Program wpr records and replays web traffic.
 package main
 
 import (
         "crypto/tls"
         "errors"
@@ skipping 65 matching lines @@
 type ReplayCommand struct {
         common CommonConfig
         cmd    cli.Command
 
         // Custom flags for replay.
         rulesFile string
 }
 
 type RootCACommand struct {
         certConfig CertConfig
+        installer  webpagereplay.Installer
         cmd        cli.Command
 }
 
 func (certCfg *CertConfig) Flags() []cli.Flag {
         return []cli.Flag{
                 cli.StringFlag{
                         Name:        "https_cert_file",
                         Value:       "wpr_cert.pem",
                         Usage:       "File containing a PEM-encoded X509 certificate to use with SSL.",
                         Destination: &certCfg.certFile,
@@ skipping 88 matching lines @@
 func (r *ReplayCommand) Flags() []cli.Flag {
         return append(r.common.Flags(),
                 cli.StringFlag{
                         Name:        "rules_file",
                         Value:       "",
                         Usage:       "File containing rules to apply to responses during replay",
                         Destination: &r.rulesFile,
                 })
 }
 
+func (r *RootCACommand) Flags() []cli.Flag {
+        return append(r.certConfig.Flags(),
+                cli.StringFlag{
+                        Name:        "android_device_id",
+                        Value:       "",
+                        Usage:       "Device id of an android device. Only relevant for Android",
+                        Destination: &r.installer.AndroidDeviceId,
+                },
+                cli.StringFlag{
+                        Name:        "adb_binary_path",
+                        Value:       "adb",
+                        Usage:       "Path to adb binary. Only relevant for Android",
+                        Destination: &r.installer.AdbBinaryPath,
+                })
+}
+
 func getListener(port int) (net.Listener, error) {
         addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("localhost:%d", port))
         if err != nil {
                 return nil, err
         }
         return net.ListenTCP("tcp", addr)
 }
 
 // Copied from https://golang.org/src/net/http/server.go.
 // This is to make dead TCP connections to eventually go away.
@@ skipping 147 matching lines @@
         httpsHandler := webpagereplay.NewReplayingProxy(archive, "https", r.common.transformers)
         tlsconfig, err := webpagereplay.ReplayTLSConfig(r.common.root_cert, archive)
         if err != nil {
                 fmt.Fprintf(os.Stderr, "Error creating TLSConfig: %v", err)
                 os.Exit(1)
         }
         startServers(tlsconfig, httpHandler, httpsHandler, &r.common)
 }
 
 func (r *RootCACommand) Install(c *cli.Context) {
-        log.Printf("Loading cert from %v\n", r.certConfig.certFile)
-        log.Printf("Loading key from %v\n", r.certConfig.keyFile)
-        root_cert, err := tls.LoadX509KeyPair(r.certConfig.certFile, r.certConfig.keyFile)
-        if err != nil {
-                fmt.Fprintf(os.Stderr, "error opening cert or key files: %v", err)
+        if err := r.installer.InstallRoot(r.certConfig.certFile, r.certConfig.keyFile); err != nil {
+                fmt.Fprintf(os.Stderr, "Install root failed: %v", err)
                 os.Exit(1)
         }
-        err = webpagereplay.InstallRoot(root_cert.Certificate[0])
-        if err != nil {
-                fmt.Fprintf(os.Stderr, "Install root failed: %v", err)
-        }
 }
 
 func (r *RootCACommand) Remove(c *cli.Context) {
-        webpagereplay.RemoveRoot()
+        r.installer.RemoveRoot()
 }
 
 func main() {
         progName := filepath.Base(os.Args[0])
 
         var record RecordCommand
         var replay ReplayCommand
         var installroot RootCACommand
         var removeroot RootCACommand
 
         record.cmd = cli.Command{
                 Name:   "record",
                 Usage:  "Record web pages to an archive",
                 Flags:  record.Flags(),
                 Before: record.common.CheckArgs,
                 Action: record.Run,
         }
 
         replay.cmd = cli.Command{
                 Name:   "replay",
                 Usage:  "Replay a previously-recorded web page archive",
                 Flags:  replay.Flags(),
                 Before: replay.common.CheckArgs,
                 Action: replay.Run,
         }
 
         installroot.cmd = cli.Command{
                 Name:   "installroot",
                 Usage:  "Install a test root CA",
-                Flags:  installroot.certConfig.Flags(),
+                Flags:  installroot.Flags(),
                 Action: installroot.Install,
         }
 
         removeroot.cmd = cli.Command{
                 Name:   "removeroot",
                 Usage:  "Remove a test root CA",
+                Flags:  removeroot.Flags(),
                 Action: removeroot.Remove,
         }
 
         // TODO(xunjieli): Remove ConvertorCommand once crbug.com/730036 is done.
         type ConvertorCommand struct {
                 cfg webpagereplay.ConvertorConfig
                 cmd cli.Command
         }
         var convert ConvertorCommand
         convert.cmd = cli.Command{
                 Name:   "convert",
                 Flags:  convert.cfg.Flags(),
                 Usage:  "Convert a legacy format to the new format",
                 Action: convert.cfg.Convert,
         }
 
         app := cli.NewApp()
         app.Commands = []cli.Command{record.cmd, replay.cmd, installroot.cmd, removeroot.cmd, convert.cmd}
         app.Usage = "Web Page Replay"
         app.UsageText = fmt.Sprintf(longUsage, progName, progName)
         app.HideVersion = true
         app.Version = ""
         app.Writer = os.Stderr
         app.RunAndExitOnError()
 }