TypeScript facade.isBlank函数代码示例

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

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

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

 function createExtension(perfRecords = null, userAgent = null,
                          messageMethod = 'Tracing.dataCollected'): WebDriverExtension {
   if (isBlank(perfRecords)) {
     perfRecords = [];
   }
   if (isBlank(userAgent)) {
     userAgent = CHROME44_USER_AGENT;
   }
   log = [];
   extension =
       ReflectiveInjector.resolveAndCreate([
                           ChromeDriverExtension.BINDINGS,
                           bind(WebDriverAdapter)
                               .toValue(new MockDriverAdapter(log, perfRecords, messageMethod)),
                           bind(Options.USER_AGENT).toValue(userAgent)
                         ])
           .get(ChromeDriverExtension);
   return extension;
 }

 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 bindings = [
     Options.DEFAULT_PROVIDERS,
     PerflogMetric.BINDINGS,
     bind(Options.MICRO_METRICS).toValue(microMetrics),
     bind(PerflogMetric.SET_TIMEOUT)
         .toValue((fn, millis) => {
           commandLog.push(['setTimeout', millis]);
           fn();
         }),
     bind(WebDriverExtension)
         .toValue(new MockDriverExtension(perfLogs, commandLog, perfLogFeatures))
   ];
   if (isPresent(forceGc)) {
     bindings.push(bind(Options.FORCE_GC).toValue(forceGc));
   }
   if (isPresent(captureFrames)) {
     bindings.push(bind(Options.CAPTURE_FRAMES).toValue(captureFrames));
   }
   if (isPresent(receivedData)) {
     bindings.push(bind(Options.RECEIVED_DATA).toValue(receivedData));
   }
   if (isPresent(requestCount)) {
     bindings.push(bind(Options.REQUEST_COUNT).toValue(requestCount));
   }
   return ReflectiveInjector.resolveAndCreate(bindings).get(PerflogMetric);
 }

 function createReporter({columnWidth = null, sampleId = null, descriptions = null,
                          metrics = null}: {columnWidth?, sampleId?, descriptions?, metrics?}) {
   log = [];
   if (isBlank(descriptions)) {
     descriptions = [];
   }
   if (isBlank(sampleId)) {
     sampleId = 'null';
   }
   var bindings = [
     ConsoleReporter.BINDINGS,
     provide(SampleDescription,
             {useValue: new SampleDescription(sampleId, descriptions, metrics)}),
     bind(ConsoleReporter.PRINT).toValue((line) => log.push(line))
   ];
   if (isPresent(columnWidth)) {
     bindings.push(bind(ConsoleReporter.COLUMN_WIDTH).toValue(columnWidth));
   }
   reporter = ReflectiveInjector.resolveAndCreate(bindings).get(ConsoleReporter);
 }

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

 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
 }

 function createExtension(perfRecords = null): WebDriverExtension {
   if (isBlank(perfRecords)) {
     perfRecords = [];
   }
   log = [];
   extension = ReflectiveInjector.resolveAndCreate([
                                   IOsDriverExtension.PROVIDERS,
                                   {provide: WebDriverAdapter, useValue: new MockDriverAdapter(log, perfRecords)}
                                 ])
                   .get(IOsDriverExtension);
   return extension;
 }

 (children: WebDriverExtension[], capabilities) => {
   var delegate;
   children.forEach(extension => {
     if (extension.supports(capabilities)) {
       delegate = extension;
     }
   });
   if (isBlank(delegate)) {
     throw new BaseException('Could not find a delegate for given capabilities!');
   }
   return delegate;
 },