In the default verbose mode, we now print information about variable
state at the bottom of basic blocks in addition to the top, and we
also print local variable linking. In the verbose propagation mode,
the state of phi processing is dumped more richly and CFA merging (the
most subtle part of CFA) is traced as well.

It turns out that we were corrupting phi nodes in case of overflow. The bug is
really obvious, but producing a test case that causes the badness is hard. Even
when the phi nodes do get corrupt, there's more that has to happen before it
causes incorrect execution - and I wasn't able to reproduce in any kind of
sensible reduced case.

Setting the tile size or tiling option after the tiler is created invalidates it, and by default the newly
created tiler will have border texels so the test doesn't pass. Switch things around in the test so the tiler
is created only after all the options are set, which is closer to what the real code does.

Support multi-author change log entries in ChangeLogEntry. Split author names using
the same logic as splitting reviewer names. _authors now stores list of dictionaries
with "name" and "email" as keys. Unlike reviewers, we can't always resolve authors to
accounts because some contributors are never listed in committers.py.

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

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

Scripts/webkitpy/common/config/committers.py: Fixed a bug that *_by_{name|email}

If a tile has invalidations at pushPropertiesTo, then we know the contents of that tile are no longer valid even
if they still have valid backing textures. This avoids pushing that texture to the impl side so it is not
displayed to the user. The texture is still kept around (managed by the TextureManager) so that when we later do
decide to update the contents for that tile we can use partial results if they are still valid.

Target.pri: Make BUILDING_JavaScriptCore available earlier, so it can be

used by the build system.

Source/WebCore:

Target.pri: Make BUILDING_WebCore available earlier, so it can be

used by the build system.

Source/WebKit2:

Target.pri: Make BUILDING_WebKit2 available, so it can be

used by the build system.

Tools:

Introduce a special type of build that replaces the static jsc/wc/wk2
static libraries with shared libraries, that individually are much faster
to link and don't require relinking into the big library when changing just
one file in one module. It can be enabled with
--qmakearg="CONFIG+=force_static_libs_as_shared"

qmake/mkspecs/features/force_static_libs_as_shared.prf: Added. With this configuration,

disable symbol visibility, static linkage and enable rpath.

qmake/mkspecs/features/functions.prf: Add a helper function to determine if

we need to link the convenience libraries together or not and renamed linkStaticLibrary
to just linkLibrary (because linkage is not necessarily static).

qmake/mkspecs/features/qtwebkit.prf: When using the trick, make sure to also

(WebCore::inlineFlowRequiresLineBox): In strict mode, add a LineBox for an empty element if it is
going to affect the line-height.
(WebCore::requiresLineBox): Pass LineInfo to inlineFlowRequiresLineBox
(WebCore::RenderBlock::LineBreaker::nextLineBreak): Pass LineInfo to inlineFlowRequiresLineBox

LayoutTests:

css2.1/20110323/empty-inline-001.htm: Added.

css2.1/20110323/empty-inline-002.htm: Added.

css2.1/20110323/empty-inline-003.htm: Added.

fast/css/empty-inline-003-quirksmode-expected.png: Result can
cover all platforms as there is no text apart from the period.

fast/css/empty-inline-003-quirksmode-expected.txt: ditto

fast/css/empty-inline-003-quirksmode.htm: empty-inline-003.htm should only pass in
strict mode, this ensures it 'fails' in quirks mode.

These asserts are incorrect, because it's valid for the default render
surface to be created but to have a root layer that doesn't draw. It
won't get added to the single render surface and it'll have an empty
layer list.

Currently, all the accelerated compositing animations are applied in WebProcess and
for each frame generated, WebProcess needs to sync with UIProcess.

This patch moves the accelerated compositing animations to UIProcess reducing the
amount of synchronization messages between WebProcess and UIProcess, this is done
sending animations information to UIProcess.

(WTF::ParallelEnvironment::ParallelEnvironment):
(WTF::ParallelEnvironment::execute):
Deinline these to avoid exporting a lot of symbols.
These are non-trivial and called only once on a given object
so it doesn't seems to be worthwile to inline them.
Additionally fix a signed-unsigned comparison in the constructor.

wtf/ParallelJobsGeneric.h:

wtf/Platform.h:

Source/WebCore:

Covered by existing tests.

According to measurements on Mac and Linux it is a
considerable speedup for SVG on multicore.

Remove the ENABLE(PARALLEL_JOBS) guard. Fix the Windows build
by qualifying ParallelJobs with the WTF namespace (otherwise
MSVC believes it belongs to WebCore which is likely a compiler bug).

When creating new dialogs, fill their WebView.view attached property
with the WebView that's creating them. This follows the same pattern
as QtQuick's ListView, enabling the usage of the same dialog component
for different WebViews.

Both: inspector protocol and WebCore/InspectorController have a number of unnecessary
methods for plumbing the menu action handlers through the WebKit and WebCore.
I intend to remove this menu support from the protocol and WebCore/InspectorController API.
I am starting with exposing the new front-end API in the WebCore and using it in the WebKit/mac port.
WebKit/win and WebKit2 to follow.

Both: inspector protocol and WebCore/InspectorController have a number of unnecessary
methods for plumbing the menu action handlers through the WebKit and WebCore.
I intend to remove this menu support from the protocol and WebCore/InspectorController API.
I am starting with exposing the new front-end API in the WebCore and using it in the WebKit/mac port.
WebKit/win and WebKit2 to follow.

Both: inspector protocol and WebCore/InspectorController have a number of unnecessary
methods for plumbing the menu action handlers through the WebKit and WebCore.
I intend to remove this menu support from the protocol and WebCore/InspectorController API.
I am starting with exposing the new front-end API in the WebCore and using it in the WebKit/mac port.
WebKit/win and WebKit2 to follow.

DFG code blocks now participate in the weak reference harvester fixpoint
so that they only consider themselves to be live if either they are
currently executing, or their owner is live and all of their weak references
are live. If not, the relevant code blocks are jettisoned.

Inline caches in both the old JIT and the DFG are now cleared if any of
their references are not marked at the end of a GC.

This is performance-neutral on SunSpider, V8, and Kraken. With the clear-
all-code-on-GC policy that we currently have, it shows a slight reduction
in memory usage. If we turn that policy off, it's pretty easy to come up
with an example program that will cause ToT to experience linear heap
growth, while with this patch, the heap stays small and remains at a
constant size.

This patch removes a (minor) security mitigation. Previously, we tried
sequester "directory listings" into unique origins to make it more
difficult for an attacker to crawl the user's local file system.
Unfortunately, this mitigation doesn't really buy us much security
because if the attacker has access to local files, we've probably lost
anyway.

The larger problem, however, is that this condition is overly
complicated and has broken in sublte ways several times in its
(relatively short) lifetime. In the cases reported in this bug, we see
that this check affects error pages in Safari and Growl notifications,
even those have nothing to do with directory listings.

If we have our heart set on this directory listing mitigation, we'll
need a more robust way of triggering the behavior than examining URLs
and guess whether they contain directory listings. For example, if we
implement Allow-From or Access-Control-Deny-Origin, then the embedder
can supply those policies along with the directory listings. Those
seem like much better solutions than the in-engine hack this patch
removes.

page/SecurityOrigin.cpp:

(WebCore::shouldTreatAsUniqueOrigin):

LayoutTests:

Update test results to show that XMLHttpRequets for directory listings
aren't blocked.

Most of the port specific implementations of EditorClient::respondToChangedSelection
(like EditorClient{Qt,Gtk,etc}) are wrongly relying on FocusController::focusedOrMainFrame
method to get the Frame where the selection is happening on.

It is not right, since a selection can be easily triggered in an inner
frame that is not focused.

No new tests since it is a hard thing to test without
to hook into editor client in layout tests. We could
change the "Dumped Delegate" messages, but it would
require a rebasile of +1200 for a minor change.

No new tests since it is a hard thing to test without
to hook into editor client in layout tests. We could
change the "Dumped Delegate" messages, but it would
require a rebasile of +1200 for a minor change.

Source/WebCore:

editing/Editor.cpp: Pass the Frame on where the selection is changing to the client.
(WebCore::Editor::respondToChangedSelection): Ditto.
(WebCore::Editor::changeSelectionAfterCommand): Ditto.
(WebCore::EmptyEditorClient::respondToChangedSelection):

page/EditorClient.h: Pass Frame* to indicate where the selection is happening.

loader/EmptyClients.h: Changed signature as per base class change.

Source/WebKit/chromium:

src/EditorClientImpl.cpp: Make use of the newly added Frame* parameter.
(WebKit::EditorClientImpl::respondToChangedSelection):

src/EditorClientImpl.h:

Source/WebKit/efl:

WebCoreSupport/EditorClientEfl.cpp: Make use of the newly added Frame* parameter.
(WebCore::EditorClientEfl::respondToChangedSelection):

WebCoreSupport/EditorClientEfl.h:

Source/WebKit/gtk:

WebCoreSupport/EditorClientGtk.cpp: Make use of the newly added Frame* parameter.
(WebKit::EditorClient::respondToChangedSelection):

WebCoreSupport/EditorClientGtk.h:

Source/WebKit/mac:

WebCoreSupport/WebEditorClient.h: Make use of the newly added Frame* parameter.

I'm moving the server to storing and serving up raw json instead of jsonp.
You can still get the jsonp by passing a "callback" parameter, but there's no
need for run-webkit-tests to get jsonp when all it wants is the raw json.

This adds an Xcode project that includes only Stub.cpp and Stub.h.
They’re built in to a library at the appropriate path for each
configuration (WebKitBuild/{Debug,Release}/libWTF.a and
/usr/local/lib/libWTF.a) and headers are installed in to the
appropriate location (WebKitBuild/{Debug,Release}/usr/local/include/wtf
and /usr/local/include/wtf). I tested building WTF in this project and
everything appears to build except for DateMath.cpp (due to bug 71747).
I have not yet done any work on making JavaScriptCore and other
projects use the built products of this new project.

Add a interface to send raw binary data.
This interface is used by WebWebSocketChannel implementation
in WebKit API.

No new tests because just export a interface.

websockets/WebSocketChannel.cpp:

(WebCore::WebSocketChannel::send):

websockets/WebSocketChannel.h:

Source/WebKit/chromium:

Add WebSocket and WebSocketClient to WebKit API.

Currently, only WebSocketStreamHandle class is exported to WebKit API.
WebSocketStreamHandle implements bi-directional communication ports.
If plugins handles the WebSocket protocol, WebSocketChannel and
WebSocketChannelClient must be exported as WebSocket because they are
the classes which implement the WebSocket protocol stack.

Normally, we use WebWebSocketChannel and WebWebSocketChannelClient as
their class names. But here we use just WebSocket and WebSocketClient
because of avoiding WebWeb prefix and class name confliction on
header include.

Currently, all the accelerated compositing animations are applied in WebProcess and
for each frame generated, WebProcess needs to sync with UIProcess.

This patch moves the accelerated compositing animations to UIProcess reducing the
amount of synchronization messages between WebProcess and UIProcess, this is done
sending animations information to UIProcess.

IDL changes and associated plumbing to expose list of gamepad objects
on navigator object (per current spec). Full patch is​https://bugs.webkit.org/show_bug.cgi?id=69451. Only basic existence
test until more plumbing in future patches.

InstanceOf already leverages the fact that we only allow the default
hasInstance implementation. So, if the base is predicted to possibly
be not an object and the CFA has not yet proven otherwise, InstanceOf
will abstain from speculating cell and instead return false if the
base is not a cell.

This appears to be a 1% speed-up on V8 on the V8 harness. 3-4% or so
speed-up in earley-boyer. Neutral according to bencher on SunSpider,
V8, and Kraken. In 32-bit, it's a 0.5% win on SunSpider and a 1.9%
win on V8 even on my harness, due to a 12.5% win on earley-boyer.

I also took this opportunity to make the code for InstanceOf common
between the two JITs. This was partially successful, in that the
"common code" has a bunch of #if's, but overall it seems like a code
size reduction.

This new ChromeClient function is called when the recommended scrollbar style
changes. This way, WebKit can respond to the change by adjusting its mouse
tracking.

page/ChromeClient.h:

(WebCore::ChromeClient::recommendedScrollbarStyleDidChange):

Existing ScrollableArea function scrollbarStyleChanged() now takes an int
indicating the new scrollbar style and a bool indicating whether it is necessary
to force an update. It used to be the case that this function was ONLY used to
force an update (and only called when an updated was needed), but now that it must
also call into the ChromeClient, it is necessary to include a bool tracking
whether we need to force an update. New implementation on FrameView is responsible
for calling ChromeClient, and then that calls into the pre-existing ScrollView
function for the forceUpdate part.

page/FrameView.cpp:

(WebCore::FrameView::scrollbarStyleChanged):

page/FrameView.h:

platform/ScrollView.cpp:

(WebCore::ScrollView:: scrollbarStyleChanged):

platform/ScrollView.h:

platform/ScrollableArea.h:

(WebCore::ScrollableArea::scrollbarStyleChanged):

platform/mac/ScrollAnimatorMac.mm:

(WebCore::ScrollAnimatorMac::updateScrollerStyle):

Source/WebKit2:

These new functions take care of passing along the
recommendedScrollbarStyleDidChange() message that originates in the ChromeClient.

UIProcess/API/mac/PageClientImpl.h:

UIProcess/PageClient.h:

UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::recommendedScrollbarStyleDidChange):

UIProcess/WebPageProxy.h:

UIProcess/WebPageProxy.messages.in:

WebProcess/WebCoreSupport/WebChromeClient.cpp:

(WebKit::WebChromeClient::recommendedScrollbarStyleDidChange):

WebProcess/WebCoreSupport/WebChromeClient.h:

This is where we actually respond to the recommendedScrollbarStyleDidChange
message. We remove the existing tracking area and create a new tracking area with
the appropriate tracking options.

UIProcess/API/mac/PageClientImpl.mm:

(WebKit::PageClientImpl::recommendedScrollbarStyleDidChange):

BuiltInPDFView inherits from WebCore::ScrollableArea, so scrollbarStyleChanged()
must now take two parameters like the one in ScrollableArea.

Move fullscreen entry points from WebView to WebWidget since they are
just about widget geometry.

Delay webkitfullscreenchange event until we know that we have entered
fullscreen mode. This is accomplished by expanding the WebKit APIs to
differentiate will{Enter,Exit} from did{Enter,Exit} state changes.

WebViewImpl is forced to keep a reference to the requested fullscreen
element while we are requesting to enter fullscreen mode. Once in
fullscreen mode, we switch to keeping only a reference to the Frame
containing the fullscreen element, which we drop upon exiting
fullscreen mode.

The existing test fast/dom/rtl-scroll-to-leftmost-and-resize.html seems does not really work in Mac DRT
(the browswer window is not resized). It works in Chromium-Mac. And Chromium-Mac's code
is forked from Mac.

platform/chromium/ScrollAnimatorChromiumMac.mm:

(WebCore::ScrollAnimatorChromiumMac::immediateScrollToPoint):

platform/mac/ScrollAnimatorMac.mm:

(WebCore::ScrollAnimatorMac::immediateScrollToPoint):

LayoutTests:

The test still marks as FAIL in test_expectations because cg-mac might need rebase.

Fixing a merge issue. On TOT we use #if USE(SCROLLBAR_PAINTER), but on the branch
it is still #if USE(WK_SCROLLBAR_PAINTER). Also, on the branch, all of the
m_scrollbarPainterController functions go through WebKitSystemInterface instead of
using forward declaration. We should consider merging those changes, but in the
meantime, for this to work, we have to go back to the branch-style.

GraphicsLayerCA contains a "linked on or after" check to account for a bug in
Core Animation on SnowLeopard and earlier, which is that CA would apply the list
of animations in reverse order.

Our previous fix was incorrect, because it only adjusted the 'additive' property
of the animation list based on ordering, rather than flipping the entire list.
This change reverses the list of animations before giving them to CA, which fixes
the bug.

Moved code to get the global object for a code origin into CodeBlock, so it is
more broadly accessible. Fixed CSE to compare both the variable number, and the
global object, before deciding to perform elimination.

We need to be careful about how we look for the baseline CodeBlock if we're lazy-compiling
an OSR exit after our CodeBlock has been jettisoned. In short, use CodeBlock::baselineVersion()
instead of CodeBlock::alternative().

No performance effect.

No tests because all of our heuristics work very hard to make sure that this never happens in
the first place. OSR exits are rare by design, and jettisoning of CodeBlocks (i.e. recompilation)
is even rarer. Furthermore, OSR exits after a CodeBlock has been jettisoned is rarer still
because the whole point of jettisoning is to bring the probability of future OSR exits to as
close to zero as possible. But even that isn't enough to trigger this bug; it requires the OSR
exit after a jettison to be the first of its kind; our whole design tries to ensure that
CodeBlocks tend to OSR exit at a handful (i.e. 1 in most cases) of points, and since jettisoning
is triggered by OSR, in most sane cases the OSR exits after jettison will not require lazy OSR
compilation. So this is a truly evil case, and any test for it would be quite fragile.

<rdar://problem/10424154> testRegExp should not be installed as part of JavaScriptCore

testRegExp and testapi.js were being installed in the JavaScriptCore framework.
As test-only tools they shouldn't be installed there by default, only when
FORCE_TOOL_INSTALL is set to YES.

This patch incorprorates a few related changes:
1) Make the jsc and testRegExp targets be configured via .xcconfig files.
2) Sets up testRegExp so that SKIP_INSTALL is YES by default, and only NO when

FORCE_TOOL_INSTALL is YES.

3) Switches the testapi target to using a script build phase to install testapi.js

so that the installation will be skipped when SKIP_INSTALL is YES. I'm not sure
why this isn't the built-in behavior when a Copy Files build phase has "Copy only
when installing" checked, but it doesn't seem to be.

4) Other random cleanup such as removing a bogus group that refers to files that do

WebChromeClient::shouldInterruptJavaScript called CallUIDelegate, which used an id
as the return value, which was then cast to a bool and always returned true. This
patch uses CallUIDelegateReturningBoolean instead of CallUIDelegate, with the default
return value of NO.

Ensure that the GAIL module is being loaded by avoiding using
gtk_test_init() directly, but a modified version of it.

tests/testatk.c:

(testWebkitAtkParentForRootObject): Use a normal GtkWidget (a
GtkWindow) as the parent container for the webView, instead of
using a dummy webView for that, which was hackish.
(testWebkitAtkSetParentForObject): Use normal GtkWidgets instead
of dummy webViews (a GtkWindow and a GtkButton).
(initializeTestingFramework): New function, identical to
gtk_test_init(), but loading GAIL as the only GTK module.
(main): Use initializeTestingFramework().

TextureMapperNode::computeAllTransforms already has a call to TextureMapperNode::computePerspectiveTransformIfNeeded,
so it does not need to be called again after TextureMapperNode::computeAllTransforms.

Adds alertDialog, confirmDialog and promptDialog properties to QQuickWebView's
privateObject. These are QML components that are created by the webview when the
corresponding function is called in JS.

The dialogs are created in a context that contains a model object, similar to
ListView delegates. The "message" and "defaultValue" parameters are available
in the model object, as well as slots expected to be called by the dialog.

This commit removes the old code for supporting QWidget builtin dialogs. The code
wasn't working properly (closing any dialog was closing the app after QWindow
refactoring in Qt5).

The cause is a null dereference of a fontData that is stored in
ComplexTextRun. The fontData is initialized by using the
fontCache, but it could be null when the font is in fallback
list. The reason a font from the fallback list might not be in the
font Cache is that it may be a web font. Before looking up the
fontCache, try to see whether the font is in the fallback list.

The keyIdentifierForEvasKeyName() and windowsKeyCodeForEvasKeyName() were static functions
in the PlatformKeyboardEventEfl.cpp. But they are also needed in the WebKit2 EFL port, so I
moved them to the separated file - EflKeyboardUtilities.cpp.

With the JS recursion level stored as a member of V8Proxy, it's tied
to a frame. But this is incorrect, as there's no reason that a JS call
stack need be restricted to a single frame (see my new test case for
an example of code going across frames).

In order to get the correct accounting of JS recursion level, per-Isolate
is the right granularity (per dslomov), which is what this patch accomplishes.

This patch removes the forceUnique flag from SecurityOrigin::create.
Now, we create unique origins without passing in the document's URL,
preventing information from the document's URL from leaking into the
unique origin.

Since we don't currently support atomic incremental uploads, incremental uploads in the threaded path result in
very strange-looking texture popping as tiles come in on pages that require more than 16 tile uploads per frame.
This disables that logic (by setting the upload limit per frame to 99999) until we handle the incremental
updates in an atomic fashion.

Layer property changes during paintContent() can leave the layer
in an invalid state as paintContentsIfDirty() has been called
without a matching updateCompositorResources() call. Removing
conditionals around these calls ensure they are balanced.

First time when we change opacity for parent we don't have layer, so
diff=StyleDifferenceRepaint is used instead of diff=StyleDifferenceRepaintLayer.
Layer is created later, in styleDidChange().
So, when we recalculate later diff, we now check for diff=StyleDifferenceRepaintLayer and
performs repaintIncludingDescendants().

Over time, the SecurityOrigin constructor has grown a bit out of
control. This patch attempts to separate the different concerns into
free functions. The general approach is to put more logic in the
"create" function and introduce a simple constructor for unique
origins.

Re-enable ref tests. Run the driver under evenly numbered display if performing
pixel tests or under oddly numbered display otherwise. This prevents the ref tests
being run in an already used Xvfb instance if pixel tests are disabled.

Modified handling of run-in children to clear generated children
before removing the parent from the render tree. This caused problems
with absolute positioned children being not properly removed from the
positioned object list of the RenderView.

1) In accessibilityAttributeValue: when an element did not have a renderer() we were returning earlier than we should have
2) We were not updating and clearing the scrollbars correctly when children were cleared or when asked for.

This patch contains the bulk (all?) of the behavior differences in this
patch series. Unique origins shouldn't remember their schemes. Doing
so causes some privileges (e.g., local access) to leak into unique
origins.

page/SecurityOrigin.cpp:

(WebCore::SecurityOrigin::SecurityOrigin):

Explicitly clear out the protocol, host, and port for unique
origins. A future patch will refactor all this code to be more
elegant.

platform/SchemeRegistry.cpp:

(WebCore::schemesWithUniqueOrigins):

Merge "about" and "javascript" in with the general case now that
we don't have a separate notion of an empty origin.

LayoutTests:

fast/frames/resources/sandboxed-iframe-storage-disallowed.html:

Inline script because the sandbox iframe isn't allowed to load
local resources.

fast/frames/sandboxed-iframe-attribute-parsing.html:

fast/frames/sandboxed-iframe-forms-dynamic.html:

fast/frames/sandboxed-iframe-forms.html:

fast/frames/sandboxed-iframe-navigation-top-by-constant-name.html:

fast/frames/sandboxed-iframe-navigation-top-by-constant-name2.html:

fast/frames/sandboxed-iframe-navigation-top-by-name.html:

fast/frames/sandboxed-iframe-navigation-top.html:

media/video-controls-no-scripting.html:

Previously sandboxed local iframes still got universal access
when we're running with universal access for file URLs! Now that
they correctly get unique origins, we need to update these tests
to allow-same-origin access in order for them to function
properly.

After r97555, we would include the borders in a CSS table's logical width even if the 'width'
property was a percent. This does not match what Firefox and IE are doing. Thus don't apply
this behavior to percent 'width'.

rendering/RenderTable.cpp:

(WebCore::RenderTable::computeLogicalWidth):

LayoutTests:

Several tests to check that we don't overflow our containing block with width: 100%.

Removed QWebElement and QtDRTNode usage that reached from WebCore into
WebKit/qt and replaced it with the ability to register custom JSValue
conversion functions. The old code has been moved to WebKit/qt.

WebKit wasn't displaying the top block in these tests because it did not paint the outline
of divs with zero size.

rendering/RenderObject.cpp:

(WebCore::RenderObject::paintOutline): paint the outline even when the block has zero size

LayoutTests:

Add tests covering dynamic outlines. At first glance the result
for outline-color-174.htm looks like it might be wrong but it's
really the statement at the top of the test that's misleading,
only the outline should be black not the entire box.

(write_test_result): Simplified a little to share more code between the case where we
crashed when running the test and where we crashed when checking the expected rendering for
a reftest. Changed to pass the crashed process name down to write_crash_report.
(TestResultWriter.write_crash_report): Added crashed_process_name parameter, which we pass
along to CrashLogs.find_newest_log rather than always using the driver name.

Scripts/webkitpy/layout_tests/port/chromium.py:

(ChromiumDriver.run_test): Pass the driver name as the name of the crashed process if we
crashed.

Scripts/webkitpy/layout_tests/port/test.py:

(TestInstance.init): Initialize new web_process_crash attribute.
(unit_test_list): Added new web-process-crash-with-stderr test, which is used by the new
test this patch adds.
(TestDriver.run_test): Pass a crashed process name to DriverOutput based on whether the test
specifies that the driver crashed or the web process crashed.

Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:

(MainTest.test_web_process_crash_log): Added. Similar to test_crash_log, but uses a test for
which we pretend the web process crashed rather than the driver process.

(LeakDetector._leaks_args): Removed extra quoting of call stacks and types. Quoting is only
required when passing arguments via the shell (which we aren't doing here). It is not
required by Perl's option-parsing code (as the comment I removed mistakenly claimed).

When adding a child to a table that has generated content, this change
ensures that we leave alone any generated content renderers that belong
to descendants in the tree. They don't need to be touched, and doing so
can create confusion about who the content belongs to.

This patch also simplifies some existing code for finding pseudoelement
renderers.

(resourceNameForWebGraphic): Helper function to translate between public API enums and
resource names.
(QWebSettings::setWebGraphic): Call the new ImageQt::setPlatformResource setter.
(QWebSettings::webGraphic): Call Image::loadPlatformResource to read from the cache
in WebCore.

Rebaselined missing-values-first-keyframe.html,
missing-values-last-keyframe.html and opacity-transform-animation.html.
Looks like these weren't quite right after​http://trac.webkit.org/changeset/100520.

[Qt] Move WebKit2 C++ APIs to private API and build QML extension plugin on top of that

A new extension object has been added to QQuickWebView (the same approach should be used
for other API classes that need experimental APIs). The QML extension mechanism is then
built on top of the experimental object.

Adds a new API for getting font family. For now, FontCacheLinux calls the new API, but don't use additional properties for compatibility. The old API will be removed when Chromium is ready to use new API.

Reviewed by Tony Chang.

No new tests. No behavior changes for now.

platform/chromium/PlatformSupport.h: Added FontFamily struct and changed the declaration of getFontFamilyForCharacters().

(webkit_accessible_get_parent): Call to the implementation of
atk_object_get_parent in AtkObject class to check whether a parent
AtkObject has been previously set, before trying to find one.

Source/WebKit/gtk:

tests/testatk.c:

(testWebkitAtkSetParentForObject): New unit test to check that
calls to atk_object_get_parent() over a WebKitGTK's accessibility
wrapper object returns its parent AtkObject if previously set.
(main): Added new test.

(testWebkitAtkParentForRootObject): Remove the offending line in
the unit test, which is not actually required to test the new
functionality and causes problems in some scenarios, due to the
lazy creation mechanism of AtkObjects.

tests/testatkroles.c:

(finish_loading): Reflect that the document frame object is no
longer the root accessibility object (a scroll pane from now on),
but the only child of that one. Thus, skip that root object.

(WebCore::AudioDestinationMac::AudioDestinationMac): Switch from using the Carbon Component Manager
to using AudioUnit's own component interface.
(WebCore::AudioDestinationMac::~AudioDestinationMac): Ditto.

platform/audio/mac/AudioFileReaderMac.cpp:

(WebCore::AudioFileReader::AudioFileReader): Remove an unncessary trip through the Carbon File Manager
when converting a char* path to a CFURLRef representing the same.

Many of the Preferences that we have in Settings.js and override in DevTools.js
are really not preferences, but capabilities. Protocol clients should have a way
of figuring out whether some capability is present before using it.