TypeScript collection.StringMapWrapper类代码示例

 .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);

  /**
   * 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;
  }

 function createMetric(
     perfLogs, perfLogFeatures,
     {microMetrics, forceGc, captureFrames, receivedData, requestCount}: {
       microMetrics?: {[key: string]: string},
       forceGc?: boolean,
       captureFrames?: boolean,
       receivedData?: boolean,
       requestCount?: boolean
     } = {}): Metric {
   commandLog = [];
   if (isBlank(perfLogFeatures)) {
     perfLogFeatures =
         new PerfLogFeatures({render: true, gc: true, frameCapture: true, userTiming: true});
   }
   if (isBlank(microMetrics)) {
     microMetrics = StringMapWrapper.create();
   }
   var providers: Provider[] = [
     Options.DEFAULT_PROVIDERS, PerflogMetric.PROVIDERS,
     {provide: Options.MICRO_METRICS, useValue: microMetrics}, {
       provide: PerflogMetric.SET_TIMEOUT,
       useValue: (fn, millis) => {
         commandLog.push(['setTimeout', millis]);
         fn();
       },
     },
     {
       provide: WebDriverExtension,
       useValue: new MockDriverExtension(perfLogs, commandLog, perfLogFeatures)
     }
   ];
   if (isPresent(forceGc)) {
     providers.push({provide: Options.FORCE_GC, useValue: forceGc});
   }
   if (isPresent(captureFrames)) {
     providers.push({provide: Options.CAPTURE_FRAMES, useValue: captureFrames});
   }
   if (isPresent(receivedData)) {
     providers.push({provide: Options.RECEIVED_DATA, useValue: receivedData});
   }
   if (isPresent(requestCount)) {
     providers.push({provide: Options.REQUEST_COUNT, useValue: requestCount});
   }
   return ReflectiveInjector.resolveAndCreate(providers).get(PerflogMetric);
 }

 events.forEach(event => {
   if (StringWrapper.equals(event['ph'], 'X')) {
     needSort = true;
     var startEvent = {};
     var endEvent = {};
     StringMapWrapper.forEach(event, (value, prop) => {
       startEvent[prop] = value;
       endEvent[prop] = value;
     });
     startEvent['ph'] = 'B';
     endEvent['ph'] = 'E';
     endEvent['ts'] = startEvent['ts'] + startEvent['dur'];
     this._remainingEvents.push(startEvent);
     this._remainingEvents.push(endEvent);
   } else {
     this._remainingEvents.push(event);
   }
 });

 describe(): {[key: string]: any} {
   var res = {
     'scriptTime': 'script execution time in ms, including gc and render',
     'pureScriptTime': 'script execution time in ms, without gc nor render'
   };
   if (this._perfLogFeatures.render) {
     res['renderTime'] = 'render time in ms';
   }
   if (this._perfLogFeatures.gc) {
     res['gcTime'] = 'gc time in ms';
     res['gcAmount'] = 'gc amount in kbytes';
     res['majorGcTime'] = 'time of major gcs in ms';
     if (this._forceGc) {
       res['forcedGcTime'] = 'forced gc time in ms';
       res['forcedGcAmount'] = 'forced gc amount in kbytes';
     }
   }
   if (this._receivedData) {
     res['receivedData'] = 'encoded bytes received since navigationStart';
   }
   if (this._requestCount) {
     res['requestCount'] = 'count of requests sent since navigationStart';
   }
   if (this._captureFrames) {
     if (!this._perfLogFeatures.frameCapture) {
       var warningMsg = 'WARNING: Metric requested, but not supported by driver';
       // using dot syntax for metric name to keep them grouped together in console reporter
       res['frameTime.mean'] = warningMsg;
       res['frameTime.worst'] = warningMsg;
       res['frameTime.best'] = warningMsg;
       res['frameTime.smooth'] = warningMsg;
     } else {
       res['frameTime.mean'] = 'mean frame time in ms (target: 16.6ms for 60fps)';
       res['frameTime.worst'] = 'worst frame time in ms';
       res['frameTime.best'] = 'best frame time in ms';
       res['frameTime.smooth'] = 'percentage of frames that hit 60fps';
     }
   }
   StringMapWrapper.forEach(
       this._microMetrics, (desc, name) => { StringMapWrapper.set(res, name, desc); });
   return res;
 }

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;
}

 /** @internal */
 private static _sortedProps(obj) {
   var props = [];
   StringMapWrapper.forEach(obj, (value, prop) => props.push(prop));
   props.sort();
   return props;
 }

  /** @internal */
  private _aggregateEvents(events: Array<{[key: string]: any}>, markName): {[key: string]: any} {
    var result = {'scriptTime': 0, 'pureScriptTime': 0};
    if (this._perfLogFeatures.gc) {
      result['gcTime'] = 0;
      result['majorGcTime'] = 0;
      result['gcAmount'] = 0;
    }
    if (this._perfLogFeatures.render) {
      result['renderTime'] = 0;
    }
    if (this._captureFrames) {
      result['frameTime.mean'] = 0;
      result['frameTime.best'] = 0;
      result['frameTime.worst'] = 0;
      result['frameTime.smooth'] = 0;
    }
    StringMapWrapper.forEach(this._microMetrics, (desc, name) => { result[name] = 0; });
    if (this._receivedData) {
      result['receivedData'] = 0;
    }
    if (this._requestCount) {
      result['requestCount'] = 0;
    }

    var markStartEvent = null;
    var markEndEvent = null;
    var gcTimeInScript = 0;
    var renderTimeInScript = 0;

    var frameTimestamps = [];
    var frameTimes = [];
    var frameCaptureStartEvent = null;
    var frameCaptureEndEvent = null;

    var intervalStarts: {[key: string]: any} = {};
    var intervalStartCount: {[key: string]: number} = {};
    events.forEach((event) => {
      var ph = event['ph'];
      var name = event['name'];
      var microIterations = 1;
      var microIterationsMatch = RegExpWrapper.firstMatch(_MICRO_ITERATIONS_REGEX, name);
      if (isPresent(microIterationsMatch)) {
        name = microIterationsMatch[1];
        microIterations = NumberWrapper.parseInt(microIterationsMatch[2], 10);
      }

      if (StringWrapper.equals(ph, 'b') && StringWrapper.equals(name, markName)) {
        markStartEvent = event;
      } else if (StringWrapper.equals(ph, 'e') && StringWrapper.equals(name, markName)) {
        markEndEvent = event;
      }

      let isInstant = StringWrapper.equals(ph, 'I') || StringWrapper.equals(ph, 'i');
      if (this._requestCount && StringWrapper.equals(name, 'sendRequest')) {
        result['requestCount'] += 1;
      } else if (this._receivedData && StringWrapper.equals(name, 'receivedData') && isInstant) {
        result['receivedData'] += event['args']['encodedDataLength'];
      } else if (StringWrapper.equals(name, 'navigationStart')) {
        // We count data + requests since the last navigationStart
        // (there might be chrome extensions loaded by selenium before our page, so there
        // will likely be more than one navigationStart).
        if (this._receivedData) {
          result['receivedData'] = 0;
        }
        if (this._requestCount) {
          result['requestCount'] = 0;
        }
      }
      if (isPresent(markStartEvent) && isBlank(markEndEvent) &&
          event['pid'] === markStartEvent['pid']) {
        if (StringWrapper.equals(ph, 'b') && StringWrapper.equals(name, _MARK_NAME_FRAME_CAPUTRE)) {
          if (isPresent(frameCaptureStartEvent)) {
            throw new BaseException('can capture frames only once per benchmark run');
          }
          if (!this._captureFrames) {
            throw new BaseException(
                'found start event for frame capture, but frame capture was not requested in benchpress');
          }
          frameCaptureStartEvent = event;
        } else if (
            StringWrapper.equals(ph, 'e') && StringWrapper.equals(name, _MARK_NAME_FRAME_CAPUTRE)) {
          if (isBlank(frameCaptureStartEvent)) {
            throw new BaseException('missing start event for frame capture');
          }
          frameCaptureEndEvent = event;
        }

        if (isInstant) {
          if (isPresent(frameCaptureStartEvent) && isBlank(frameCaptureEndEvent) &&
              StringWrapper.equals(name, 'frame')) {
            frameTimestamps.push(event['ts']);
            if (frameTimestamps.length >= 2) {
              frameTimes.push(
                  frameTimestamps[frameTimestamps.length - 1] -
                  frameTimestamps[frameTimestamps.length - 2]);
            }
          }
        }

//.........这里部分代码省略.........