readPerfLog(): Promise<any> {
   this._commandLog.push('readPerfLog');
   if (this._perfLogs.length > 0) {
     var next = this._perfLogs[0];
     this._perfLogs.shift();
     return PromiseWrapper.resolve(next);
   } else {
     return PromiseWrapper.resolve([]);
   }
 }

 beginMeasure(): Promise<any> {
   var resultPromise = PromiseWrapper.resolve(null);
   if (this._forceGc) {
     resultPromise = resultPromise.then((_) => this._driverExtension.gc());
   }
   return resultPromise.then((_) => this._beginMeasure());
 }

  /**
   * Ends measuring.
   */
  endMeasure(restart: boolean): Promise<{[key: string]: any}> {
    let completer = PromiseWrapper.completer<{[key: string]: any}>();
    let adapter = this._wdAdapter;
    let names = StringMapWrapper.keys(this._userMetrics);

    function getAndClearValues() {
      PromiseWrapper.all(names.map(name => adapter.executeScript(`return window.${name}`)))
          .then((values: any[]) => {
            if (values.every(isNumber)) {
              PromiseWrapper.all(names.map(name => adapter.executeScript(`delete window.${name}`)))
                  .then((_: any[]) => {
                    let map = StringMapWrapper.create();
                    for (let i = 0, n = names.length; i < n; i++) {
                      StringMapWrapper.set(map, names[i], values[i]);
                    }
                    completer.resolve(map);
                  }, completer.reject);
            } else {
              TimerWrapper.setTimeout(getAndClearValues, 100);
            }
          }, completer.reject);
    }
    getAndClearValues();
    return completer.promise;
  }

 inject([AsyncTestCompleter], (async) => {
   PromiseWrapper.catchError(aggregate([], {captureFrames: true}), (err): any => {
     expect(() => { throw err; })
         .toThrowError(
             'frame capture requested in benchpress, but no start event was found');
     async.done();
   });
 }));

 reportMeasureValues(measureValues: MeasureValues): Promise<any> {
   var formattedValues = this._metricNames.map(metricName => {
     var value = measureValues.values[metricName];
     return ConsoleReporter._formatNum(value);
   });
   this._printStringRow(formattedValues);
   return PromiseWrapper.resolve(null);
 }

 function createReporters(ids: any[]) {
   var r = ReflectiveInjector
               .resolveAndCreate([
                 ids.map(id => { return {provide: id, useValue: new MockReporter(id)}; }),
                 MultiReporter.createBindings(ids)
               ])
               .get(MultiReporter);
   return PromiseWrapper.resolve(r);
 }

 it('should throw if no end event', inject([AsyncTestCompleter], (async) => {
      PromiseWrapper.catchError(
          aggregate(
              [eventFactory.markStart('frameCapture', 3), eventFactory.instant('frame', 4)],
              {captureFrames: true}),
          (err): any => {
            expect(() => { throw err; }).toThrowError('missing end event for frame capture');
            async.done();
          });
    }));

 function createExtension(ids: any[], caps) {
   return PromiseWrapper.wrap(() => {
     return ReflectiveInjector
         .resolveAndCreate([
           ids.map((id) => { return {provide: id, useValue: new MockExtension(id)}; }),
           {provide: Options.CAPABILITIES, useValue: caps}, WebDriverExtension.bindTo(ids)
         ])
         .get(WebDriverExtension);
   });
 }

 logs(type) {
   this._log.push(['logs', type]);
   if (type === 'performance') {
     return PromiseWrapper.resolve(this._events.map((event) => {
       return {
         'message': Json.stringify({'message': {'method': this._messageMethod, 'params': event}})
       };
     }));
   } else {
     return null;
   }
 }