Add serializeForDateTimeTypes()
The code is moved from setValueAsDate() and setDateValue().

Add serialize()

parseToDouble() is the top-level function to parse a
type-dependent string and return a double
value. parseToDoubleForNumber() and parseToDateComponents()
functions are helper functions for it. serialize() is the
top-level function to serialize a double value to a type-dependent
string, and serializeForNumberType() and
serializeForDateTimeTypes() are helper functions for it.

Final cleanup for ​http://trac.webkit.org/changeset/54748.
Some MS fonts don't come with a default install of Tiger, but do
come with a default Leopard/SnowLeopard install. As a result we naturally
get different metrics a page uses these fonts.

-Put the baseline for text-control-intrinsic-widths in the right place!
-I missed perspective-non-layer.html because we don't run it on Leopard.
-Accidentally deleted drag-text-delay-expected.txt and text-control-intrinsic-widths-expected.txt
instead of updating their results.

For Mac fonts that have invalid avgCharWidth entries in the OS/2 table,
fallback to the Safari 4- behavior of using the width of a zero. For other
fonts, make Mac match Windows (and thus IE) metrics.

Lucida Grande is hard-coded to match MS Shell Dlg for inputs and
Courier New for textareas in order to match Safari Win, Firefox and, in
some cases IE (IE uses different default fonts depending on encoding).

The only case where we still don't match Windows is if no font-size is
set. The default font-size for form controls on the Mac is smaller and
thus text-control widths will be slightly smaller.

Since ​http://trac.webkit.org/changeset/54460 the EventListeners registered by a
worker thread are not removed until after the thread's JSGlobalData has been
destroyed. This is slightly worrisome since the JSEventListener contains
JSObject*s, which will be dangling once the heap is destroyed. The
JSEventListeners may also reference the worker thread's normal world, which
again it makes no sense to keep around after the JSGlobalData is freed.

Remove all event listeners immediately prior to tearing down the JSGlobalData.

​https://bugs.webkit.org/show_bug.cgi?id=34728 addressed the symptoms of this
problem, and it is probably cleaner to make the client data's normal world no
longer be a member (since it is a ref-counted object), however they should be
no requirement to 'detatch' – it makes no sense for anyone to be referencing
the world after the JSGlobalData has gone away (the world's purpose is to hold
wrapper objects in the JSGlobalData's heap). Keep the restructuring that makes
the normal world no longer be a member, but remove the detach mechanism this
patch added & replace with stronger ASSERTs.

These break the OS X Leaks tool. Use a bits stolen from the refCount to hold the
'InTable' and 'HasTerminatingNullCharacter' flags, along with the string type
(fixes a leak where the string data is allocated at the address (this + 1), and is
misinterpreted as being an internal buffer).

Selecting text contained in <foreignObject> leads to artefacts. Same for zooming/panning.
RenderForeignObject contained old legacy code returning FloatRect() for repaintRectInLocalCoordinates,
which is obviously wrong. Fixing that leads to even more problems, as the underlying RenderBlock
did not reflect the x/y translation set on the <foreignObject>. This is problematic, as laying out
positioned objects in the XHTML subtree depends on proper size/location values of the frameRect.

Correctly clip on overflow="hidden". overflow="scroll" & friends are not yet supported, see lengthy
comment in RenderSVGBlock why we either need RenderLayer for RenderForeignObject or need to rework
overflow handling to avoid RenderLayer.

SVGForeignObjectElement uses a hacky custom solution to synchronize CSS width/height properties with
the SVG width/height attributes. Remove all of that code and just implement calcWidth/calcHeight in
RenderForeignObject, grabbing the right values from SVGForeignObjectElement::width/height upon layout.

svg/SVGForeignObjectElement.cpp: Kill a lot of custom code - it was just plain wrong to utilize CSS to push width/height information down to RenderBlock.
(WebCore::SVGForeignObjectElement::svgAttributeChanged):

(WebCore::ComplexTextController::ComplexTextRun::ComplexTextRun):
(WebCore::ComplexTextController::ComplexTextRun::setIsNonMonotonic): Added. Sets m_isMonotonic
and populates m_glyphEndOffsets with the end offsets of each glyph’s corresponding character range.
(WebCore::ComplexTextController::advance): For non-monotonic runs, use endOffsetAt() to get
glyphs’ end offsets.
(WebCore::ComplexTextController::adjustGlyphsAndAdvances): Check for monotonicity and call
setIsNonMonotonic() if needed.

html/HTMLFormCollection.cpp: (WebCore::HTMLFormCollection::formCollectionInfo): Removed
a misplaced checkConsistency() call. We are not looking at cache content at this point, and
caches will be reset on next access.

Another problem with protected references is that they can keep a bunch
of strings alive long after they're useful. In SunSpider and a few popular
websites, the size-speed tradeoff seems to favor weak references.

runtime/JSPropertyNameIterator.cpp:
(JSC::JSPropertyNameIterator::JSPropertyNameIterator): Moved this constructor
into the .cpp file, since it's not used elsewhere.

(JSC::JSPropertyNameIterator::~JSPropertyNameIterator): Added a destructor
to support our weak reference.

runtime/JSPropertyNameIterator.h:
(JSC::Structure::setEnumerationCache):
(JSC::Structure::clearEnumerationCache):
(JSC::Structure::enumerationCache): Added a function for clearing a
Structure's enumeration cache, used by our new destructor. Also fixed
indentation to match the rest of the file.

Flex (​http://flex.sourceforge.net/) uses identifiers named as yy_*.
WebCore/css/CSSParser.cpp needs to handle some such identifiers.
We should relax the style rule for the file to allow underscored identifiers.

Flex (​http://flex.sourceforge.net/) uses identifiers named as yy_*.
WebCore/css/CSSParser.cpp needs to handle some such identifiers.
We should relax the style rule for the file to allow underscored identifiers.

Unfortunately our ​http://webkit.org/pending-commit bugzilla query is not
smart enough to ignore obsolete patches, so bugs show up there which are
still open, but do not have patches ready for landing on them.
This new command "clean-pending-commit" will remove r+ from obsolete patches
in the pending-commit list.

This is due to the fact that the Mac port has an
invalid path to the image diff tool. Currently it points
to image_diff even though ImageDiff would be correct. We
can't change it to the right path yet without causing the
script to hang. ImageDiff expects to be long-running and
be passed image data over stdin. image_diff (chromium's fork)
expects to be passed command line arguments.
This fix works around the random failures by disabling pixel
tests on mac and logging if the user was trying to run with pixel
tests enabled.

(JSC::typeName): Use a little capitalization. Don't crash in the case of
a non-object cell, since it might just be an uninitialized cell.

(JSC::Heap::objectTypeCounts): The new SPI.

runtime/Collector.h:

runtime/CollectorHeapIterator.h:

(JSC::CollectorHeapIterator::advance):
(JSC::LiveObjectIterator::operator++):
(JSC::DeadObjectIterator::operator++):
(JSC::ObjectIterator::operator++): Made 2 tweaks to these iterators:
(1) Skip the last cell in the block, since it's a dummy sentinel, and
we don't want it to confuse the object count; (2) Fixed a logic error
in LiveObjectIterator that could cause it to iterate dead objects if
m_block were equal to m_heap.nextBlock and m_cell were less than
m_heap.nextCell. No test for this since I can't think of a way that this
could make WebKit behave badly.

WebKit/mac: Exported some new JavaScript heap introspection.

Reviewed by Oliver Hunt.

Misc/WebCoreStatistics.h:

Misc/WebCoreStatistics.mm:

(+[WebCoreStatistics javaScriptObjectTypeCounts]): Just like
javaScriptProtectedObjectTypeCounts, except this function enumerates all
live objects, not just protected objects.

Small cleanups in SVG render tree code.
Centralize calls to inflateShadow(), in SVGRenderSupport::computeRectForRepaint,
instead of spreading them around the subclasses. All classes should inherit
protected from SVGRenderBase, made it consistent.

Test that Web Inspector can inspect styles of elements in iframe from a domain
different from main frame domain.

inspector-tests.js moved to LayoutTests/http/tests/inspector because it can
be referenced by relative path from LayoutTests/inspector but not vice versa
(html files served from LayoutTests/http/tests cannot refer it because WebKit
tests httpd doesn't serve content not under LayoutTests/http).

This change brings back SourceFrame's canvas+style magic, restores line
wrapping and makes things a lot like they used to be.
It removes TextEditor for now and renames NativeTextViewer into TextViewer.
TextViewer is no longer derived from TextEditor.
This TextViewer is still based on TextEditorModel, no iframes are involved.

Instead of creating div per line, TextViewer splits source code into 50 line
chunks. Upon scroll event, visible chunks are sharded into lines and individual
lines are highlighted. Whenever highlighted region gets outside of the visible
area, highlight spans are thrown away and region is replaced with the original
plain text chunk.

Complex stuff:

Whenever there is a need to manipulate individual lines (add message bubble /
set breakpoint / reveal / etc.), individual chunks for such lines are created.

There is also an implicit machinery that is maintaining selection when it
goes beyond the visible area.

[Qt] GraphicsLayer: somtimes the item flickers at the end of an animation
This is because we try to delete the animation when finished: that is
unnecessary. WebCore manages the animation's lifecycle and makes sure
to call the right function when the animation can be deleted.

SVGMaskElement is the only class that keeps a HashMap of canvas
resources rather than just a pointer to a resource. This
patch makes SVGMaskElement invalidate all of its resources in the
HashMap instead of just one.

The changes to the rect conversions are indeed correct. In Haiku (to stay
compatibly with BeOS), a BRect specifies the left/top and bottom/right pixel
*indices*, even though the values are floating point. So a rectangle covering
just one pixel would be specified as BRect(0, 0, 0, 0). In WebCore and other
frame works, such rectangles would be expressed as 0, 0, 1, 1. In WebCore, the
width and height of rectangles refer to the distance between pixels, while on
Haiku, a one pixel rect has indeed a width and height of 0, as confusing as
that may be.

The part of the patch that affects
WebCore/platform/graphics/haiku/ImageHaiku.cpp also implements the drawing
methods more correctly. Image observers are notified, and pattern drawing takes
the "phase" into account which makes scrolled backgrounds render correctly.
Transformations are still not supported, since the Haiku drawing backend itself
does not yet support them.

Use OwnPtr when creating the BBitmap to avoid future leaks with early returns.

This doesn't fix the root cause of us not
correctly failing when support binaries are missing.
This only causes the DumpRenderTree binary not to be
missing in the custom build directory case.
Later patches will make us correctly fail fast when
support binaries (like DumpRenderTree or ImageDiff) are missing.

Scripts/webkit-build-directory: Added.

Need a way to re-use the perl logic for finding build directories in non-perl scripts.

loader/ImageLoader.cpp:
(WTF::ValueCheck): Special case value check for ImageLoader - it's allocated inside elements,
so check the owner instead.
(WebCore::ImageEventSender::hasPendingEvents): Added a debugging aid for ImageLoader destructor.
(WebCore::ImageLoader::~ImageLoader): Assert that we're not going to leave dangling pointers
in ImageEventSender.
(WebCore::ImageLoader::setImage): Cancel events that could be dispatched for the previous
image. The only client using this method that I could find was DeleteButton, which doesn't
care about load events for the new image, so I didn't add any code for firing those.
(WebCore::ImageLoader::setLoadingImage): This method only existed to confuse readers -
there wasn't any meaningful code shared (callers just undid most assignments made there).
Merged the logic into callers.
(WebCore::ImageLoader::updateFromElement): We're forgetting the old image, so forget its
old events, too.
(WebCore::ImageLoader::notifyFinished): This can be called from setImage(), in which case
no one is going to dispatch the event "soon". So, don't queue it.
(WebCore::ImageEventSender::dispatchPendingEvents): Call checkConsistency(). This didn't
help catch this particuar bug, but seems like a useful check anyway.

(WebCore::ImageBuffer::toDataURL): Don't allocate an unused CGImageRef
and buffer, and switch to the new overload of base64Encode that
doesn't require us to copy all the image data into a Vector first.

platform/text/Base64.cpp:

(WebCore::base64Encode):

platform/text/Base64.h:

Added an overload that takes a raw data pointer and length, just like
we have for base64Decode. The overload that takes a Vector as input
just calls through to the new overload.

(_NPN_Evaluate):
If Flash calls this to evaluate a script that destroys the PluginView,
we crash when returning to Flash code. Before evaluating the script,
call PluginView::keepAlive() to hold a ref to this instance (and release
it asynchronously).

plugins/PluginView.cpp:

(WebCore::instanceMap):
Return a map from the NPP to the PluginView.
(WebCore::PluginView::~PluginView):
Assert that the keep alive timer is not running; remove ourselves from
the instance map.
(WebCore::PluginView::performRequest):
The parent Frame is now a RefPtr; use .get().
(WebCore::PluginView::status):
Ditto.
(WebCore::PluginView::didReceiveResponse):
Ditto.
(WebCore::PluginView::PluginView):
Add the view to the instance map.
(WebCore::PluginView::lifeSupportTimerFired):
Deref the PluginView.
(WebCore::PluginView::keepAlive):
Ref the PluginView, then start a time to release the reference
asynchronously.
(WebCore::PluginView::keepAlive):
Find the PluginView in the map, and call its keepAlive() function.

plugins/PluginView.h:

Made m_parentFrame a RefPtr, so that it will remain valid when the
keep alive timer fires.
(WebCore::PluginView::parentFrame):
Use .get().

plugins/gtk/PluginViewGtk.cpp:

(WebCore::PluginView::updatePluginWidget):
Use .get().
(WebCore::PluginView::handleKeyboardEvent):
Use .get().
(WebCore::PluginView::handleMouseEvent):
Use .get().

plugins/PluginViewNone.cpp:

(WebCore::PluginView::keepAlive):
Stubbed.

WebKitTools:

DumpRenderTree/win/TestNetscapePlugin/main.cpp:

(executeScript):
Moved to an earlier point in the file.
(NPP_New):
If the plug-in has an onDestroy attribute, store its value.
(NPP_Destroy):
If the plug-in has code to run on destruction, run it and free it.

(WebCore::FontCache::getCachedFontData): This method is meant to replace getCachedFontPlatformData
that was moved in the private section of the class. It calls getCachedFontPlatformData and cache
the returned FontPlatformData if it is not null.
(WebCore::FontCache::getFontData): Updated to use the new getCachedFontData.

platform/graphics/FontCache.h: Updated several methods to return a SimpleFontData in lieu of a

(WebCore::FontCache::getSimilarFontPlatformData):
(WebCore::FontCache::getLastResortFallbackFont):
Updated all the previous platform methods to return a SimpleFontData.

platform/graphics/mac/FontCacheMac.mm:

(WebCore::FontCache::getSimilarFontPlatformData): Updated to return a SimpleFontData.
(WebCore::FontCache::getLastResortFallbackFont): Ditto. Also refactored the code
and moved a DEFINE_STATIC_LOCAL where it is needed.

Extract the platform dependant Apache configuration checking code in httpd.pm to a separate function
called getHTTPDConfigPathForTestDirectory and use run-launcher instead of run-safari if run on Linux.

[Chromium] Refactor AutocompletePopupMenuClient into a base class,
SuggestionsPopupMenuClient, and two derived classes,
AutocompletePopupMenuClient and AutoFillPopupMenuClient. Currently
the behavior of suggestions popups has not changed.

Some optimizations to safe unnecessary summations and multiplications.
Optimize AffineTransform to handle an identity or translation matrix
more efficient.
Added translationRight to avoid multiplications of matrices as much as
possible.

WebCoreSupport/WebFrameLoaderClient.mm: (NetscapePluginWidget::handleEvent): A mouseout
DOM event is dispatched while handling NSMouseMoved - but we shouldn't be sending a
mouse moved event to plug-ins at this point.

Set the Gtk Adjustments of the FrameViews when they are restored
from the PageCache too. Right we only do it for the newly created
FrameViews in transitionToCommittedForNewPage, but we it also
needs to be done in the equilavent transition method for cached
pages.

Add two subphases SVGTextPaintSubphaseGlyphFillSelection and
SVGTextPaintSubphaseGlyphStrokeSelection for painting selected
text on SVG. Selected texts are painted with style from
getCachedPseudoStyle() instead of style().

Add two subphases SVGTextPaintSubphaseGlyphFillSelection and
SVGTextPaintSubphaseGlyphStrokeSelection for painting SVG text
selection. texts are painted with style from getCachedPseudoStyle() instead of style().

Three small string fixes:
(1) StringBuilder::release should CRASH if the buffer allocation failed.
(2) Remove weird, dead code from JSString::tryGetValue, replace with an ASSERT.
(3) Move UString::createFromUTF8 out to the API, as tryCreateStringFromUTF8.

This is only used from the API, and (now) unlike other UString::create
methods may return UString::null() to indicate failure cases. Better
handle these in the API.

platform/graphics/qt/GraphicsLayerQt.cpp:
(WebCore::MaskEffectQt::MaskEffectQt): implement mask as
QGraphicsEffect
(WebCore::MaskEffectQt::draw): reimp
(WebCore::GraphicsLayerQtImpl::GraphicsLayerQtImpl): init the effect
(WebCore::GraphicsLayerQtImpl::paint): no need for drawContents
(WebCore::GraphicsLayerQtImpl::flushChanges): make sure to update the
mask layer, not just the actual children

css2.1/t0803-c5504-imrgn-l-02-b-ag-expected.html and css2.1/t0804-c5509-ipadn-l-02-b-ag-expected.html have been rebaselined
because the original expected values are incorrect, judging from the test description and how IE 8.0, Firefox 3.6, and Opera 10.10 render the pages.
fast/dom/clone-node-dynamic-style-expected.html have been also rebaselined because the original expected values assumes a line break.
Expected values under platform/qt need not be updated because the tests are in the Skipped file for the platform.

findNextLineBreak() unconditionally allowed lines to break between elements when no other line breaking opportunity had been found,
but that was unnecessary and led to incorrect layout. Disallow that kind of line breaks.