Dart Timeline improvements

sdk/lib/developer/timeline.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.developer;
 
+final bool _isProduct = const bool.fromEnvironment("dart.vm.product");

[rmacnak, 2016/05/10 21:20:00]

const bool _isProduct ...

[Cutch, 2016/05/10 21:30:19]

Done.

+
 typedef dynamic TimelineSyncFunction();
 typedef Future TimelineAsyncFunction();
 
 /// Add to the timeline.
 class Timeline {
   /// Start a synchronous operation labeled [name]. Optionally takes
   /// a [Map] of [arguments]. This operation must be finished before
   /// returning to the event queue.
   static void startSync(String name, {Map arguments}) {
+    if (_isProduct) {
+      return;
+    }
     if (name is! String) {
       throw new ArgumentError.value(name,
                                     'name',
                                     'Must be a String');
     }
-    var block = new _SyncBlock._(name, _getTraceClock());
+    var block = new _SyncBlock._(name, _getTraceClock(), _getThreadCpuClock());
     if (arguments is Map) {
       block._appendArguments(arguments);
     }
     _stack.add(block);
   }
 
   /// Finish the last synchronous operation that was started.
   static void finishSync() {
+    if (_isProduct) {
+      return;
+    }
     if (_stack.length == 0) {
       throw new StateError(
           'Uneven calls to startSync and finishSync');
     }
     // Pop top item off of stack.
     var block = _stack.removeLast();
     // Finish it.
     block.finish();
   }
 
   /// Emit an instant event.
   static void instantSync(String name, {Map arguments}) {
+    if (_isProduct) {
+      return;
+    }
     if (name is! String) {
       throw new ArgumentError.value(name,
                                     'name',
                                     'Must be a String');
     }
     Map instantArguments;
     if (arguments is Map) {
       instantArguments = new Map.from(arguments);
     }
     _reportInstantEvent(_getTraceClock(),
@@ skipping 42 matching lines @@
     if (taskId is! int) {
       throw new ArgumentError.value(taskId,
                                     'taskId',
                                     'Must be an int');
     }
   }
 
   /// Start a synchronous operation within this task named [name].
   /// Optionally takes a [Map] of [arguments].
   void start(String name, {Map arguments}) {
+    if (_isProduct) {
+      return;
+    }
     if (name is! String) {
       throw new ArgumentError.value(name,
                                     'name',
                                     'Must be a String');
     }
     var block = new _AsyncBlock._(name, _taskId);
     if (arguments is Map) {
       block._appendArguments(arguments);
     }
     _stack.add(block);
     block._start();
   }
 
   /// Emit an instant event for this task.
   void instant(String name, {Map arguments}) {
+    if (_isProduct) {
+      return;
+    }
     if (name is! String) {
       throw new ArgumentError.value(name,
                                     'name',
                                     'Must be a String');
     }
     Map instantArguments;
     if (arguments is Map) {
       instantArguments = new Map.from(arguments);
     }
     _reportTaskEvent(_getTraceClock(),
                      _taskId,
                      'n',
                      'Dart',
                      name,
                      _argumentsAsJson(instantArguments));
   }
 
   /// Finish the last synchronous operation that was started.
   void finish() {
+    if (_isProduct) {
+      return;
+    }
     if (_stack.length == 0) {
       throw new StateError(
           'Uneven calls to start and finish');
     }
     // Pop top item off of stack.
     var block = _stack.removeLast();
     block._finish();
   }
 
   /// Retrieve the [TimelineTask]'s task id. Will throw an exception if the
@@ skipping 60 matching lines @@
 class _SyncBlock {
   /// The category this block belongs to.
   final String category = 'Dart';
   /// The name of this block.
   final String name;
   /// An (optional) set of arguments which will be serialized to JSON and
   /// associated with this block.
   Map _arguments;
   // The start time stamp.
   final int _start;
+  // The start time stamp of the thread cpu clock.
+  final int _startCpu;
 
   _SyncBlock._(this.name,
-               this._start);
+               this._start,
+               this._startCpu);
 
   /// Finish this block of time. At this point, this block can no longer be
   /// used.
   void finish() {
     // Report event to runtime.
     _reportCompleteEvent(_start,
-                         _getTraceClock(),
+                         _startCpu,
                          category,
                          name,
                          _argumentsAsJson(_arguments));
   }
 
   void _appendArguments(Map arguments) {
     if (arguments == null) {
       return;
     }
     if (_arguments == null) {
@@ skipping 16 matching lines @@
   arguments['isolateNumber'] = Timeline._isolateIdString;
   return JSON.encode(arguments);
 }
 
 /// Returns the next async task id.
 external int _getNextAsyncId();
 
 /// Returns the current value from the trace clock.
 external int _getTraceClock();
 
+/// Returns the current value from the thread CPU usage clock.
+external int _getThreadCpuClock();
+
 /// Returns the isolate's main port number.
 external int _getIsolateNum();
 
 /// Reports an event for a task.
 external void _reportTaskEvent(int start,
                                int taskId,
                                String phase,
                                String category,
                                String name,
                                String argumentsAsJson);
 
 /// Reports a complete synchronous event.
 external void _reportCompleteEvent(int start,
-                                   int end,
+                                   int startCpu,
                                    String category,
                                    String name,
                                    String argumentsAsJson);
 
 /// Reports an instant event.
 external void _reportInstantEvent(int start,
                                   String category,
                                   String name,
                                   String argumentsAsJson);