webkit/webkitwebsettings.cpp: Change function call to reflect new
webkit_web_settings_get_enchant_dicts name.
(get_enchant_broker): Add this method which returns the enchant broker singleton.
(free_spell_checking_language): The list contents have changed, so change
the way each element is freed.
(webkit_web_settings_finalize): Change to reflect 'spell_checking_languages_list'
to 'enchant_dicts' member name change.
(webkit_web_settings_set_property): Use the broker singleton here instead of making
a new one for each language. The Enchant dictionary is now the list payload.
(webkit_web_settings_copy): More name-change updates.
(webkit_web_settings_get_enchant_dicts): Ditto.

bindings/js/JSDOMBinding.h:
(WebCore::Document::getWrapperCache): Inlined.
(WebCore::domObjectWrapperMapFor): Renamed to start with lowercase. Moved to header to inline.

bindings/js/JSDOMWrapper.h: Added.
(WebCore::DOMObject::DOMObject): Factored this out of JSDOMBinding.h to avoid include
cycle. I think the class should be renamed, I picked a forward-looking header name because
we already have a DOMObject.h

bindings/js/JSNodeCustom.h: Added.
(WebCore::getCachedDOMNodeWrapper): Moved from JSDOMBinding.cpp and moved here,
so it could inline everywhere without creating an include cycle. Consider inline
cache.
(WebCore::toJS): Moved to header to inline.

bindings/js/ScriptWrappable.h:
(WebCore::ScriptWrappable::ScriptWrappable): Implement this in the obvious
way for JavaScriptCore. (Using a WeakGCPtr).
(WebCore::ScriptWrappable::wrapper):
(WebCore::ScriptWrappable::setWrapper):
(WebCore::ScriptWrappable::clearWrapper):

bindings/scripts/CodeGeneratorJS.pm: Include CustomHeader heaaders
in the header, not just the impl file, so they can add inlining.

When the run-chromium-webkit-tests code was landed and the code was
refactored into the 'port' package, I accidentally broke using
http_server.py or websocket_server.py as command-line scripts
(the constructors needed a port object they weren't getting). This
change fixes them so that --server start|stop actually works.

As a part of this, the two files need to be able to call port.get(),
but doing that is awkward from a file inside the package, so I moved
get() into factory.py and imported that into init.py so that
http_server.py and websocket_server.py can just import factory.

Fix the function signature for check_sys_deps on the mac port, and
fix the ordering of port_obj.check_sys_deps() and
port_obj.start_helper() (helper needs to be started before we check
the system configuration).

For clients that want to show a user interface element when JavaScript
was blocked on a page, we need to disambiguate between querying the
client for whether JavaScript is enabled from actually failing to
execute some script.

This patch adds a new FrameLoaderClient callback for when WebCore would
like to execute JavaScript but fails to because JavaScript is disabled.

This patch also touches every client of canExecuteScripts so they can
indicate whether we should make this callback. I was hoping there was
a better choke point, but my first two attempts were wrong in subtle
ways. pkasting points out that this will be easy to screw up in the
future, so it's better to make all the clients be explicit.

Modifies the FocusController to check the frame's page's defersLoading() flag before firing blur/focus events.
This flag is set while a modal dialog (like a window.alert or window.confirm) is up. Firing the events causes
assertion failures, since when the dialog is dismissed the PageGroupLoadDeferrer assumes that no script has run.

Ensure that fragment parsing has no side effects on the fragment’s owner
document.

html/HTMLParser.cpp:

(WebCore::HTMLParser::insertNode): Don’t call
dispatchDocumentElementAvailable() for fragments.
(WebCore::HTMLParser::handleError): Don’t copy attributes to the owner
document’s <html> and <body> elements when a redundant <html> or <body>
is encountered while parsing a fragment.
(WebCore::HTMLParser::framesetCreateErrorCheck): Don’t change the owner
document’s <body> element’s style when parsing a fragment.
(WebCore::HTMLParser::createHead): Don’t attach the new <head> to the
ownder document of a fragment.

AppKit decided that it wanted to group all editing commands for some reason (and thus undo
reverted them all at once).

DumpRenderTree/mac/DumpRenderTree.mm:
(dump): Reverted the change that made DumpRenderTree use -[NSApplication run].
(runTest): Ditto.
(-[DumpRenderTreeApplication isRunning]): Override isRunning with a function that always
returns YES. This is another way to make the Java plug-in work.

compileGetDirectOffset modifies the contents of the object register
when the object is not using the inline storage array. As the object
register contains our 'this' pointer we can't allow it to be clobbered.
The fix is simply to copy the register into a separate scratch register
when we're loading off an object that doesn't use inline storage.

Stop doing contradictory things in updatePluginWidget (we were at
the same time pretending the geometry setting was delayed until
::paint and setting the geometry not once but twice) and just set
it any time the windowRect or clipRect for the plugin has changed.

This is closer to what the Mac port does, and fixes instances of
the plugins not being drawn until the window is resized or
scrolled. Other than that all manual and layout tests seems to
still work.

Implement getter lookup caching in the interpreter.
The getter stubs are generated through basically the
same code paths as the normal get_by_id caching.
Instead of simply loading a property and returning,
we load the getter slot, and pass the getter, base value
and return address to a shared stub used for getter
dispatch.

op_get_by_id_getter_chain was not passing the correct this parameter.
The bug was caused by incorrect use of baseCell instead of baseValue,
baseValue contains the original object for the lookup (and hence the
correct this object), baseCell is clobbered as part of walking the
prototype chain.

fast/dom/resources/TestApplet.java: Removed.
This test was added in a failing form, even though it never worked. The new tests cover
everything it was meant to cover.

java/SharedApplet.java: Added. This class will have methods for simple tests, but it's
also possible to just add new source files.

java/Makefile: Added. Compile all .java files in the directory.

java: Added.

java/argument-to-object-type-expected.txt: Added.

java/argument-to-object-type.html: Added.

java/array-return-expected.txt: Added.

java/array-return.html: Added.
Added tests for recently fixed bugs.

platform/gtk/Skipped:

platform/qt/Skipped:

platform/win/Skipped:
Java tests only work on Mac currently.

WebKitTools:

DumpRenderTree/mac/DumpRenderTree.mm:
(exitApplicationRunLoop):
(dump):
(runTest):
DumpRenderTree now runs an NSApplication, not just an event loop. This way, the Java plug-in
can start without freezing.

(WebCore::InspectorController::canAttachWindow): Use the minimum height for this calculation,

not the preferred height.

(WebCore::InspectorController::attachWindow): attachWindow() shouldn't decide the policy, as it is

often called partway through the show or dock procedure after some of the initial conditions have
changed. Let the front-end itself and the InspectorClient's make the policy decision at the start
of the show/dock operation.

inspector/InspectorFrontendHost.cpp:

(WebCore::InspectorFrontendHost::canAttachWindow):

inspector/InspectorFrontendHost.h:

inspector/InspectorFrontendHost.idl:

inspector/front-end/inspector.js:

(WebInspector.toggleAttach): Before attaching, ask the front-end-host if attaching is allowed.

WebKit/mac:

WebCoreSupport/WebInspectorClient.mm:

(-[WebInspectorWindowController showWindow:]): Swap the order of the "should attach?" check

to get the expected behavior.

WebKit/win:

WebCoreSupport/WebInspectorClient.cpp:

(WebInspectorClient::showWindowWithoutNotifications): Swap the order of the "should attach?" check

to get the expected behavior.

LayoutTests:

inspector/timeline-event-dispatch.html: Actually click in the right place now that the
inspector isn't docked anymore.

CGImageSourceGetStatusAtIndex claims that all frames of a multi-frame image are incomplete when we've not yet received the
complete data for an image that is using an incremental data source (<rdar://problem/7679174>). We work around this by
special-casing all frames except the last in an image and treating them as complete if they are present and reported as
being incomplete. We do this on the assumption that loading new data can only modify the existing last frame or append new
frames. The last frame is only treated as being complete if the image source reports it as such. This ensures that it is
truly the last frame of the image rather than just the last that we currently have data for.

(WebCore::HTMLElement::createContextualFragment): Modified to perform only checks
that are specific for an HTMLElement object. The rest of the logic has been moved to the
corresponding method in the Element class.

NSClipView offsets any rects marked as needing display during scrolling
by the scroll offset. Compensate for this when -setNeedsDisplay: is called
during scrolling.

WebView/WebHTMLView.mm:

(-[WebHTMLView _frameOrBoundsChanged]): Set inScrollPositionChanged to YES
around to call to FrameView::scrollPositionChanged().
(-[WebHTMLView setNeedsDisplayInRect:]): When called beneath
scrollPositionChanged(), adjust the rect by the inverse of the scroll offset.

The previous patch to this file was broken (sorry). First of all,
the conversion from UTF8 was accidentally removed. Second, for
empty strings, we need to point the implementation at StringImpl::empty().

The co-ordinates attached to a touch event are not used for tracking touch motion, rather the co-ordinates attached to Touches within the touch event should be used. Set the co-ordinates on the event itself to 0 to avoid confusion and match observed iPhone behavior.

page/EventHandler.cpp:
(WebCore::EventHandler::handleTouchEvent): Set the pageX/Y and screenX/Y co-ordinates attached to the touch event to 0,0 to match observed behavior on the iPhone.

page/EventHandler.h: Remove now unused members m_firstTouchScreenPos and m_firstTouchPagePos.

Fixed backspace keycode.
Fixed using the appropriate fields from the Haiku event for mapping
to the VK_* codes and added mapping a great deal more codes.
Added extraction of modifier key flags.
Completed implementation of disambiguateKeyDownEvent()
Implemented currentCapsLockState().

This change will enable about 30 test cases to pass in Chromium.
All of these test cases are related to selection rect boundaries.
This change will enable the test cases to retrieve the selection
rect boundary rectangle for the current selection.

MediaControlPrivate and GraphicsLayer are patched together via
a shared PlatformLayer (QGraphicsItem). This patch makes sure that the
QGraphicsVideoItem from MediaControl becomes part of the scene
associsated with GraphicsLayer

Prompts a person for their SVN username if not already cached (by Subversion).

Currently, webkit-patch is unable to commit to the SVN repo. unless the
WebKit SVN username is already cached (from of a prior commit by hand)
because "svn commit" (called by webkit-patch) defaults to using the system
login name unless the username is already cached or specified on the
command line.

FrameView::resize will already queue a layout, so there's no need
to force one ourselves. On top of that, the layout function
already adjusts the view size when needed, so there's no need to
do that manually either. No change in the layout tests or unit
tests after this.

The implementation is currently very simple: Added a PopupMenuHaiku
class that derives from a native BPopUpMenu. It attaches a BHandler
derivative to the BApplication (WebCore main thread) which receives
the item invokation and menu hidden events and informs the PopupMenuClient
accordingly.

html/HTMLObjectElement.idl:
These objects no longer need overriding name getters, as they no longer intercept the
apple_runtime_object property.

bindings/js/JSPluginElementFunctions.cpp:
(WebCore::pluginInstance): This is no longer static. It was used for callPlugin() in
this file, and now it's also used elsewhere when calling plug-in methods.
(WebCore::runtimeObjectGetter): Removed. This function was only used by the intercepting
name getters.

bridge/runtime_method.cpp:
(JSC::callRuntimeMethod):
Take plug-in element's instance directly, without relying on fake attribute lookup.
One change resulting from this is that RuntimeObjectImp may not be created in some cases -
this code only needs an instance, but the old code had to pass the instance wrapped into
RuntimeObjectImp.

The test was verifying two things: first, that U+FFFD is rendered by the browser, and second,
that ill-formed UTF-8 sequences are turned into U+FFFD. Some aspects of the latter are not
precisely defined by the Unicode specification, so different platforms may legitimately
have different results.

Split the test into two: one to test the rendering of invalid UTF-8 sequences, and the other
to protect against regressions in each platform's decoding behaviour.

[V8] Streamline V8 event listener code. Merge all the variants of
V8DOMWrapper::getEventListner() into a single version and generate
addEventListener() and removeEventListener() bindings for all objects
except DOMWindow.

Remove RenderLayer's addScrolledContentOffset() and subtractScrolledContentOffset()
methods, and instead use the existing scrolledContentOffset(), and use
IntSize and IntPoint instead of lots of x, y variables.

Added new IntPoint toPoint(const IntSize&) method as a convenience to convert a size to a point,
which is needed in a few places.

page/EventHandler.cpp:
(WebCore::EventHandler::handleDrag): Use the new toPoint() convenience.

platform/graphics/IntPoint.h:
(WebCore::toPoint): New convenience method to convert an IntSize to an IntPoint.

fontconfig on Linux can change the render preferences on a per strike
basis (a strike a combination of face and size). Because of this, we
need to query fontconfig each time a new FontPlatformData is created
for a new size.

There's a risk of reseting a valid assignee for example when
triaging a bug. All components in WebKit have the default
assignee set to ​webkit-unassigned@webkit.org so this should
not cause problems for people relying on this functionality.

bindings/js/JSNodeCustom.h: Added.
(WebCore::getCachedDOMNodeWrapper): Moved here so it can be inlined.
(WebCore::toJS): Moved here so it can be inlined.

bindings/js/ScriptWrappable.h:
(WebCore::ScriptWrappable::ScriptWrappable): Implement this in the obvious
way for JavaScriptCore.
(WebCore::ScriptWrappable::wrapper):
(WebCore::ScriptWrappable::setWrapper):
(WebCore::ScriptWrappable::clearWrapper):

bindings/scripts/CodeGeneratorJS.pm: Include CustomHeader heaaders
in the header, not just the impl file, so they can add inlining.

InspectorController now binds sourceID to url and maintains a map of 'sticky'
breakpoints. Whenever script is loaded and there is a sticky breakpoint url matching,
breakpoint is being 'restored' synchronously in debug server and pushed to frontend.
Front-end no longer stores map of sticky breakpoints.

When page-break-{after,before} is set to always, force page breaks even for overflow-specified elements.
RenderBlock::inRootBlockContext() was introduced by Changeset 5611. Although it is a reasonable criteria for choosing an optional page break location, it is not for a mandatory page break as specified by ​http://dev.w3.org/csswg/css3-page/#forced-pg-brk. The method is removed because it is not used anywhere else.
Note: this patch makes page break work for overflow-specified elements. For tables and floated elements, more work is needed.​https://bugs.webkit.org/show_bug.cgi?id=9526

When page-break-{after,before} is set to always, force page breaks even for overflow-specified elements.
RenderBlock::inRootBlockContext() was introduced by Changeset 5611. Although it is a reasonable criteria for choosing an optional page break location, it is not for a mandatory page break as specified by ​http://dev.w3.org/csswg/css3-page/#forced-pg-brk. The method is removed because it is not used anywhere else.
Note: this patch makes page break work for overflow-specified elements. For tables and floated elements, more work is needed.​https://bugs.webkit.org/show_bug.cgi?id=9526

RenderLayer::updateLayerPositions() computes the clipped overflow rect
and the outline bounds for repaint, and then calls repaintAfterLayoutIfNeeded()
which can compute the same rects all over again. Avoid this by passing
these two rects into repaintAfterLayoutIfNeeded() if known. This measurably
reduces the time spent in updateLayerPositions() for some content.

(-[WebHTMLView _recursiveDisplayRectIfNeededIgnoringOpacity:isVisibleRect:rectIsVisibleRectForView:topView:]):
Suppress the warning and the forced layout if the view is not being drawn
in this display operation.

The plugInViewWithArguments: API passes a dictionary of plugin arguments. One of the parameters
is WebPlugInBaseURLKey, which is a key that represents the base URL of the document containing
the plug-in's view. Instead of sending the base URL, code in WebFrameLoaderClient::createPlugin
would incorrectly pass the source URL of the plug-in resource.

WebCoreSupport/WebFrameLoaderClient.mm:
(WebFrameLoaderClient::createPlugin): When building the plug-in arguments dictionary, pass the
real base URL for the WebPlugInBaseURLKey key.

I made ENABLE(SANDBOX) only control the sandbox attribute itself;
I did not ifdef the infrastructure to make sandboxing
switchable. This is because the likely concerns about sandboxing
are not stability of the infrastructure code, but rather the fact
that the security model exposed to authors is still evolving.

bridge/jni/jsc/JavaInstanceJSC.cpp: (JavaInstance::invokeMethod): Do handle returned arrays.
Also, added an ifdef around code that's only needed on Tiger, and removed a comment saying
it can be removed when "new" plugin ships. I doubt that anyone can remember what "new"
could refer to back then.