Make targets full Context objects, and them push them on the context stack

BUG=355562

Review URL: https://codereview.chromium.org/209003011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@259071 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 92 insertions, 81 deletions

diff --git a/tools/cr/cr/actions/adb.py b/tools/cr/cr/actions/adb.py
index 54eebe95..7e14120 100644
--- a/tools/cr/cr/actions/adb.py
+++ b/tools/cr/cr/actions/adb.py
@@ -24,7 +24,8 @@ class Adb(object):
   def GetPids(cls, target):
     """Gets the set of running PIDs that match the specified target."""
     pids = []
-    output = cr.Host.Capture(target, '{CR_ADB}', 'shell', 'ps')
+    with target:
+      output = cr.Host.Capture('{CR_ADB}', 'shell', 'ps')
     pattern = re.compile(r'\S+\s+(\d+)\s+.*{CR_PROCESS}')
     for line in output.split('\n'):
       match = re.match(pattern, line)
@@ -35,13 +36,13 @@ class Adb(object):
   @classmethod
   def Run(cls, target, arguments):
     """Invoke a target binary on the device."""
-    cr.Host.Execute(
-        target,
-        '{CR_ADB}', 'shell', 'am', 'start',
-        '-a', '{CR_ACTION}',
-        '-n', '{CR_INTENT}',
-        '{CR_RUN_ARGUMENTS}',
-        *arguments
+    with target:
+      cr.Host.Execute(
+          '{CR_ADB}', 'shell', 'am', 'start',
+          '-a', '{CR_ACTION}',
+          '-n', '{CR_INTENT}',
+          '{CR_RUN_ARGUMENTS}',
+          *arguments
     )
 
   @classmethod
@@ -53,49 +54,50 @@ class Adb(object):
       return
     pids = cls.GetPids(target)
     if pids:
-      cr.Host.Execute(target, '{CR_ADB}', 'shell', 'kill', *pids)
+      with target:
+        cr.Host.Execute('{CR_ADB}', 'shell', 'kill', *pids)
     elif target.verbose:
       print target.Substitute('{CR_TARGET_NAME} not running')
     cls._kills[target_name] = True
 
   @classmethod
   def Uninstall(cls, target, arguments):
-    cr.Host.Execute(
-        target,
-        '{CR_ADB}', 'uninstall',
-        '{CR_PACKAGE}',
-        *arguments
+    with target:
+      cr.Host.Execute(
+          '{CR_ADB}', 'uninstall',
+          '{CR_PACKAGE}',
+          *arguments
     )
 
   @classmethod
   def Install(cls, target, arguments):
-    cr.Host.Execute(
-        target,
-        '{CR_ADB}', 'install',
-        '{CR_BINARY}',
-        *arguments
+    with target:
+      cr.Host.Execute(
+          '{CR_ADB}', 'install',
+          '{CR_BINARY}',
+          *arguments
     )
 
   @classmethod
   def Reinstall(cls, target, arguments):
-    cr.Host.Execute(
-        target,
-        '{CR_ADB}', 'install',
-        '-r',
-        '{CR_BINARY}',
-        *arguments
+    with target:
+      cr.Host.Execute(
+          '{CR_ADB}', 'install',
+          '-r',
+          '{CR_BINARY}',
+          *arguments
     )
 
   @classmethod
   def AttachGdb(cls, target, arguments):
-    cr.Host.Execute(
-        target,
-        '{CR_ADB_GDB}',
-        '--adb={CR_ADB}',
-        '--symbol-dir=${CR_BUILD_DIR}/lib',
-        '--program-name={CR_TARGET_NAME}',
-        '--package-name={CR_PACKAGE}',
-        *arguments
+    with target:
+      cr.Host.Execute(
+          '{CR_ADB_GDB}',
+          '--adb={CR_ADB}',
+          '--symbol-dir=${CR_BUILD_DIR}/lib',
+          '--program-name={CR_TARGET_NAME}',
+          '--package-name={CR_PACKAGE}',
+          *arguments
     )
 
 
@@ -114,8 +116,8 @@ class AdbRunner(cr.Runner):
     Adb.Run(target, arguments)
 
   def Test(self, target, arguments):
-    cr.Host.Execute(
-        target,
+    with target:
+      cr.Host.Execute(
         '{CR_TEST_RUNNER}', '{CR_TEST_TYPE}',
         '-s', '{CR_TARGET_NAME}',
         '--{CR_TEST_MODE}',
diff --git a/tools/cr/cr/actions/gdb.py b/tools/cr/cr/actions/gdb.py
index 841c2c1..cdbb1bf 100644
--- a/tools/cr/cr/actions/gdb.py
+++ b/tools/cr/cr/actions/gdb.py
@@ -19,12 +19,12 @@ class GdbDebugger(cr.Debugger):
 
   def Invoke(self, targets, arguments):
     for target in targets:
-      cr.Host.Execute(
-          target,
-          '{CR_GDB}', '--eval-command=run', '--args',
-          '{CR_BINARY}',
-          '{CR_RUN_ARGUMENTS}',
-          *arguments
+      with target:
+        cr.Host.Execute(
+            '{CR_GDB}', '--eval-command=run', '--args',
+            '{CR_BINARY}',
+            '{CR_RUN_ARGUMENTS}',
+            *arguments
       )
 
   def Attach(self, targets, arguments):
diff --git a/tools/cr/cr/actions/linux.py b/tools/cr/cr/actions/linux.py
index b56c797..0e869ee 100644
--- a/tools/cr/cr/actions/linux.py
+++ b/tools/cr/cr/actions/linux.py
@@ -22,7 +22,8 @@ class LinuxRunner(cr.Runner):
     print '**WARNING** Kill not yet implemented on linux'
 
   def Run(self, target, arguments):
-    cr.Host.Execute(target, '{CR_BINARY}', '{CR_RUN_ARGUMENTS}', *arguments)
+    with target:
+      cr.Host.Execute('{CR_BINARY}', '{CR_RUN_ARGUMENTS}', *arguments)
 
   def Test(self, target, arguments):
     self.Run(target, arguments)
diff --git a/tools/cr/cr/base/context.py b/tools/cr/cr/base/context.py
index b700519..1081fd1 100644
--- a/tools/cr/cr/base/context.py
+++ b/tools/cr/cr/base/context.py
@@ -98,32 +98,43 @@ class _ArgumentParser(argparse.ArgumentParser):
 _stack = []
 
 
-class _Context(cr.config.Config):
+class _ContextData:
+  pass
+
+
+class Context(cr.config.Config):
   """The base context holder for the cr system.
 
   This holds the common context shared throughout cr.
   Mostly this is stored in the Config structure of variables.
   """
 
-  def __init__(self, description='', epilog=''):
-    super(_Context, self).__init__('Context')
-    self._args = None
-    self._arguments = cr.config.Config('ARGS')
-    self._derived = cr.config.Config('DERIVED')
+  def __init__(self, name='Context'):
+    super(Context, self).__init__(name)
+    self._data = _ContextData()
+
+  def CreateData(self, description='', epilog=''):
+    self._data.args = None
+    self._data.arguments = cr.config.Config('ARGS')
+    self._data.derived = cr.config.Config('DERIVED')
     self.AddChildren(*cr.config.GLOBALS)
     self.AddChildren(
         cr.config.Config('ENVIRONMENT', literal=True, export=True).Set(
             {k: self.ParseValue(v) for k, v in os.environ.items()}),
-        self._arguments,
-        self._derived,
+        self._data.arguments,
+        self._data.derived,
     )
     # Build the command line argument parser
-    self._parser = _ArgumentParser(add_help=False, description=description,
-                                   epilog=epilog)
-    self._subparsers = self.parser.add_subparsers()
+    self._data.parser = _ArgumentParser(add_help=False, description=description,
+                                        epilog=epilog)
+    self._data.subparsers = self.parser.add_subparsers()
     # Add the global arguments
-    self.AddCommonArguments(self._parser)
-    self._gclient = {}
+    self.AddCommonArguments(self._data.parser)
+    self._data.gclient = {}
+
+  @property
+  def data(self):
+    return self._data
 
   def __enter__(self):
     """ To support using 'with cr.base.context.Create():'"""
@@ -138,7 +149,7 @@ class _Context(cr.config.Config):
     return False
 
   def AddSubParser(self, source):
-    parser = source.AddArguments(self._subparsers)
+    parser = source.AddArguments(self._data.subparsers)
 
   @classmethod
   def AddCommonArguments(cls, parser):
@@ -168,27 +179,27 @@ class _Context(cr.config.Config):
 
   @property
   def args(self):
-    return self._args
+    return self._data.args
 
   @property
   def arguments(self):
-    return self._arguments
+    return self._data.arguments
 
   @property
   def speculative(self):
-    return self._speculative
+    return self._data.speculative
 
   @property
   def derived(self):
-    return self._derived
+    return self._data.derived
 
   @property
   def parser(self):
-    return self._parser
+    return self._data.parser
 
   @property
   def remains(self):
-    remains = getattr(self._args, '_remains', None)
+    remains = getattr(self._data.args, '_remains', None)
     if remains and remains[0] == '--':
       remains = remains[1:]
     return remains
@@ -211,21 +222,24 @@ class _Context(cr.config.Config):
 
   @property
   def gclient(self):
-    if not self._gclient:
-      self._gclient = cr.base.client.ReadGClient()
-    return self._gclient
+    if not self._data.gclient:
+      self._data.gclient = cr.base.client.ReadGClient()
+    return self._data.gclient
 
   def ParseArgs(self, speculative=False):
     cr.plugin.DynamicChoices.only_active = not speculative
-    self._speculative = speculative
-    self._args = self._parser.parse_args()
-    self._arguments.Wipe()
-    if self._args:
-      self._arguments.Set(
-          {k: v for k, v in vars(self._args).items() if v is not None})
+    self._data.speculative = speculative
+    self._data.args = self._data.parser.parse_args()
+    self._data.arguments.Wipe()
+    if self._data.args:
+      self._data.arguments.Set(
+          {k: v for k, v in vars(self._data.args).items() if v is not None})
 
   def DumpValues(self, with_source):
     _DumpVisitor(with_source).VisitNode(self)
 
+
 def Create(description='', epilog=''):
-  return _Context(description=description, epilog=epilog)
+  context = Context()
+  context.CreateData(description=description, epilog=epilog)
+  return context
diff --git a/tools/cr/cr/targets/target.py b/tools/cr/cr/targets/target.py
index 295d59d..cef67f2 100644
--- a/tools/cr/cr/targets/target.py
+++ b/tools/cr/cr/targets/target.py
@@ -7,13 +7,14 @@ import operator
 import re
 
 import cr
+import cr.base.context
 
 DEFAULT = cr.Config.From(
     CR_DEFAULT_TARGET='chrome',
 )
 
 
-class Target(cr.Config, cr.AutoExport):
+class Target(cr.base.context.Context, cr.AutoExport):
   """Base class for implementing cr targets.
 
   A target is something that can be built and run.
@@ -44,6 +45,7 @@ class Target(cr.Config, cr.AutoExport):
         CR_RUN_ARGUMENTS='',
         CR_TEST_TYPE=test_type,
     )
+    self._data = cr.context.data
     self.AddChildren(config, cr.context)
     if hasattr(self, 'CONFIG'):
       self.AddChild(self.CONFIG)
@@ -57,14 +59,6 @@ class Target(cr.Config, cr.AutoExport):
     return self.Get('CR_BUILD_TARGET')
 
   @property
-  def verbose(self):
-    return cr.context.verbose
-
-  @property
-  def dry_run(self):
-    return cr.context.dry_run
-
-  @property
   def valid(self):
     return cr.Builder.IsTarget(self.build_target)