2010-09-10  Jeff Johnston  <jjohnstn@redhat.com>

	* feature.xml: Bump up version to 0.2.

2010-05-18  Charley Wang  <chwang@redhat.com>

	* feature.xml: Add callgraph.docs plugin

2010-05-18  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Fix provider name.

2010-04-26  Andrew Overholt  <overholt@redhat.com>

	* feature.xml: Use featureURL property instead of explicit URL.

2010-04-26  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Match consistent license text (bug #306627).  Update
	copyright year.
	* license.html: New file.  HTML version of SUA (bug #306627).
	* build.properties: Include license.html.

2010-04-13  Andrew Overholt  <overholt@redhat.com>

	* feature.xml: Restrict to os=linux.

2009-11-03  Charley Wang  <chwang@redhat.com>

	* feature.properties: Change description for Callgraph feature. Add Changelog
	* feature.properties: Change featureName