Version 20 (modified by Ademar Reis, 13 years ago) (diff)


Procedures and policies for releases of QtWebKit

Releases of QtWebKit are cut from WebKit's trunk. Some time before the release a new branch is created and hosted in a Git repository. After the release it becomes a maintenance branch.

Release branches and their status

QtWebKit 2.0

Status: released, maintainance

QtWebKit 2.1

Status: open, frozen (critical fixes only)

QtWebKit 2.1.x

Status: open (next update on top of 2.1, will include html5 media)

QtWebKit 2.2

Status: not branched yet (work is happening on trunk)

Release branch creation

Getting changes into a release branch

If you'd like to include a patch in the release branch, please consider only fixes that:

  • Fix data corruption
  • Fix crashes
  • Fix a previously broken build
  • Regression from the last minor release
  • Documentation changes
  • Crucial usability issue (after discussion in the mailing list)

There are two ways to integrate changes into a release branch:

  • The commit is landed in the trunk and then it is cherry-picked into the release branch.
  • Time constraints prevent us from landing the patch and we have to include a change before landing it (exceptional patch, see below).

Exceptional patches must satisfy the following criteria before they are included in the release:

  • An entry with the attached patch is filed in (using;
  • The patch has a ChangeLog entry;
  • The changes are public and live on a gitorious branch, rebased with the targeted release;
  • Patches that affect WebCore should have a layout test included, although this is not mandatory;
  • At least one WebKit reviewer signs off on the patch and no other reviewer objects;
  • The bug is marked to block the tracker bug for patches pending trunk inclusion:;
  • Any exception has to be first discussed in the public mailing list;

After the release we have to make a concentrated effort in reducing the number of exceptional patches, by reviewing the changes in the bugs that the tracker bug (32653) depends on.

Procedures for cherry-picking and weekly releasing

The process for cherry-picking changes from trunk to a stable branch is semi-automated. To keep things working as expected, some care must be taken when commiting changes there. Below are the basic steps and the commands involved:

  • Clone the qtwebkit git/svn mirror and keep it up to date;
  • Downloand and setup qtwebkit/tools (change PATH and PYTHONPATH as necessary);
  • Check UsingGitWithWebKit for valuable tips and tricks;
  • Set your username and password in git-config (see instructions in the link above);
  • From the branch where you want to cherry-pick a change (git new-workdir is your friend), run (see --help). This script will parse bugzilla, ask for cherry-picks, add comments and remove bugs from their trackers;
  • If there's a conflict, the script will abort. In that case:
    • Solve the conflict (git status, git rm, git add, patch the files manually, etc -- your choice);
    • Commit the changes, keeping the original changelog from the original git commit;
    • Run the script again, it'll detect the new commit and continue as expected.
  • Before letting the script add a comment to bugzilla, make sure the build is not broken and run some basic tests (run QtTestBrowser, the API tests -- your choice), so that if there's something broken, you can fix it and git commit --amend the changes before a reference is added to bugzilla.
  • Avoid adding extra commits in the branch, always prefer cherry-picks to keep cross references with what's in trunk.
  • If the patch is a backport, you're free to add your own changelog, but make sure there are at least two lines there: one with the bug title and one with the full bug URL;
  • In case of doubts, follow the example of what's already there (see git log).

To create release notes reports (similiar to the ones posted weekly in the QtWebKit Developer Journal), run the (see --help). Usually it looks like this:

  $ --commits <previous-tag> --email ';'

Don't forget to tag the repository (and git push --tags) before making an announcement.

Proposal for release testing

The idea for a new release would be that it has no regressions over the previous release. This should mean:

  • All LayoutTests that passed on the old version should pass on the release candidate.

This can be realized by either storing the list of tests ran on the old release somewhere or using the LayoutTests/ directory of the old release. This has the possible problem that DRT was changed in a incompatible way or the WebKit behavior was changed and now a test would fail. Alternatively one could compare the list of tests that were ran and for every removed test it may not be in the Skipped list.

  • It should pass all manual tests.

This can be realized by creating a "meta" manual page linking to all manual tests we want to run before the release.

  • It should not consume more memory on the existing test cases and benchmarks.

This can be realized by using and use QtLauncher on a list of URLs and use mirrored content (from the benchmarking). Afterwards one can manually compare the memory usage.

  • Survive a night with iexploder or other fuzzing utilities.

As part of the release the tester(s) should write a simple protocol. It should include the LayoutTests ran, the manual tests ran and their results, the result of and should be stored on a publicly available place for future reference.

Nokia Releases

Nokia creates the following official releases of QtWebKit:

  1. Every releases consists of a source package that is available for download (todo: add location). The source package can be compiled and installed into an existing installation of Qt, as an convenient way for developers to try out new releases with their applications.
  2. QtWebKit releases are included in the Qt application and UI framework and can be downloaded as source and binaries from Qt's support team provides commercial support for these releases.
  3. Nokia also delivers the QtWebKit releases to the Symbian Foundation and the Maemo project.

In these release channels the release is always first available as a source only package. New releases will be included in future versions of Qt. It may happen that a release becomes available in Symbian or Maemo before it is included in Qt, as these delivery channels are independent. The inclusion of newer QtWebKit releases in Symbian and Maemo and their availability as separate source packages constitutes the independence from Qt.

We maintain backwards binary and source compatibility between minor and patch releases.

Release Management Tools

The scripts used to semi-automate the release management work (cherry-pick, bugzilla interaction, reports, release-notes, etc) can be found in the qtwebkit/tools git repository.