chore: move benchpress to @angular/benchpress

modules/@angular/benchpress/src/webdriver/async_webdriver_adapter.dart

@@ -0,0 +1,35 @@
+library benchpress.src.webdriver.async_webdriver_adapter_dart;
+
+import 'dart:async';
+import 'package:webdriver/webdriver.dart' show WebDriver, LogEntry;
+import '../web_driver_adapter.dart' show WebDriverAdapter;
+
+class AsyncWebDriverAdapter extends WebDriverAdapter {
+  WebDriver _driver;
+  AsyncWebDriverAdapter(this._driver);
+
+  Future waitFor(Function callback) {
+    return callback();
+  }
+
+  Future executeScript(String script) {
+    return _driver.execute(script, const []);
+  }
+
+  Future executeAsyncScript(String script) {
+    return _driver.executeAsync(script, const []);
+  }
+
+  Future<Map> capabilities() {
+    return new Future.value(_driver.capabilities);
+  }
+
+  Future<List<Map>> logs(String type) {
+    return _driver.logs
+        .get(type)
+        .map((LogEntry entry) => {'message': entry.message})
+        .fold(<Map>[], (log, Map entry) {
+      return log..add(entry);
+    });
+  }
+}

modules/@angular/benchpress/src/webdriver/chrome_driver_extension.ts

@@ -0,0 +1,257 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {ListWrapper, StringMapWrapper} from '@angular/facade/src/collection';
+import {Json, NumberWrapper, StringWrapper, isBlank, isPresent} from '@angular/facade/src/lang';
+
+import {Options} from '../common_options';
+import {WebDriverAdapter} from '../web_driver_adapter';
+import {PerfLogFeatures, WebDriverExtension} from '../web_driver_extension';
+
+
+/**
+ * Set the following 'traceCategories' to collect metrics in Chrome:
+ * 'v8,blink.console,disabled-by-default-devtools.timeline,devtools.timeline'
+ *
+ * In order to collect the frame rate related metrics, add 'benchmark'
+ * to the list above.
+ */
+export class ChromeDriverExtension extends WebDriverExtension {
+  // TODO(tbosch): use static values when our transpiler supports them
+  static get PROVIDERS(): any[] { return _PROVIDERS; }
+
+  private _majorChromeVersion: number;
+
+  constructor(private _driver: WebDriverAdapter, userAgent: string) {
+    super();
+    this._majorChromeVersion = this._parseChromeVersion(userAgent);
+  }
+
+  private _parseChromeVersion(userAgent: string): number {
+    if (isBlank(userAgent)) {
+      return -1;
+    }
+    var v = StringWrapper.split(userAgent, /Chrom(e|ium)\//g)[2];
+    if (isBlank(v)) {
+      return -1;
+    }
+    v = v.split('.')[0];
+    if (isBlank(v)) {
+      return -1;
+    }
+    return NumberWrapper.parseInt(v, 10);
+  }
+
+  gc() { return this._driver.executeScript('window.gc()'); }
+
+  timeBegin(name: string): Promise<any> {
+    return this._driver.executeScript(`console.time('${name}');`);
+  }
+
+  timeEnd(name: string, restartName: string = null): Promise<any> {
+    var script = `console.timeEnd('${name}');`;
+    if (isPresent(restartName)) {
+      script += `console.time('${restartName}');`;
+    }
+    return this._driver.executeScript(script);
+  }
+
+  // See [Chrome Trace Event
+  // Format](https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/edit)
+  readPerfLog(): Promise<any> {
+    // TODO(tbosch): Chromedriver bug https://code.google.com/p/chromedriver/issues/detail?id=1098
+    // Need to execute at least one command so that the browser logs can be read out!
+    return this._driver.executeScript('1+1')
+        .then((_) => this._driver.logs('performance'))
+        .then((entries) => {
+          var events = [];
+          entries.forEach(entry => {
+            var message = Json.parse(entry['message'])['message'];
+            if (StringWrapper.equals(message['method'], 'Tracing.dataCollected')) {
+              events.push(message['params']);
+            }
+            if (StringWrapper.equals(message['method'], 'Tracing.bufferUsage')) {
+              throw new Error('The DevTools trace buffer filled during the test!');
+            }
+          });
+          return this._convertPerfRecordsToEvents(events);
+        });
+  }
+
+  private _convertPerfRecordsToEvents(
+      chromeEvents: Array<{[key: string]: any}>,
+      normalizedEvents: Array<{[key: string]: any}> = null) {
+    if (isBlank(normalizedEvents)) {
+      normalizedEvents = [];
+    }
+    var majorGCPids = {};
+    chromeEvents.forEach((event) => {
+      var categories = this._parseCategories(event['cat']);
+      var name = event['name'];
+      if (this._isEvent(categories, name, ['blink.console'])) {
+        normalizedEvents.push(normalizeEvent(event, {'name': name}));
+      } else if (this._isEvent(
+                     categories, name, ['benchmark'],
+                     'BenchmarkInstrumentation::ImplThreadRenderingStats')) {
+        // TODO(goderbauer): Instead of BenchmarkInstrumentation::ImplThreadRenderingStats the
+        // following events should be used (if available) for more accurate measurments:
+        //   1st choice: vsync_before - ground truth on Android
+        //   2nd choice: BenchmarkInstrumentation::DisplayRenderingStats - available on systems with
+        //               new surfaces framework (not broadly enabled yet)
+        //   3rd choice: BenchmarkInstrumentation::ImplThreadRenderingStats - fallback event that is
+        //               always available if something is rendered
+        var frameCount = event['args']['data']['frame_count'];
+        if (frameCount > 1) {
+          throw new Error('multi-frame render stats not supported');
+        }
+        if (frameCount == 1) {
+          normalizedEvents.push(normalizeEvent(event, {'name': 'frame'}));
+        }
+      } else if (
+          this._isEvent(categories, name, ['disabled-by-default-devtools.timeline'], 'Rasterize') ||
+          this._isEvent(
+              categories, name, ['disabled-by-default-devtools.timeline'], 'CompositeLayers')) {
+        normalizedEvents.push(normalizeEvent(event, {'name': 'render'}));
+      } else if (this._majorChromeVersion < 45) {
+        var normalizedEvent = this._processAsPreChrome45Event(event, categories, majorGCPids);
+        if (normalizedEvent != null) normalizedEvents.push(normalizedEvent);
+      } else {
+        var normalizedEvent = this._processAsPostChrome44Event(event, categories);
+        if (normalizedEvent != null) normalizedEvents.push(normalizedEvent);
+      }
+    });
+    return normalizedEvents;
+  }
+
+  private _processAsPreChrome45Event(event, categories, majorGCPids) {
+    var name = event['name'];
+    var args = event['args'];
+    var pid = event['pid'];
+    var ph = event['ph'];
+    if (this._isEvent(
+            categories, name, ['disabled-by-default-devtools.timeline'], 'FunctionCall') &&
+        (isBlank(args) || isBlank(args['data']) ||
+         !StringWrapper.equals(args['data']['scriptName'], 'InjectedScript'))) {
+      return normalizeEvent(event, {'name': 'script'});
+    } else if (
+        this._isEvent(
+            categories, name, ['disabled-by-default-devtools.timeline'], 'RecalculateStyles') ||
+        this._isEvent(categories, name, ['disabled-by-default-devtools.timeline'], 'Layout') ||
+        this._isEvent(
+            categories, name, ['disabled-by-default-devtools.timeline'], 'UpdateLayerTree') ||
+        this._isEvent(categories, name, ['disabled-by-default-devtools.timeline'], 'Paint')) {
+      return normalizeEvent(event, {'name': 'render'});
+    } else if (this._isEvent(
+                   categories, name, ['disabled-by-default-devtools.timeline'], 'GCEvent')) {
+      var normArgs = {
+        'usedHeapSize': isPresent(args['usedHeapSizeAfter']) ? args['usedHeapSizeAfter'] :
+                                                               args['usedHeapSizeBefore']
+      };
+      if (StringWrapper.equals(ph, 'E')) {
+        normArgs['majorGc'] = isPresent(majorGCPids[pid]) && majorGCPids[pid];
+      }
+      majorGCPids[pid] = false;
+      return normalizeEvent(event, {'name': 'gc', 'args': normArgs});
+    } else if (
+        this._isEvent(categories, name, ['v8'], 'majorGC') && StringWrapper.equals(ph, 'B')) {
+      majorGCPids[pid] = true;
+    }
+    return null;  // nothing useful in this event
+  }
+
+  private _processAsPostChrome44Event(event, categories) {
+    var name = event['name'];
+    var args = event['args'];
+    if (this._isEvent(categories, name, ['devtools.timeline', 'v8'], 'MajorGC')) {
+      var normArgs = {
+        'majorGc': true,
+        'usedHeapSize': isPresent(args['usedHeapSizeAfter']) ? args['usedHeapSizeAfter'] :
+                                                               args['usedHeapSizeBefore']
+      };
+      return normalizeEvent(event, {'name': 'gc', 'args': normArgs});
+    } else if (this._isEvent(categories, name, ['devtools.timeline', 'v8'], 'MinorGC')) {
+      var normArgs = {
+        'majorGc': false,
+        'usedHeapSize': isPresent(args['usedHeapSizeAfter']) ? args['usedHeapSizeAfter'] :
+                                                               args['usedHeapSizeBefore']
+      };
+      return normalizeEvent(event, {'name': 'gc', 'args': normArgs});
+    } else if (
+        this._isEvent(categories, name, ['devtools.timeline', 'v8'], 'FunctionCall') &&
+        (isBlank(args) || isBlank(args['data']) ||
+         (!StringWrapper.equals(args['data']['scriptName'], 'InjectedScript') &&
+          !StringWrapper.equals(args['data']['scriptName'], '')))) {
+      return normalizeEvent(event, {'name': 'script'});
+    } else if (this._isEvent(
+                   categories, name, ['devtools.timeline', 'blink'], 'UpdateLayoutTree')) {
+      return normalizeEvent(event, {'name': 'render'});
+    } else if (
+        this._isEvent(categories, name, ['devtools.timeline'], 'UpdateLayerTree') ||
+        this._isEvent(categories, name, ['devtools.timeline'], 'Layout') ||
+        this._isEvent(categories, name, ['devtools.timeline'], 'Paint')) {
+      return normalizeEvent(event, {'name': 'render'});
+    } else if (this._isEvent(categories, name, ['devtools.timeline'], 'ResourceReceivedData')) {
+      let normArgs = {'encodedDataLength': args['data']['encodedDataLength']};
+      return normalizeEvent(event, {'name': 'receivedData', 'args': normArgs});
+    } else if (this._isEvent(categories, name, ['devtools.timeline'], 'ResourceSendRequest')) {
+      let data = args['data'];
+      let normArgs = {'url': data['url'], 'method': data['requestMethod']};
+      return normalizeEvent(event, {'name': 'sendRequest', 'args': normArgs});
+    } else if (this._isEvent(categories, name, ['blink.user_timing'], 'navigationStart')) {
+      return normalizeEvent(event, {'name': name});
+    }
+    return null;  // nothing useful in this event
+  }
+
+  private _parseCategories(categories: string): string[] { return categories.split(','); }
+
+  private _isEvent(
+      eventCategories: string[], eventName: string, expectedCategories: string[],
+      expectedName: string = null): boolean {
+    var hasCategories = expectedCategories.reduce(
+        (value, cat) => { return value && ListWrapper.contains(eventCategories, cat); }, true);
+    return isBlank(expectedName) ? hasCategories :
+                                   hasCategories && StringWrapper.equals(eventName, expectedName);
+  }
+
+  perfLogFeatures(): PerfLogFeatures {
+    return new PerfLogFeatures({render: true, gc: true, frameCapture: true, userTiming: true});
+  }
+
+  supports(capabilities: {[key: string]: any}): boolean {
+    return this._majorChromeVersion != -1 &&
+        StringWrapper.equals(capabilities['browserName'].toLowerCase(), 'chrome');
+  }
+}
+
+function normalizeEvent(
+    chromeEvent: {[key: string]: any}, data: {[key: string]: any}): {[key: string]: any} {
+  var ph = chromeEvent['ph'];
+  if (StringWrapper.equals(ph, 'S')) {
+    ph = 'b';
+  } else if (StringWrapper.equals(ph, 'F')) {
+    ph = 'e';
+  }
+  var result =
+      {'pid': chromeEvent['pid'], 'ph': ph, 'cat': 'timeline', 'ts': chromeEvent['ts'] / 1000};
+  if (chromeEvent['ph'] === 'X') {
+    var dur = chromeEvent['dur'];
+    if (isBlank(dur)) {
+      dur = chromeEvent['tdur'];
+    }
+    result['dur'] = isBlank(dur) ? 0.0 : dur / 1000;
+  }
+  StringMapWrapper.forEach(data, (value, prop) => { result[prop] = value; });
+  return result;
+}
+
+var _PROVIDERS = [{
+  provide: ChromeDriverExtension,
+  useFactory: (driver, userAgent) => new ChromeDriverExtension(driver, userAgent),
+  deps: [WebDriverAdapter, Options.USER_AGENT]
+}];

modules/@angular/benchpress/src/webdriver/firefox_driver_extension.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {StringWrapper, isPresent} from '@angular/facade/src/lang';
+
+import {WebDriverAdapter} from '../web_driver_adapter';
+import {PerfLogFeatures, WebDriverExtension} from '../web_driver_extension';
+
+export class FirefoxDriverExtension extends WebDriverExtension {
+  static get PROVIDERS(): any[] { return _PROVIDERS; }
+
+  private _profilerStarted: boolean;
+
+  constructor(private _driver: WebDriverAdapter) {
+    super();
+    this._profilerStarted = false;
+  }
+
+  gc() { return this._driver.executeScript('window.forceGC()'); }
+
+  timeBegin(name: string): Promise<any> {
+    if (!this._profilerStarted) {
+      this._profilerStarted = true;
+      this._driver.executeScript('window.startProfiler();');
+    }
+    return this._driver.executeScript('window.markStart("' + name + '");');
+  }
+
+  timeEnd(name: string, restartName: string = null): Promise<any> {
+    var script = 'window.markEnd("' + name + '");';
+    if (isPresent(restartName)) {
+      script += 'window.markStart("' + restartName + '");';
+    }
+    return this._driver.executeScript(script);
+  }
+
+  readPerfLog(): Promise<any> {
+    return this._driver.executeAsyncScript('var cb = arguments[0]; window.getProfile(cb);');
+  }
+
+  perfLogFeatures(): PerfLogFeatures { return new PerfLogFeatures({render: true, gc: true}); }
+
+  supports(capabilities: {[key: string]: any}): boolean {
+    return StringWrapper.equals(capabilities['browserName'].toLowerCase(), 'firefox');
+  }
+}
+
+var _PROVIDERS = [{
+  provide: FirefoxDriverExtension,
+  useFactory: (driver) => new FirefoxDriverExtension(driver),
+  deps: [WebDriverAdapter]
+}];

modules/@angular/benchpress/src/webdriver/ios_driver_extension.ts

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Json, StringWrapper, isBlank, isPresent} from '@angular/facade/src/lang';
+
+import {WebDriverAdapter} from '../web_driver_adapter';
+import {PerfLogFeatures, WebDriverExtension} from '../web_driver_extension';
+
+export class IOsDriverExtension extends WebDriverExtension {
+  // TODO(tbosch): use static values when our transpiler supports them
+  static get PROVIDERS(): any[] { return _PROVIDERS; }
+
+  constructor(private _driver: WebDriverAdapter) { super(); }
+
+  gc(): Promise<any> { throw new Error('Force GC is not supported on iOS'); }
+
+  timeBegin(name: string): Promise<any> {
+    return this._driver.executeScript(`console.time('${name}');`);
+  }
+
+  timeEnd(name: string, restartName: string = null): Promise<any> {
+    var script = `console.timeEnd('${name}');`;
+    if (isPresent(restartName)) {
+      script += `console.time('${restartName}');`;
+    }
+    return this._driver.executeScript(script);
+  }
+
+  // See https://github.com/WebKit/webkit/tree/master/Source/WebInspectorUI/Versions
+  readPerfLog() {
+    // TODO(tbosch): Bug in IOsDriver: Need to execute at least one command
+    // so that the browser logs can be read out!
+    return this._driver.executeScript('1+1')
+        .then((_) => this._driver.logs('performance'))
+        .then((entries) => {
+          var records = [];
+          entries.forEach(entry => {
+            var message = Json.parse(entry['message'])['message'];
+            if (StringWrapper.equals(message['method'], 'Timeline.eventRecorded')) {
+              records.push(message['params']['record']);
+            }
+          });
+          return this._convertPerfRecordsToEvents(records);
+        });
+  }
+
+  /** @internal */
+  private _convertPerfRecordsToEvents(records: any[], events: any[] = null) {
+    if (isBlank(events)) {
+      events = [];
+    }
+    records.forEach((record) => {
+      var endEvent = null;
+      var type = record['type'];
+      var data = record['data'];
+      var startTime = record['startTime'];
+      var endTime = record['endTime'];
+
+      if (StringWrapper.equals(type, 'FunctionCall') &&
+          (isBlank(data) || !StringWrapper.equals(data['scriptName'], 'InjectedScript'))) {
+        events.push(createStartEvent('script', startTime));
+        endEvent = createEndEvent('script', endTime);
+      } else if (StringWrapper.equals(type, 'Time')) {
+        events.push(createMarkStartEvent(data['message'], startTime));
+      } else if (StringWrapper.equals(type, 'TimeEnd')) {
+        events.push(createMarkEndEvent(data['message'], startTime));
+      } else if (
+          StringWrapper.equals(type, 'RecalculateStyles') || StringWrapper.equals(type, 'Layout') ||
+          StringWrapper.equals(type, 'UpdateLayerTree') || StringWrapper.equals(type, 'Paint') ||
+          StringWrapper.equals(type, 'Rasterize') ||
+          StringWrapper.equals(type, 'CompositeLayers')) {
+        events.push(createStartEvent('render', startTime));
+        endEvent = createEndEvent('render', endTime);
+      }
+      // Note: ios used to support GCEvent up until iOS 6 :-(
+      if (isPresent(record['children'])) {
+        this._convertPerfRecordsToEvents(record['children'], events);
+      }
+      if (isPresent(endEvent)) {
+        events.push(endEvent);
+      }
+    });
+    return events;
+  }
+
+  perfLogFeatures(): PerfLogFeatures { return new PerfLogFeatures({render: true}); }
+
+  supports(capabilities: {[key: string]: any}): boolean {
+    return StringWrapper.equals(capabilities['browserName'].toLowerCase(), 'safari');
+  }
+}
+
+function createEvent(ph, name, time, args = null) {
+  var result = {
+    'cat': 'timeline',
+    'name': name,
+    'ts': time,
+    'ph': ph,
+    // The ios protocol does not support the notions of multiple processes in
+    // the perflog...
+    'pid': 'pid0'
+  };
+  if (isPresent(args)) {
+    result['args'] = args;
+  }
+  return result;
+}
+
+function createStartEvent(name, time, args = null) {
+  return createEvent('B', name, time, args);
+}
+
+function createEndEvent(name, time, args = null) {
+  return createEvent('E', name, time, args);
+}
+
+function createMarkStartEvent(name, time) {
+  return createEvent('b', name, time);
+}
+
+function createMarkEndEvent(name, time) {
+  return createEvent('e', name, time);
+}
+
+var _PROVIDERS = [{
+  provide: IOsDriverExtension,
+  useFactory: (driver) => new IOsDriverExtension(driver),
+  deps: [WebDriverAdapter]
+}];

modules/@angular/benchpress/src/webdriver/selenium_webdriver_adapter.dart

@@ -0,0 +1,3 @@
+library benchpress.src.webdriver.selenium_webdriver_adapter;
+
+//no dart implementation

modules/@angular/benchpress/src/webdriver/selenium_webdriver_adapter.ts

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as webdriver from 'selenium-webdriver';
+
+import {WebDriverAdapter} from '../web_driver_adapter';
+
+
+
+/**
+ * Adapter for the selenium-webdriver.
+ */
+export class SeleniumWebDriverAdapter extends WebDriverAdapter {
+  static get PROTRACTOR_BINDINGS(): any[] { return _PROTRACTOR_BINDINGS; }
+
+  constructor(private _driver: any) { super(); }
+
+  /** @internal */
+  private _convertPromise(thenable) {
+    var resolve: (result: any) => void;
+    var reject: (error: any) => void;
+    var promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    thenable.then(
+        // selenium-webdriver uses an own Node.js context,
+        // so we need to convert data into objects of this context.
+        // Previously needed for rtts_asserts.
+        (data) => resolve(convertToLocalProcess(data)), reject);
+    return promise;
+  }
+
+  waitFor(callback): Promise<any> {
+    return this._convertPromise(this._driver.controlFlow().execute(callback));
+  }
+
+  executeScript(script: string): Promise<any> {
+    return this._convertPromise(this._driver.executeScript(script));
+  }
+
+  executeAsyncScript(script: string): Promise<any> {
+    return this._convertPromise(this._driver.executeAsyncScript(script));
+  }
+
+  capabilities(): Promise<any> {
+    return this._convertPromise(
+        this._driver.getCapabilities().then((capsObject) => capsObject.serialize()));
+  }
+
+  logs(type: string): Promise<any> {
+    // Needed as selenium-webdriver does not forward
+    // performance logs in the correct way via manage().logs
+    return this._convertPromise(this._driver.schedule(
+        new webdriver.Command(webdriver.CommandName.GET_LOG).setParameter('type', type),
+        'WebDriver.manage().logs().get(' + type + ')'));
+  }
+}
+
+function convertToLocalProcess(data): Object {
+  var serialized = JSON.stringify(data);
+  if ('' + serialized === 'undefined') {
+    return undefined;
+  }
+  return JSON.parse(serialized);
+}
+
+var _PROTRACTOR_BINDINGS = [{
+  provide: WebDriverAdapter,
+  useFactory: () => new SeleniumWebDriverAdapter((<any>global).browser),
+  deps: []
+}];