2011-07-06  Jeff Johnston  <jjohnstn@redhat.com>

	* feature.xml: Add new plugins moved from gprov/gcov.

2010-07-26  Elliott Baron  <ebaron@fedoraproject.org>

	* feature.xml: Bump version, require CDT 7.

2010-05-28  Elliott Baron  <ebaron@fedoraproject.org>

	* feature.xml: Regenerated dependencies.

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

	* feature.properties: Fix provider name.

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-12  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Match consistent license text (bug #306627).

2009-08-11  Elliott Baron  <ebaron@redhat.com>

	* feature.xml: Remove redundant feature dependencies, set CDT version >= 6.0.0.
	Bump version to 0.3.0.

2009-05-28  Elliott Baron  <ebaron@redhat.com>

	* feature.properties: Fix featureProvider key.

2009-05-20  Elliott Baron  <ebaron@redhat.com>

	* feature.xml: Remove '.feature' from feature ID.

2009-05-19  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Change provider from Eclipse.org to Eclipse.

2009-04-23  Andrew Overholt  <overholt@redhat.com>

	* feature.xml: Remove 5.0.0.qualifier versions on CDT dependencies.

2009-04-03  Elliott Baron  <ebaron@redhat.com>

	* feature.xml: 0.2.0 version.

2009-01-14  Andrew Overholt  <overholt@redhat.com>

	* feature.xml: Re-add update site information (sorry).

2009-01-14  Elliott Baron  <ebaron@redhat.com>

	* feature.xml: Removed update site information.

2009-01-08  Elliott Baron  <ebaron@redhat.com>

	* feature.xml: Added CDT features to required features.

2009-01-06  Andrew Overholt  <overholt@redhat.com>

	* feature.xml: Add update site information.  Remove Linux requirement.

2008-12-16  Elliott Baron  <ebaron@redhat.com>

	* feature.xml: Added dependencies and Linux requirement.

2008-12-10  Andrew Overholt  <overholt@redhat.com>

	* feature.xml: Typo in feature ID.

2008-12-10  Andrew Overholt  <overholt@redhat.com>

	* build.properties: Inital checkin.
	* feature.xml: Likewise.
	* feature.properties: Likewise.
	* epl-v10.html: Likewise.
