[android] Create Battery Utils to seperate power functionality

build/android/pylib/device/device_utils.py

Index: build/android/pylib/device/device_utils.py
diff --git a/build/android/pylib/device/device_utils.py b/build/android/pylib/device/device_utils.py
index 9f538e1b0efd9f51ffaa4c1345febe8149edccc6..e36047b10466b0c80147f17a2850265cb3241ec5 100644
--- a/build/android/pylib/device/device_utils.py
+++ b/build/android/pylib/device/device_utils.py
@@ -1438,6 +1438,7 @@ class DeviceUtils(object):
     """
     return logcat_monitor.LogcatMonitor(self.adb, *args, **kwargs)
 
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def GetBatteryInfo(self, timeout=None, retries=None):
     """Gets battery info for the device.
@@ -1465,6 +1466,7 @@ class DeviceUtils(object):
         result[k.strip()] = v.strip()
     return result
 
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def GetCharging(self, timeout=None, retries=None):
     """Gets the charging state of the device.
@@ -1482,6 +1484,7 @@ class DeviceUtils(object):
         return True
     return False
 
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def SetCharging(self, enabled, timeout=None, retries=None):
     """Enables or disables charging on the device.
@@ -1512,7 +1515,7 @@ class DeviceUtils(object):
 
     timeout_retry.WaitFor(set_and_verify_charging, wait_period=1)
 
-  # TODO(rnephew): Make private when all use cases can use the context manager.
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def DisableBatteryUpdates(self, timeout=None, retries=None):
     """ Resets battery data and makes device appear like it is not
@@ -1542,7 +1545,7 @@ class DeviceUtils(object):
                          check_return=True)
     timeout_retry.WaitFor(battery_updates_disabled, wait_period=1)
 
-  # TODO(rnephew): Make private when all use cases can use the context manager.
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def EnableBatteryUpdates(self, timeout=None, retries=None):
     """ Restarts device charging so that dumpsys no longer collects power data.
@@ -1559,6 +1562,7 @@ class DeviceUtils(object):
     self.RunShellCommand(['dumpsys', 'battery', 'reset'], check_return=True)
     timeout_retry.WaitFor(battery_updates_enabled, wait_period=1)
 
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @contextlib.contextmanager
   def BatteryMeasurement(self, timeout=None, retries=None):
     """Context manager that enables battery data collection. It makes
@@ -1648,3 +1652,20 @@ class DeviceUtils(object):
       return parallelizer.Parallelizer(devices)
     else:
       return parallelizer.SyncParallelizer(devices)
+
+  # TODO(rnephew): Implement cache class.
+  def GetCacheEntry(self, key):

[perezju, 2015/03/30 11:05:23]

I'm not sure I like this idea. Why would a class expose its private cache to the
public? Seems like an invitation to mess with its internal state, and break
assumptions that methods using the cache may be making about it.

We may want a Cache class (if we really feel like we need some features not
already provided by a simple dictionary), but even then I also think that the
_cache object itself should be a private member.

If BatteryUtils needs a cache, it should use its own private one, either some
instance of a fancy Cache class or just a simple dictionary. This would also
lessen the worry of "others" overriding what we put in the cache. Thoughts?

(Also, BatteryUtils does not seem to be using this yet. So maybe material for
another CL?)

[jbudorick, 2015/03/30 13:35:03]

BatteryUtils doesn't know how to control the lifetime of cache variables;
DeviceUtils does. The cache functionality is the only reason
GetCharging/SetCharging are in DeviceUtils. They'd otherwise be implemented
separately (which is the driving reason behind this change, iirc).

That said, the current implementation is still problematic. If DeviceUtils is
providing the cache, the implementation needs to keep the client caches separate
from its own cache.

[rnephew (Wrong account), 2015/03/30 17:50:29]

It will use this when it stops passing the calls through to device_utils and
does everything in its own implementation.
Done.

+    """Cache getter."""
+    return self._cache.get(key)
+
+  def SetCacheEntry(self, key, value, override=False):
+    """Cache setter."""
+    if key not in self._cache:
+      self._cache[key] = value
+    elif override and value != self._cache[key]:
+      logging.warning('%s already in cache. Overriding %s with %s.', key,
+                      self._cache[key], value)
+      self._cache[key] = value
+    else:
+      logging.warning('%s already in cache. Not overriding %s with %s.', key,
+                      self._cache[key], value)