Make telemetry platform a singleton

tools/telemetry/telemetry/core/browser.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.
 
 import os
 
 from telemetry import decorators
 from telemetry.core import browser_credentials
 from telemetry.core import exceptions
 from telemetry.core import extension_dict
 from telemetry.core import local_server
 from telemetry.core import memory_cache_http_server
-from telemetry.core import platform
+from telemetry.core import platform as platform_module
 from telemetry.core import tab_list
 from telemetry.core import wpr_modes
 from telemetry.core import wpr_server
 from telemetry.core.backends import browser_backend
 from telemetry.core.platform.profiler import profiler_finder
 
 
 class Browser(object):
   """A running browser instance that can be controlled in a limited way.
 
   To create a browser instance, use browser_finder.FindBrowser.
 
   Be sure to clean up after yourself by calling Close() when you are done with
   the browser. Or better yet:
     browser_to_create = FindBrowser(options)
     with browser_to_create.Create() as browser:
       ... do all your operations on browser here
   """
-  def __init__(self, backend, platform_backend):
+  def __init__(self, backend, platform):
+    assert isinstance(platform, platform_module.Platform)
     self._browser_backend = backend
     self._http_server = None
     self._wpr_server = None
-    self._platform_backend = platform_backend
-    self._platform = platform.Platform(platform_backend)
+    self._platform = platform
     self._active_profilers = []
     self._profilers_states = {}
     self._local_server_controller = local_server.LocalServerController(backend)
     self._tabs = tab_list.TabList(backend.tab_list_backend)
     self.credentials = browser_credentials.BrowserCredentials()
     self._platform.SetFullPerformanceModeEnabled(True)
 
   def __enter__(self):
     self.Start()
     return self
@@ skipping 46 matching lines @@
     return extension_dict.ExtensionDict(self._browser_backend.extension_backend)
 
   @property
   def supports_tracing(self):
     return self._browser_backend.supports_tracing
 
   def is_profiler_active(self, profiler_name):
     return profiler_name in [profiler.name() for
                              profiler in self._active_profilers]
 
+
   def _GetStatsCommon(self, pid_stats_function):
     browser_pid = self._browser_backend.pid
     result = {
         'Browser': dict(pid_stats_function(browser_pid), **{'ProcessCount': 1}),
         'Renderer': {'ProcessCount': 0},
         'Gpu': {'ProcessCount': 0},
         'Other': {'ProcessCount': 0}
     }
     process_count = 1
-    for child_pid in self._platform_backend.GetChildPids(browser_pid):
+    for child_pid in self._platform.GetChildPids(browser_pid):
       try:
-        child_cmd_line = self._platform_backend.GetCommandLine(child_pid)
+        child_cmd_line = self._platform.GetCommandLine(child_pid)
         child_stats = pid_stats_function(child_pid)
       except exceptions.ProcessGoneException:
         # It is perfectly fine for a process to have gone away between calling
         # GetChildPids() and then further examining it.
         continue
       child_process_name = self._browser_backend.GetProcessName(child_cmd_line)
       process_name_type_key_map = {'gpu-process': 'Gpu', 'renderer': 'Renderer'}
       if child_process_name in process_name_type_key_map:
         child_process_type_key = process_name_type_key_map[child_process_name]
       else:
@@ skipping 42 matching lines @@
         'WorkingSetSizePeak': U,
         'ProportionalSetSize': V,
         'PrivateDirty': W
       },
       'SystemCommitCharge': X,
       'SystemTotalPhysicalMemory': Y,
       'ProcessCount': Z,
     }
     Any of the above keys may be missing on a per-platform basis.
     """
-    self._platform_backend.PurgeUnpinnedMemory()
-    result = self._GetStatsCommon(self._platform_backend.GetMemoryStats)
+    self._platform.WillGetMemoryStats()
+    result = self._GetStatsCommon(self._platform.GetMemoryStats)
     result['SystemCommitCharge'] = \
-        self._platform_backend.GetSystemCommitCharge()
+        self._platform.GetSystemCommitCharge()
     result['SystemTotalPhysicalMemory'] = \
-        self._platform_backend.GetSystemTotalPhysicalMemory()
+        self._platform.GetSystemTotalPhysicalMemory()
     return result
 
+
   @property
   def cpu_stats(self):

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

I think the root of the problem here is that these *_stats methods don't belong
on Browser. Instead, they should be available via Timeline.

The unfortunate thing about this patch's attempt to make these first class
citizens in Platform is that it means opening up all these things in the
Platform API more widely. WDYT?

     """Returns a dict of cpu statistics for the system.
     { 'Browser': {
         'CpuProcessTime': S,
         'TotalTime': T
       },
       'Gpu': {
         'CpuProcessTime': S,
         'TotalTime': T
       },
       'Renderer': {
         'CpuProcessTime': S,
         'TotalTime': T
       }
     }
     Any of the above keys may be missing on a per-platform basis.
     """
-    result = self._GetStatsCommon(self._platform_backend.GetCpuStats)
+    result = self._GetStatsCommon(self._platform.GetCpuStats)
     del result['ProcessCount']
 
     # We want a single time value, not the sum for all processes.
-    cpu_timestamp = self._platform_backend.GetCpuTimestamp()
+    cpu_timestamp = self._platform.GetCpuTimestamp()
     for process_type in result:
       # Skip any process_types that are empty
       if not len(result[process_type]):
         continue
       result[process_type].update(cpu_timestamp)
     return result
 
   @property
   def io_stats(self):
     """Returns a dict of IO statistics for the browser:
@@ skipping 10 matching lines @@
         'WriteTransferCount': Z
       },
       'Renderer': {
         'ReadOperationCount': W,
         'WriteOperationCount': X,
         'ReadTransferCount': Y,
         'WriteTransferCount': Z
       }
     }
     """
-    result = self._GetStatsCommon(self._platform_backend.GetIOStats)
+    result = self._GetStatsCommon(self._platform.GetIOStats)
     del result['ProcessCount']
     return result
 
   def StartProfiling(self, profiler_name, base_output_file):
     """Starts profiling using |profiler_name|. Results are saved to
     |base_output_file|.<process_name>."""
     assert not self._active_profilers, 'Already profiling. Must stop first.'
 
     profiler_class = profiler_finder.FindProfiler(profiler_name)
 
     if not profiler_class.is_supported(self._browser_backend.browser_type):
       raise Exception('The %s profiler is not '
                       'supported on this platform.' % profiler_name)
 
     if not profiler_class in self._profilers_states:
       self._profilers_states[profiler_class] = {}
 
-    self._active_profilers.append(
-        profiler_class(self._browser_backend, self._platform_backend,
-            base_output_file, self._profilers_states[profiler_class]))
+    profiler = self.platform.InstantiateProfiler(
+        profiler_class,
+        self._browser_backend,
+        base_output_file,
+        self._profilers_states[profiler_class])
+    self._active_profilers.append(profiler)
 
   def StopProfiling(self):
     """Stops all active profilers and saves their results.
 
     Returns:
       A list of filenames produced by the profiler.
     """
     output_files = []
     for profiler in self._active_profilers:
       output_files.extend(profiler.CollectProfile())
@@ skipping 21 matching lines @@
         self.platform.FlushSystemCacheForDirectory(
             self._browser_backend.browser_directory)
       else:
         self.platform.FlushEntireSystemCache()
 
     self._browser_backend.SetBrowser(self)
     self._browser_backend.Start()
 
   def Close(self):
     """Closes this browser."""
-    for profiler_class in self._profilers_states:
-      profiler_class.WillCloseBrowser(self._browser_backend,
-                                      self._platform_backend)
+    profiler_classes = list(self._profilers_states.keys())
+    self._platform.WillCloseBrowser(self._browser_backend,
+                                    profiler_classes)
 
     self.platform.SetFullPerformanceModeEnabled(False)
 
     if self._wpr_server:
       self._wpr_server.Close()
       self._wpr_server = None
 
     if self._http_server:
       self._http_server.Close()
       self._http_server = None
@@ skipping 79 matching lines @@
 
   @property
   def supports_system_info(self):
     return self._browser_backend.supports_system_info
 
   def GetSystemInfo(self):
     """Returns low-level information about the system, if available.
 
        See the documentation of the SystemInfo class for more details."""
     return self._browser_backend.GetSystemInfo()