catapult/tracing/tracing/value/value.html - platform/external/chromium-trace - Git at Google

 <!DOCTYPE html>
 <!--
 Copyright (c) 2015 The Chromium Authors. All rights reserved.
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 -->
 <link rel="import" href="/tracing/base/guid.html">
 <link rel="import" href="/tracing/base/utils.html">
 <script>
 'use strict';

 tr.exportTo('tr.v', function() {
   function Value(canonicalUrl, name, opt_options, opt_groupingKeys,
                  opt_diagnostics) {
     if (typeof(name) !== 'string')
       throw new Error('Expected value_name grouping key to be provided');

     this.groupingKeys = opt_groupingKeys || {};
     this.groupingKeys.name = name;

     this.diagnostics = opt_diagnostics || {};

     // May be undefined
     this.diagnostics.canonical_url = canonicalUrl;

     var options = opt_options || {};
     this.description = options.description;
     this.important = options.important !== undefined ?
         options.important : false;
   }

   Value.fromDict = function(d) {
     if (d.type === 'numeric')
       return NumericValue.fromDict(d);

     if (d.type === 'dict')
       return DictValue.fromDict(d);

     if (d.type == 'failure')
       return FailureValue.fromDict(d);

     if (d.type === 'skip')
       return SkipValue.fromDict(d);

     throw new Error('Not implemented');
   };

   Value.prototype = {
     get name() {
       return this.groupingKeys.name;
     },

     get canonicalUrl() {
       return this.diagnostics.canonical_url;
     },

     addGroupingKey: function(keyName, key) {
       if (this.groupingKeys.hasOwnProperty(keyName))
           throw new Error('Tried to redefine grouping key ' + keyName);
       this.groupingKeys[keyName] = key;
     },

     asDict: function() {
       return this.asJSON();
     },

     asJSON: function() {
       var d = {
         grouping_keys: this.groupingKeys,
         description: this.description,
         important: this.important,
         diagnostics: this.diagnostics
       };

       this._asDictInto(d);
       if (d.type === undefined)
         throw new Error('_asDictInto must set type field');
       return d;
     },

     _asDictInto: function(d) {
       throw new Error('Not implemented');
     }
   };

   function NumericValue(canonicalUrl, name, numeric, opt_options,
                         opt_groupingKeys, opt_diagnostics) {
     if (!(numeric instanceof tr.v.NumericBase))
       throw new Error('Expected numeric to be instance of tr.v.NumericBase');

     Value.call(this, canonicalUrl, name, opt_options, opt_groupingKeys,
                opt_diagnostics);
     this.numeric = numeric;
   }

   NumericValue.fromDict = function(d) {
     if (d.numeric === undefined)
       throw new Error('Expected numeric to be provided');
     var numeric = tr.v.NumericBase.fromDict(d.numeric);
     return new NumericValue(d.diagnostics.canonical_url, d.grouping_keys.name,
                             numeric, d, d.grouping_keys, d.diagnostics);
   };

   NumericValue.prototype = {
     __proto__: Value.prototype,

     _asDictInto: function(d) {
       d.type = 'numeric';
       d.numeric = this.numeric.asDict();
     }
   };

   function DictValue(canonicalUrl, name, value, opt_options, opt_groupingKeys,
                      opt_diagnostics) {
     Value.call(this, canonicalUrl, name, opt_options, opt_groupingKeys,
                opt_diagnostics);
     this.value = value;
   }

   DictValue.fromDict = function(d) {
     if (d.units !== undefined)
       throw new Error('Expected units to be undefined');
     if (d.value === undefined)
       throw new Error('Expected value to be provided');
     return new DictValue(d.diagnostics.canonical_url, d.grouping_keys.name,
                          d.value, d, d.groupingKeys, d.diagnostics);
   };

   DictValue.prototype = {
     __proto__: Value.prototype,

     _asDictInto: function(d) {
       d.type = 'dict';
       d.value = this.value;
     }
   };


   function FailureValue(canonicalUrl, name, opt_options, opt_groupingKeys,
                         opt_diagnostics) {
     var options = opt_options || {};

     var stack;
     if (options.stack === undefined) {
       if (options.stack_str === undefined) {
         throw new Error('Expected stack_str or stack to be provided');
       } else {
         stack = options.stack_str;
       }
     } else {
       stack = options.stack;
     }

     if (typeof stack !== 'string')
       throw new Error('stack must be provided as a string');

     if (canonicalUrl === undefined) {
       throw new Error('FailureValue must provide canonicalUrl');
     }

     Value.call(this, canonicalUrl, name, options, opt_groupingKeys,
                opt_diagnostics);
     this.stack = stack;
   }

   FailureValue.fromError = function(canonicalUrl, e) {
     var ex = tr.b.normalizeException(e);
     return new FailureValue(canonicalUrl, ex.typeName,
                             {description: ex.message,
                              stack: ex.stack});

   };

   FailureValue.fromDict = function(d) {
     if (d.units !== undefined)
       throw new Error('Expected units to be undefined');
     if (d.stack_str === undefined)
       throw new Error('Expected stack_str to be provided');
     return new FailureValue(d.diagnostics.canonical_url, d.grouping_keys.name,
                             d, d.grouping_keys, d.diagnostics);
   };

   FailureValue.prototype = {
     __proto__: Value.prototype,

     _asDictInto: function(d) {
       d.type = 'failure';
       d.stack_str = this.stack;
     }
   };


   function SkipValue(canonicalUrl, name, opt_options, opt_groupingKeys,
                      opt_diagnostics) {
     Value.call(this, canonicalUrl, name, opt_options, opt_groupingKeys,
                opt_diagnostics);
   }

   SkipValue.fromDict = function(d) {
     if (d.units !== undefined)
       throw new Error('Expected units to be undefined');
     return new SkipValue(d.diagnostics.canonical_url, d.grouping_keys.name,
                          d, d.grouping_keys, d.diagnostics);
   };

   SkipValue.prototype = {
     __proto__: Value.prototype,

     _asDictInto: function(d) {
       d.type = 'skip';
     }
   };


   return {
     Value: Value,
     NumericValue: NumericValue,
     DictValue: DictValue,
     FailureValue: FailureValue,
     SkipValue: SkipValue
   };
 });
 </script>
	<!DOCTYPE html>
	<!--
	Copyright (c) 2015 The Chromium Authors. All rights reserved.
	Use of this source code is governed by a BSD-style license that can be
	found in the LICENSE file.
	-->
	<link rel="import" href="/tracing/base/guid.html">
	<link rel="import" href="/tracing/base/utils.html">
	<script>
	'use strict';

	tr.exportTo('tr.v', function() {
	function Value(canonicalUrl, name, opt_options, opt_groupingKeys,
	opt_diagnostics) {
	if (typeof(name) !== 'string')
	throw new Error('Expected value_name grouping key to be provided');

	this.groupingKeys = opt_groupingKeys \|\| {};
	this.groupingKeys.name = name;

	this.diagnostics = opt_diagnostics \|\| {};

	// May be undefined
	this.diagnostics.canonical_url = canonicalUrl;

	var options = opt_options \|\| {};
	this.description = options.description;
	this.important = options.important !== undefined ?
	options.important : false;
	}

	Value.fromDict = function(d) {
	if (d.type === 'numeric')
	return NumericValue.fromDict(d);

	if (d.type === 'dict')
	return DictValue.fromDict(d);

	if (d.type == 'failure')
	return FailureValue.fromDict(d);

	if (d.type === 'skip')
	return SkipValue.fromDict(d);

	throw new Error('Not implemented');
	};

	Value.prototype = {
	get name() {
	return this.groupingKeys.name;
	},

	get canonicalUrl() {
	return this.diagnostics.canonical_url;
	},

	addGroupingKey: function(keyName, key) {
	if (this.groupingKeys.hasOwnProperty(keyName))
	throw new Error('Tried to redefine grouping key ' + keyName);
	this.groupingKeys[keyName] = key;
	},

	asDict: function() {
	return this.asJSON();
	},

	asJSON: function() {
	var d = {
	grouping_keys: this.groupingKeys,
	description: this.description,
	important: this.important,
	diagnostics: this.diagnostics
	};

	this._asDictInto(d);
	if (d.type === undefined)
	throw new Error('_asDictInto must set type field');
	return d;
	},

	_asDictInto: function(d) {
	throw new Error('Not implemented');
	}
	};

	function NumericValue(canonicalUrl, name, numeric, opt_options,
	opt_groupingKeys, opt_diagnostics) {
	if (!(numeric instanceof tr.v.NumericBase))
	throw new Error('Expected numeric to be instance of tr.v.NumericBase');

	Value.call(this, canonicalUrl, name, opt_options, opt_groupingKeys,
	opt_diagnostics);
	this.numeric = numeric;
	}

	NumericValue.fromDict = function(d) {
	if (d.numeric === undefined)
	throw new Error('Expected numeric to be provided');
	var numeric = tr.v.NumericBase.fromDict(d.numeric);
	return new NumericValue(d.diagnostics.canonical_url, d.grouping_keys.name,
	numeric, d, d.grouping_keys, d.diagnostics);
	};

	NumericValue.prototype = {
	__proto__: Value.prototype,

	_asDictInto: function(d) {
	d.type = 'numeric';
	d.numeric = this.numeric.asDict();
	}
	};

	function DictValue(canonicalUrl, name, value, opt_options, opt_groupingKeys,
	opt_diagnostics) {
	Value.call(this, canonicalUrl, name, opt_options, opt_groupingKeys,
	opt_diagnostics);
	this.value = value;
	}

	DictValue.fromDict = function(d) {
	if (d.units !== undefined)
	throw new Error('Expected units to be undefined');
	if (d.value === undefined)
	throw new Error('Expected value to be provided');
	return new DictValue(d.diagnostics.canonical_url, d.grouping_keys.name,
	d.value, d, d.groupingKeys, d.diagnostics);
	};

	DictValue.prototype = {
	__proto__: Value.prototype,

	_asDictInto: function(d) {
	d.type = 'dict';
	d.value = this.value;
	}
	};


	function FailureValue(canonicalUrl, name, opt_options, opt_groupingKeys,
	opt_diagnostics) {
	var options = opt_options \|\| {};

	var stack;
	if (options.stack === undefined) {
	if (options.stack_str === undefined) {
	throw new Error('Expected stack_str or stack to be provided');
	} else {
	stack = options.stack_str;
	}
	} else {
	stack = options.stack;
	}

	if (typeof stack !== 'string')
	throw new Error('stack must be provided as a string');

	if (canonicalUrl === undefined) {
	throw new Error('FailureValue must provide canonicalUrl');
	}

	Value.call(this, canonicalUrl, name, options, opt_groupingKeys,
	opt_diagnostics);
	this.stack = stack;
	}

	FailureValue.fromError = function(canonicalUrl, e) {
	var ex = tr.b.normalizeException(e);
	return new FailureValue(canonicalUrl, ex.typeName,
	{description: ex.message,
	stack: ex.stack});

	};

	FailureValue.fromDict = function(d) {
	if (d.units !== undefined)
	throw new Error('Expected units to be undefined');
	if (d.stack_str === undefined)
	throw new Error('Expected stack_str to be provided');
	return new FailureValue(d.diagnostics.canonical_url, d.grouping_keys.name,
	d, d.grouping_keys, d.diagnostics);
	};

	FailureValue.prototype = {
	__proto__: Value.prototype,

	_asDictInto: function(d) {
	d.type = 'failure';
	d.stack_str = this.stack;
	}
	};


	function SkipValue(canonicalUrl, name, opt_options, opt_groupingKeys,
	opt_diagnostics) {
	Value.call(this, canonicalUrl, name, opt_options, opt_groupingKeys,
	opt_diagnostics);
	}

	SkipValue.fromDict = function(d) {
	if (d.units !== undefined)
	throw new Error('Expected units to be undefined');
	return new SkipValue(d.diagnostics.canonical_url, d.grouping_keys.name,
	d, d.grouping_keys, d.diagnostics);
	};

	SkipValue.prototype = {
	__proto__: Value.prototype,

	_asDictInto: function(d) {
	d.type = 'skip';
	}
	};


	return {
	Value: Value,
	NumericValue: NumericValue,
	DictValue: DictValue,
	FailureValue: FailureValue,
	SkipValue: SkipValue
	};
	});
	</script>