I believe size property hasn't been used so far because (1) it hasn't been properly parsed and
(2) a comment in CSSComputedStyleDeclaration::getPropertyCSSValue says so.
Changing the way of parsing it should not cause any regressions -- no existing tests fail because of this change.

[chromium] Fix bug that prevents autosave of forms without action attribute​https://bugs.webkit.org/show_bug.cgi?id=38014
Change is in the Chromium WebKit API so it can't be tested with a JS-based layout test.
It needs a native unit test, which would go in the Chromium repo, not WebKit.

src/WebPasswordFormData.cpp:
(WebKit::WebPasswordFormData::WebPasswordFormData): Set correct URL if action is NULL

[Chromium] Add two things to the webkit API to support appcaches in workers.
1) WebURLRequest TargetTypes for worker and shared worker main resources.
2) Factory method on class WebCommonWorkerClient to

[Chromium] Add two things to the webkit API to support appcaches in workers.
1) WebURLRequest TargetTypes for worker and shared worker main resources.
2) Factory method on class WebCommonWorkerClient to

Unfortunately, the simple fix of not populating the drag data with file URLs doesn't work
since the default drop handling uses the drag data URL to navigate to dropped files/URLs.
For now, we hack around the problem in the Chromium platform, but the proper long term
solution is to change DragController::performDrag to check dragData::asFilenames().

When doing a partial redraw of an SVGImage used as a CSS background
image, we're limited to drawing the entire Frame, clipped to the dirty rect.
Because of this, we need to fix up the CTM so that the origin is at the
top left of the unclipped image, rather than the top left of the
portion being redrawn.

(WebCore::DocumentThreadableLoader::DocumentThreadableLoader): Now we remove the
credential from the request here to avoid forgetting to do so in the different code path.
(WebCore::DocumentThreadableLoader::makeSimpleCrossOriginAccessRequest): Just add the
"Origin" header.
(WebCore::DocumentThreadableLoader::loadRequest): Check here the the credential have
been removed so that we don't leak them. Also tweaked a comment to make it clear that
the URL check has issue when credential is involved.

LayoutTests:

Test that doing a cross-origin request with a preflight check does
not raise a NETWORK_ERR exception and does not send the credentials.

[chromium] Merged the WebView public method to close suggestion popups
into a single method to close all popups (select and suggestions).
That ensures select popups are closed when the browser window is moved
or resized.​https://bugs.webkit.org/show_bug.cgi?id=37837

​http://trac.webkit.org/changeset/58191/ caused the caret-rtl-2 layout
test to start failing under Chromium. Since we're the only ones who
run pixel tests, it's possible that the actual baseline needs to be updated
and not just the chromium baseline...but I'm not sure.

​https://bugs.webkit.org/show_bug.cgi?id=38154 FastMalloc calls madvise too often.
<rdar://problem/7834433> REGRESSSION: 1.5% PLT regression due to 56028 (return memory quicker).
To save on madvise calls when recommitting memory recommit the entire span and then carve it
instead of carving the span up and only committing the part that will be used immediately.

We must let Skia do font fallback, rather than picking a font name
then handing that to Skia. For example, if we have Bengali text and
choose FreeSans + fake bold, and then later reuse the name, Skia will
helpfully use FreeSansBold (which doesn't cover Bengali).

In the process of remove the custom code from NodeIterator, we thought
we fixed a subtle bug where iterating over nodes from another frame
would get the wrong prototype chain. This test documents that we
didn't actually change the behavior and we still have the bug.

Another example of CallWith=ScriptState. This case shows us the right
way to handle the interaction with exception codes.

In my previous patch, I put the exception code handling after the
ScriptState exception handling. It turns out this was a mistake
(although a harmless one at the time because no IDL caused us to
generate that code). Now that we're generating both kinds of exception
handling, we need to generate them in the right order.

It's somewhat lame to special case addEventListener and
removeEventListener in the code generator, but it saves a large amount
of boilerplate "custom" bindings code.

Idea shamelessly stolen from the V8 code generator.

This patch points to some good refactoring opportunities in
CodeGeneratorJS.pm, but I'm going to hold off on those for a future
patch. By generating test coverage for the code generator, we make
these future refactorings easier.

In 58261, we added code to abstract step that interrogates the squash
and git_commit options, but it doesn't declare that it uses those
options. That means any command that doesn't happen to declare those
options might be broken if it uses the cached_lookup mechanism.

Remove call to StringImpl::createCFString and instead use CFStringCreateWithCharacters
directly. StringImpl::createCFString only an optimization when called
from the thread that WebCore is running on, which is never the case for
WKStringCopyCFString. We should revisit this later, perhaps adding a
threadspecific allocator. We also now honor the passed in allocator.

Rather than sprinkle PLATFORM #ifdefs around, add a new method,
RenderLayerCompositor::shouldPropagateCompositingToIFrameParent(), that indicates whether
an iframe with composited content should trigger compositing mode in the enclosing document
(a behavior that differs between platforms).

Use this new method to determine whether to trigger a style recalc in the parent document
when an iframe becomes composited.

Move the code formerly in RenderView::compositingStateChanged() into RenderLayerCompositor().

This is a simple extension to my prior patch. Basically hoist the
existing character loading logic from the charCodeAt thunk and into
a helper function, then add a helper to load strings from the small
string cache. This allows trivial implementations of fromCharCode
and charAt.

​http://trac.webkit.org/changeset/55798 simplified processing of
active DOM objects but introduced a subtle bug in garbage
collection of XHRs. ActiveDOMObject is not a direct base class of
XHR and so upcasting changes pointer identity and breaks DOM
maps. This leads to forever live persistent handles to XHR that
had pending activity while V8 GC happened.

After further research, I believe the hang is caused by:​http://bugs.python.org/issue2320
Basically Popen() is not reentrant.
The workaround is to pass close_fds=True to Popen() on Mac/Linux.

I fixed our main Popen wrapper "Executive.run_command" to use close_fds=True
when appropriate.

I audited all places we call Popen() and either moved them to run_command
or left a FIXME that they are not thread safe. A few places I added the
close_fds workaround there and left an explanitory note.

Scripts/webkitpy/common/checkout/scm_unittest.py:

Added note that this Popen use is not threadsafe.

Scripts/webkitpy/common/system/executive.py:

Fixed our Executive.run_* to workaround python bug 2320.

Scripts/webkitpy/common/system/user.py:
_ Added note that this Popen use is not threadsafe.

An <input type="search"> contains an inner block, which is explicitly
centered in RenderTextControlSingleLine based on the height of the element.
However, the clipping rect was not using the set location, and instead
calculated off of the top border and padding alone. This also vertically
centers the Caps Lock indicator.

rendering/RenderTextControl.cpp: moved controlClipRect implementation to RenderTextControlSingleLine

WebCore::CSSSelector::RareData::parseNth doesn't check whether the search for '-' in the argument was successful.
This results in incorrect parsing.
For example, '3n' is parsed as if it were '3n-3'. The code has been working OK just accidentally.

The problem with calling lightweight builtins is that marshalling
the call from the nitro calling convention to the system calling
convention is very expensive relative to the cost of the actually
evaluating the function. To work around this problem this patch
adds the ability to define a custom thunk for a builtin.

This allows us to use high performance custom implementations of
the common and sensible versions of simple builtins. This patch
includes a simple (use of which is currently hardcoded) thunk for
charCodeAt.

This adds a JSInterfaceJIT subclass called SpecializedThunkJIT
that has helper functions to remove (or at least reduce) the need
to have separate thunk implementations for each JSValue encoding.

I did a number of separate optimizations which speed up style
resolution enough to more than make up for the regression. This
measures as a total PLT speedup of somewhere between 1.5% and
3.7%.

Optimizations done:

Cache determineLinkState results, to avoid the need to repeatedly compute
the visited link hash for the same element. This directly addresses much
of the slowdown, since all elements get their style computed twice now.

Added a fast way to get the length of a CSSMutableStyleDeclaration, and use
in CSSStyleSelector::matchRulesForList, since it was hot there.

Hoist some loop invariant code that's not detected by the compiler out of the
main loop in matchRulesForList

inline CSSStyleSelector::initElement and locateSharedStyle,
since there is only one call site in each case

Inline the common non-line fast case of determineLinkState, and split the rest into
out-of-line determineLinkStateSlowCase.

Added inline versions of the functions called by
visitedLinkHash (the version called by determineLinkState).

css/CSSMutableStyleDeclaration.cpp:
(WebCore::CSSMutableStyleDeclaration::length): Implemented in terms of new
inline nonvirtual mutableLength().

css/CSSMutableStyleDeclaration.h:
(WebCore::CSSMutableStyleDeclaration::mutableLength): Added new nonvirtual
inline way to get the length if you know you have a mutable style decl.

css/CSSStyleSelector.cpp:
(WebCore::CSSStyleSelector::init): Clear cached link state.
(WebCore::CSSStyleSelector::matchRulesForList): hoist some code out of the main
loop and get style decl length more efficiently.
(WebCore::CSSStyleSelector::initElement): inline (only one call site)
(WebCore::CSSStyleSelector::SelectorChecker::determineLinkState): Inline fast
case, call slow case.
(WebCore::CSSStyleSelector::SelectorChecker::determineLinkStateSlowCase): Split
most of the above function into this slow case helper.
(WebCore::CSSStyleSelector::canShareStyleWithElement): Use the cache-enabled
way to get the current link state.
(WebCore::CSSStyleSelector::locateSharedStyle): inline
(WebCore::CSSStyleSelector::styleForElement): Use the cache-enabled way
to get the current link state.

css/CSSStyleSelector.h:
(WebCore::CSSStyleSelector::currentElementLinkState): inline way to
get link state for the current element; manages the cache

platform/LinkHash.cpp:
(WebCore::visitedLinkHashInline): inline version of below function
(WebCore::visitedLinkHash): call the inline version
(WebCore::visitedURLInline): inline version of below function
(WebCore::visitedURL): call the inline version
(WebCore::visitedURL): call inline versions of above two functions

Turn on AUTO_VACUUM = INCREMENTAL for all HTML5 databases, and
vacuum all databases when the number of free pages is at least 10%
of the number of total pages. Also, adding a guard against a bug
that was fixed in SQLite only starting with version 3.6.16.

(JSC::RegisterFile::RegisterFile): Use WeakGCPtr for managing m_globalObject,
since it's a weak pointer. (We never noticed this error before because,
in WebKit, global objects always have a self-reference in a global variable,
so marking the register file's global variables would keep m_globalObject
alive. In the JavaScriptCore API, you can allocate a global object with
no self-reference.)

runtime/JSActivation.h: Removed unneeded #include.

runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::~JSGlobalObject): Don't use ==, since a weak
pointer is 0 when the object it points to runs its destructor.

runtime/WeakGCPtr.h:

(JSC::WeakGCPtr::clear): Changed to return a bool indicating whether the
clear actually happened.
(JSC::WeakGCPtr::assign): Changed to forbid assignment of 0 as a shorthand
for calling clear(). A client should never clear by assigning 0, since
clear() should be conditional on whether the object doing the clearing
is still pointed to by the weak pointer. (Otherwise, a zombie object might
clear a pointer to a new, valid object.)

Added Mac only initializeMainThreadToProcessMainThread which sets up callOnMainThread
and isMainThead calls to assume that WebCore's main thread is also the
process's main thread. Since it is possible that both initializeMainThread
and initializeMainThreadToProcessMainThread could be called, the first one called
wins (either will work).

wtf/Threading.h: Moved to top of file.

wtf/ThreadingPthreads.cpp:

(WTF::initializeThreading): Remove call to initializeMainThread.

wtf/ThreadingWin.cpp:

(WTF::initializeThreading): Ditto.

wtf/gtk/ThreadingGtk.cpp:

(WTF::initializeThreading): Ditto.

wtf/mac/MainThreadMac.mm:

(WTF::initializeMainThreadPlatform):
(WTF::initializeMainThreadToProcessMainThread):
(WTF::scheduleDispatchFunctionsOnMainThread):
(WTF::isMainThread):
Add runtime switch between the old behavior of using the system's main
thread and a stored pointer to the main thread. Tiger always uses the
system's main thread.

An empty credential is currently regarded as a invalid login because it means a missing value in
protectionSpaceToCredentialMap. This change makes it consistent with current WebCore's behavior
by ignoring empty credentials.

No new tests added since this only affects credential entered by user from credential dialog,
which is not testable in DRT.

--git-commit will use a specific local commit for land/upload.
If a commit-range is specified, then that range is treated as
a single squashed commit.

--squash will squash all local changes including working copy changes
into a single patch.

--no-squash is the legacy behavior (upload only considers the working copy,
land commits the working copy and then each local commit separately to SVN)

If neither is specified, then an informative error is raised if there is
more than one local commit or when there are local commit(s) and working
copy changes.

If the webkit-patch.squash git config parameter is set, then
that will be respected instead of raising an error.

Scripts/check-webkit-style:

Scripts/webkitpy/common/checkout/api.py:

Scripts/webkitpy/common/checkout/api_unittest.py:

Scripts/webkitpy/common/checkout/scm.py:

Scripts/webkitpy/common/checkout/scm_unittest.py:

Scripts/webkitpy/style/optparser.py:
--git-since is removed and --git-commit no longer implies commit_id..
Instead, it treats that individual commit, but also supports commit ranges
(e.g. commit_id..) as arguments.

WebCore/platform/Arena.h: uword is used to cast from pointers here. unsigned long is 32-bit on Windows (but 64-bit on mac), and too small to hold a pointer. uintptr_t is 32-bit on 32-bit systems (mac, linux and windows) and 64-bit on all 64-bit systems

If an QVariantMap containing QObjectStar is added to the to QtWebkit
Javascript, it's use causes Segmentation Fault.
It happens because, in the case QMetaType::QVariantMap, the "root"
object that is inside of a PassRefPtr is passed recursively inside a
loop to recover the content of the map, but the PassRefPtr semantics
prohibit its use inside a loop, so the "root" object mus be passed
using the method "PassRefPtr::get" in order to keep the current
reference.

If an QVariantMap containing QObjectStar is added to the to QtWebkit
Javascript, it's use causes Segmentation Fault.
It happens because, in the case QMetaType::QVariantMap, the "root"
object that is inside of a PassRefPtr is passed recursively inside a
loop to recover the content of the map, but the PassRefPtr semantics
prohibit its use inside a loop, so the "root" object mus be passed
using the method "PassRefPtr::get" in order to keep the current
reference.

This revision separates the code responsible for reading and iterating
over text files from the rest of check-webkit-style.

Scripts/check-webkit-style:

Changed the script to use the new StyleProcessor and
TextFileReader classes instead of the StyleChecker class.

Scripts/webkitpy/style/checker.py:

Added a FIXME to rename many of uses of the word "processor" to
"checker". We did this to clarify the difference between
ProcessorBase instances passed to the TextFileReader and
classes that process and check lines for style.

Added a FIXME to remove FileType.NONE as a possible return value
of ProcessorDispatcher._file_type(). This will better consolidate
the logic of which files should be skipped.

Added a FIXME to delete the StyleChecker class.

Added the StyleProcessor class which implements ProcessorBase.
This class is responsible for processing lines to check style
(but not for reading files). For each file, this class creates
creates both a carriage-return checker and a format-specific
style checker (e.g. one of C++, Python, etc).

Updated the PatchChecker class to use a TextFileReader instance
instead of a StyleChecker.

Scripts/webkitpy/style/checker_unittest.py:

Added the StyleProcessor_EndToEndTest class to do "end-to-end"
tests of the StyleProcessor class.

Added the StyleProcessor_CodeCoverageTest to test the
StyleProcessor class with more complete code coverage.
Unlike the StyleProcessor_EndToEndTest class, this class makes
heavy use of mock parameters.

Added FIXME's to delete the unit test classes that are no
longer needed.

Updated the PatchCheckerTest class to use a MockTextFileReader
instead of a MockStyleChecker.

runtime/JSGlobalObjectFunctions.cpp:
(JSC::parseInt): Added a FIXME comment about a problem I noticed.
(JSC::parseFloat): Added a FIXME comment about a problem I noticed;
covered by test cases in the test I added.

runtime/UString.cpp:
(JSC::UString::toDouble): Added FIXME comments about two problem I
noticed; covered by test cases in the tests I added. Added a return
statement so we don't crash when illegal UTF-16 sequences are present.

WebView was calling -_webView in a few places where it should have just used itself. It never
makes sense for WebView to call -_webView on itself, and these calls look like they were copied
from similar code in WebHTMLView, WebFrameView and WebDataSource, where -_webView has a different,
useful meaning.

Former implementation attempted to use AtomicString(HashTableDeletedValue)
however those values cannot be used that way: one cannot construct
QualifiedNameImpl out of such AtomicString as we'll try to lookup this string
in the table, for example.​https://bugs.webkit.org/show_bug.cgi?id=37722

Former implementation attempted to use AtomicString(HashTableDeletedValue)
however those values cannot be used that way: one cannot construct
QualifiedNameImpl out of such AtomicString as we'll try to lookup this string
in the table, for example.​https://bugs.webkit.org/show_bug.cgi?id=37722

The host check assumed that both host started at the same position. This is true
if both URL are the same but sometimes one has credential and the other does not.
In this case, the method would compare invalid positions.

Test: http/tests/appcache/credential-url.html

platform/KURL.cpp:

(WebCore::protocolHostAndPortAreEqual):

platform/KURLGoogle.cpp:

(WebCore::protocolHostAndPortAreEqual):
Fix the host check to take both URL's credential into account.

Attempt to turn the last core builder green again (not related anymore to my previous SVG checkins :-)
Skip http/tests/media/video-play-stall-seek.html on Windows as well (just like it has been done for Mac in r58107).
Bug ​https://bugs.webkit.org/show_bug.cgi?id=38000 describes the problem, and says it's ok to skip the test.

Not reviewed. Fix linkage on several bots (no idea, why it worked in a from-scratch rebuild on Leopard on my machine!) -> include NodeRenderStyle.h
Having to include NodeRenderStyle.h just to pull in the renderStyle() is a crazy concept, but I see what it tries to avoid (including RenderObject.h in Node.h)

Huge speedup for SVG painting using paint servers (gradient/patterns). Cache underlying
WebCore::Gradient/Pattern datastructures, do not rebuild them on every painting. This marks
the finish of the SVGResource -> RenderSVGResource transition.

Outline of same key changes:

RenderSVGResource is an abstract base class now, and the previous class is now named RenderSVGResourceContainer
All resources except RenderSVGResourceSolidColor now inherit from RenderSVGResourceContainer, as they are all
associated with a SVG*Element class. RenderSVGResourceSolidColor inherits from RenderSVGResource, and is not
associated with any SVG*Element class. RenderSVGResourceSolidColor is not a render tree object, despite its name.
The reason for that is consistency with all other painting resources.

RenderSVGResourceSolidColor does not live in the render tree, and exists only as static object, which is shared
and always used when filling/stroking with solid colors - just like the old SVGPaintServerSolid.

RenderSVGResourceGradient/RenderSVGResourcePattern now store the underlying WebCore::Gradient/Pattern object
instead of rebuilding it everytime we're asked to paint -> this is the main difference with the old concept, leading
to much faster speed.

SVGResource has vanished. All resources (clipper/filter/marker/masker/gradient/pattern) now share the same codepaths
to handle updates and client invalidation - which is a huge benefit, and makes the code easier to understand.

rendering/RenderSVGResource.h: Make RenderSVGResource an abstract base class, see above for the reasoning.
(WebCore::RenderSVGResource::RenderSVGResource):
(WebCore::RenderSVGResource::~RenderSVGResource):
(WebCore::RenderSVGResource::postApplyResource):

rendering/RenderSVGResourceLinearGradient.cpp: Moved from SVGPaintServerLinearGradient, cleaned up and refactored.
(WebCore::RenderSVGResourceLinearGradient::RenderSVGResourceLinearGradient):
(WebCore::RenderSVGResourceLinearGradient::~RenderSVGResourceLinearGradient):
(WebCore::RenderSVGResourceLinearGradient::buildGradient):

rendering/RenderSVGResourceRadialGradient.cpp: Moved from SVGPaintServerRadialGradient, cleaned up and refactored.
(WebCore::RenderSVGResourceRadialGradient::RenderSVGResourceRadialGradient):
(WebCore::RenderSVGResourceRadialGradient::~RenderSVGResourceRadialGradient):
(WebCore::RenderSVGResourceRadialGradient::buildGradient):

rendering/RenderSVGResourceSolidColor.cpp: Moved from SVGPaintServerSolid, cleaned up and refactored.
(WebCore::RenderSVGResourceSolidColor::RenderSVGResourceSolidColor):
(WebCore::RenderSVGResourceSolidColor::~RenderSVGResourceSolidColor):
(WebCore::RenderSVGResourceSolidColor::applyResource):
(WebCore::RenderSVGResourceSolidColor::postApplyResource):

svg/SVGStopElement.cpp: Clean up code, moved stop color calculation from SVGGradientElement to here, where it belongs.
(WebCore::SVGStopElement::parseMappedAttribute):
(WebCore::SVGStopElement::stopColorIncludingOpacity):

svg/SVGStopElement.h:

svg/SVGStyledElement.cpp:
(WebCore::SVGStyledElement::~SVGStyledElement):
(WebCore::SVGStyledElement::svgAttributeChanged): Only invalidateResourcesInAncestorChain()/deregisterFromResources() when we're not parsing.
(WebCore::SVGStyledElement::invalidateResourcesInAncestorChain): Early exit if we find a parent resources, there is no resource nesting.
(WebCore::SVGStyledElement::invalidateResourceClients): Renamed from invalidateCanvasResources()
(WebCore::SVGStyledElement::childrenChanged): Only invalidate SVGElementInstances when !changedByParser is set.

NOTE: This WILL affect _any_ platform with custom svg results for tests using gradients/patterns.

That means I have to wait for the bot results, and update them ASAP. Therefore landing out
of california business hours and on the weekend - please stay tuned I'll fix any breakages soon.
(Except for chromium whose test results are not available on build.webkit.org, sorry.)

Not reviewed. Add win specific result for svg/custom/broken-internal-references.svg
It's a bad idea that textPath dumps FLT_MAX when it's not shown - that should be fixed, but it's not related to Moritas testcase.

The problem was we were assuming patch files/diff output as utf-8.
Turns out they're not. We have to treat them as binary data because
a single patch may have multiple text files in it with conflicting encodings!

Scripts/webkitpy/common/checkout/api.py:

contents_at_revision returns a byte array, so decode it to unicode
before passing it to parse_latest_entry_from_file

Scripts/webkitpy/common/checkout/api_unittest.py:

Update our mock mock_contents_at_revision to match the encoding
semantics of the real one.

Scripts/webkitpy/common/checkout/scm.py:

Be careful not to decode output which may contain file contents
(like diff, cat or show) as the encoding for that content is unknown.

Scripts/webkitpy/common/checkout/scm_unittest.py:

Update our tests to use both latin1 and utf-8 encoded data.

Scripts/webkitpy/common/net/bugzilla.py:

_fill_attachment_form should not assume unicode data. Callers
may wish to attach other types of files to bugs.

Scripts/webkitpy/common/prettypatch.py:

Diffs are byte arrays, deal with them as such.

Scripts/webkitpy/common/prettypatch_unittest.py:

Test to make sure we handle diffs with multiple conflicting encodings.

Scripts/webkitpy/common/system/executive_unittest.py:

Make sure that our unicode support does not break our
byte array input support for run_command.

fast/events/touch/script-tests/basic-single-touch-events.js:
(verifyTouch): update test expectation with new coordinates.
(singleTouchSequence): increase the touch move delta.
(touchTargets): Start the touch at a different point to

This patch adds a vector of additionalFeatures to WindowFeatures
and populates it with any feature strings that evaluate to "yes"
and aren't directly observed in WindowFeatures. This allows
clients to capture experimental window features.

When a layer goes into compositing mode because it has a negative z-index child that is going
into compositing mode, then set willBeComposited to true. Also add another assertion to catch
any other cases where the state of willBeComposited is mismanaged.

After r37484, animation and transition end events were fired on a timer, after the animation/transition
ended. This opened up one event loop cycle in which the non-animating state of the element was visible
before the event fired, resulting in flashes in content that reset style from the event handler.

Fix by firing these events in the same event cycle as the animation end, once all animations
have been updated. This also required moving the place that start animations are fixed until
a later state in the state machine, so that animations have their start time set at the point
the event is fired (to avoid an assertion when using the freeze API in DRT).

Not testable, since the flash is very transitory and cannot be captured in a pixel test.

page/animation/AnimationBase.cpp:
(WebCore::AnimationBase::updateStateMachine): Move the firing of 'start' events into the state
where the start time is known.

page/animation/AnimationControllerPrivate.h:

page/animation/AnimationController.cpp:
(WebCore::AnimationControllerPrivate::updateStyleIfNeededDispatcherFired): Call the new fireEventsAndUpdateStyle()
method.
(WebCore::AnimationControllerPrivate::fireEventsAndUpdateStyle): New method to share code that used to be in
updateStyleIfNeededDispatcherFired().
(WebCore::AnimationControllerPrivate::animationTimerFired): Call fireEventsAndUpdateStyle() once we've
processed all animations.

new-run-webkit-tests: add a "--retry-failures" flag and a
"--no-retry-failures" flag (the former is the default). Also, rename
"--print-unexpected-results" and "--retry-unexpected-results" to
"--print-last-failures" and "--retry-last-failures" because the
retry flag was confusing. The new flag names aren't great, but
hopefully they're less confusing.

Every other Objective-C class that calls
WebCoreObjCFinalizeOnMainThread(self) in +initialize also calls
JSC::initializeThreading(). The WebTextIteratorPrivate class
was the only one missing this call.