Make telemetry platform a singleton

tools/telemetry/telemetry/core/platform/__init__.py

 # Copyright 2012 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.
 
-from telemetry.core.platform import factory
+import sys
 
+def _CreateHostPlatformBackend():
+  if sys.platform.startswith('linux'):
+    from telemetry.core.platform import linux_platform_backend
+    return linux_platform_backend.LinuxPlatformBackend()
+  elif sys.platform == 'darwin':
+    from telemetry.core.platform import mac_platform_backend
+    return mac_platform_backend.MacPlatformBackend()
+  elif sys.platform == 'win32':
+    from telemetry.core.platform import win_platform_backend
+    return win_platform_backend.WinPlatformBackend()
+  else:
+    raise NotImplementedError()
+
+_host_platform = None
+
+def ResetHostPlatformSingleton():

[tonyg, 2014/08/02 15:58:18]

What's the use case for resetting? I can't think of a case where the host would
change.

+  global _host_platform
+  if _host_platform:
+    _host_platform.Close()
+    _host_platform = None
+
+def GetHostPlatformName():
+  if sys.platform.startswith('linux'):
+    return 'linux'

[tonyg, 2014/08/02 15:58:18]

This ends up duplicating strings from the platforms themselves. Do you think we
really need the GetHostPlatformName() sugar, or is it fine to do
GetHostPlatform().GetOSName()?

+  elif sys.platform == 'darwin':
+    return 'mac'
+  elif sys.platform == 'win32':
+    return 'win'
+  else:
+    raise NotImplementedError()
 
 def GetHostPlatform():
-  return Platform(factory.GetPlatformBackendForCurrentOS())
-
+  global _host_platform
+  if not _host_platform:
+    _host_platform = Platform(_CreateHostPlatformBackend())
+  return _host_platform
 
 class Platform(object):
   """The platform that the target browser is running on.
 
   Provides a limited interface to interact with the platform itself, where
   possible. It's important to note that platforms may not provide a specific
   API, so check with IsFooBar() for availability.
   """
   def __init__(self, platform_backend):
     self._platform_backend = platform_backend
+    self._platform_backend.SetPlatform(self)
+
+  def Close(self):
+    pass
 
   def IsRawDisplayFrameRateSupported(self):
     """Platforms may be able to collect GL surface stats."""
     return self._platform_backend.IsRawDisplayFrameRateSupported()
 
   def StartRawDisplayFrameRateMeasurement(self):
     """Start measuring GL surface stats."""
     return self._platform_backend.StartRawDisplayFrameRateMeasurement()
 
   def StopRawDisplayFrameRateMeasurement(self):
@@ skipping 197 matching lines @@
             'average_temperature_c': c,
 
             ...
           }
 
           ...
         }
       }
     """
     return self._platform_backend.StopMonitoringPower()
+
+  def GetChildPids(self, pid):

[tonyg, 2014/08/02 15:58:18]

Isn't this a backendy thing? Are we really exposing this to the API?

I know in the past we've been pretty careful about making sure Measurements are
agnostic of pids.

+    return self._platform_backend.GetChildPids(pid)
+
+  def GetCommandLine(self, pid):
+    return self._platform_backend.GetCommandLine(pid)
+
+  def WillGetMemoryStats(self):

[tonyg, 2014/08/02 15:58:18]

Seems like another good thing to hide from the API. We shouldn't trust
Measurements to have to call Will/Dids at the right point, right?

+    self._platform_backend.PurgeUnpinnedMemory()
+
+  def GetMemoryStats(self, pid):
+    return self._platform_backend.GetMemoryStats(pid)
+
+  def GetSystemCommitCharge(self):
+    return self._platform_backend.GetSystemCommitCharge()
+
+  def GetSystemTotalPhysicalMemory(self):
+    return self._platform_backend.GetSystemTotalPhysicalMemory()
+
+  def GetCpuStats(self, pid):
+    return self._platform_backend.GetCpuStats(pid)
+
+  def GetIOStats(self, pid):
+    return self._platform.GetIOStats(pid)
+
+  def InstantiateProfiler(self, profiler_class, browser_backend,
+                          base_output_file, state):
+    return profiler_class(browser_backend, self, base_output_file, state)
+
+  def WillCloseBrowser(self, browser_backend, profiler_classes):
+    for cls in profiler_classes:
+      cls.WillCloseBrowser(browser_backend, self._platform_backend)