SpellChecker uses TextCheckerClient, which belongs Page object,
which is possibly destroyed during SpellChecker's lifetime.
This change added to a guard before using TextCheckerClient to
ensure it being live.

This refactors the way LayerRendererChromium calls setLayerRenderer on its layers in a few ways to clean things
up:

*) Move the pre-paint call to setLayerRenderer from updatePropertiesAndRenderSurfaces() to paintLayerContents().

updatePropertiesAndRenderSurfaces() does too much and the layer renderer pointer only has to be up to date to do
the actual paint. Longer term we won't need to call this at all in order to call paint and this call will just
go away.

*) Tweaks updateCompositorResourcesRecursive() to be slightly shorter and less error-prone.
*) Explicitly set the LayerRendererChromium for each layer in the tree when transfering the root layer (used

during lost context). LayerChromium::setLayerRenderer checks if the new LayerRendererChromium is different
by comparing the pointer value to the old one. This check will be incorrect if there are multiple lost
contexts between a setLayerRenderer() call and a new LayerRendererChromium happens to be allocated at the
same address as the old one. An explicit call to setLayerRenderer() for every layer in the tree fixes this
since when this function is called the new and old LayerRendererChromium are still live and so they cannot
live at the same address.

The first two changes are purely refactors and do not change behavior. The third issue can't be tested via a
layout test directly as we don't have a way to induce a lost context on the compositor in a layout test.

storage/StorageTracker.cpp:
(WebCore::StorageTracker::syncDeleteOrigin): Uses helper function
to get path of origin's db
(WebCore::StorageTracker::databasePathForOrigin): New helper function.
that gets the path of an origin's local storage db from StorageTracker.
(WebCore::StorageTracker::diskUsageForOrigin): New API.

No tests since we don't have any bots testing CFNETWORK_DATA_ARRAY_CALLBACK.

platform/network/mac/ResourceHandleMac.mm:

(-[WebCoreResourceHandleAsDelegate connection:didReceiveDataArray:]): The didReceiveData()
callback on client can result in the load being cancelled. This results in the delegate
(self) being freed. Protect self during the loop so we can check for m_handle and safely
return without crashing.

Adding a LayerOffset class that will replace existing usage of tx/ty.
LayerOffset is necessary since these values are commonly used as both
a size and a point. Updating paintIntoRect to use this new class.

Moved m_absCaretBounds, m_absoluteCaretRepaintBounds, m_absCaretBoundsDirty, and m_caretPaint back
from CaretBase to FrameSelection because they are only used in FrameSelection, and made the rest
of member variables in CaretBase private.

editing/FrameSelection.cpp:
(WebCore::CaretBase::CaretBase): Takes CaretVisibility as an argument.
(WebCore::DragCaretController::DragCaretController):
(WebCore::FrameSelection::FrameSelection): Initializes m_absCaretBoundsDirty and m_caretPaint
now that they are part of FrameSelection again.
(WebCore::DragCaretController::setCaretPosition):
(WebCore::FrameSelection::setSelection):
(WebCore::CaretBase::clearCaretRect): Extracted from updateCaretRect.
(WebCore::CaretBase::updateCaretRect): No longer clears caret; all call sites (namely setCaretPosition
and localCaretRect) that used to call updateCaretRect now need to call clearCaretRect or updateCaretRect
based on some conditions.
(WebCore::FrameSelection::localCaretRect):
(WebCore::CaretBase::caretRepaintRect):
(WebCore::FrameSelection::recomputeCaretRect):
(WebCore::FrameSelection::paintCaret): Only calls CaretBase::paintCaret if m_caretPaint is true.
(WebCore::CaretBase::paintCaret): Removed an early exit for when m_caretPaint is false since m_caretPaint
has been moved from CaretBase to FrameSelection.
(WebCore::FrameSelection::focusedOrActiveStateChanged):
(WebCore::FrameSelection::updateAppearance):
(WebCore::FrameSelection::setCaretVisibility): Takes CaretVisibility instead of bool.
(WebCore::FrameSelection::caretBlinkTimerFired):

GraphicsLayer uses parent/child terminology for tree structure, as does CCLayerImpl. LayerChromium was using
superlayer/sublayer terms, inherited from this code's branching from the platform/graphics/win/CACF code. The
mixed terminology is confusing and parent/child is more common, so this unifies everything to use parent/child.

UIProcess/WebPageProxy.cpp:
(WebKit::WebPageProxy::handleWheelEvent):
(WebKit::canCoalesce):
(WebKit::coalesce):
(WebKit::coalescedWheelEvent):
(WebKit::WebPageProxy::didReceiveEvent):
(WebKit::WebPageProxy::processDidCrash):
Reworks coalescing/merging code to happen on didReceiveEvent rather than in
handleWheelEvent. This means we now store the pending events in a queue, and
pull them out when we can.

Remove the (unused) _isAnimating ivar and replace it with two ivars: _isEnteringFullScreen and
_isExitingFullScreen. These will ensure each is only called once per full screen request, and
that if one exit/enter request interrupts another, that the required functions are called in
order.

Handle the removal of a full screen element from within Node::willRemove() instead
of Document::nodeWillBeRemoved(). The new function Document::fullScreenElementWillBeRemoved() will
be called by Node::willRemove() to handle those changes which used to occur in nodeWillBeRemoved().

Test: fullscreen/full-screen-remove-children.html

dom/Document.cpp:
(WebCore::Document::nodeWillBeRemoved): Removed the code checking for the full screen element.
(WebCore::Document::fullScreenElementWillBeRemoved): Added, moved from nodeWillBeRemoved.

dom/Document.h:

dom/Node.cpp:
(WebCore::Node::willRemove): Check to see if this is the current full screen element.

ScrollAnimatorMac has a new bit -- m_needsScrollerStyleUpdate. This is set to true
when a ScrollAnimator is inactive and has received the
updateScrollerStyleForNewRecommendedScrollerStyle delegate notification. It
prevents any work from being done for this delegate until the ScrollAnimator
becomes active again.

This override of ScrollAnimator::setIsActive() calls the base class, and then calls updateScrollerStyle() if needsScrollerStyleUpdate() is set to true.
(WebCore::ScrollAnimatorMac::setIsActive):

This is mostly the same as the old delegate method. Key differences are that if
the ScrollAnimator is inactive, we now setNeedsScrollerStyleUpdate(true) and
return early. We also only call scrollableArea()->scrollbarStyleChanged() if
needsScrollerStyleUpdate() is false since in the true case when we are restoring
from the page cache, this would be duplicated work.
(WebCore::ScrollAnimatorMac::updateScrollerStyle):

New WKSystemInterface function is needed to retrieve the scrollbar style.

Until we move all the UI for find on page into WebKit on Windows (specifically, drawing the find bouncy),
WebKit clients need to know whether WebKit is drawing the page overlay or not. Keep track of this in
the WebPageProxy in the UI process and provide a WebKit2 API to retrieve this information.

WebProcess/WebPage/WebPage.cpp:
(WebKit::WebPage::installPageOverlay): Send message to UI process to tell it the page overlay is installed.
(WebKit::WebPage::uninstallPageOverlay): Send message to UI process to tell it the page overlay is uninstalled.

Second attempts at a fix for this bug. Instead of removing the dirtying (which turned out to be needed in a few cases),
make dirtyLinesFromChangedChild mark a child as needing layout when it has to recur to the parent. Because the method already
aborts the recursion if selfNeedsLayout() is set on the parent, this has the effect of stopping the O(n2) pathological
behavior, since you can use the selfNeedsLayout() bit to understand that you've dirtied the lines already.

platform/graphics/cairo/CairoUtilities.cpp:
(WebCore::copyCairoImageSurface): Abstract the code from WebCore::ImageBuffer::copyImage
into this helper which creates a deep copy of a Cairo image surface.

platform/graphics/cairo/CairoUtilities.h: Added declaration.

platform/graphics/cairo/ImageBufferCairo.cpp:
(WebCore::ImageBuffer::copyImage): Use the new helper.

platform/graphics/cairo/ImageCairo.cpp: Abstract some of this logic
into the new drawSurfaceToContext method on PlatformContextCairo.
(WebCore::BitmapImage::draw):

Chromium bug is ​http://crbug.com/60744. Expected images need to be
updated because they are incorrect. The cause of this image change
cannot be easily determined at present because the test has been
broken for so long.

WebProcess/Plugins/PluginView.cpp:
(WebKit::PluginView::getAuthenticationInfo):
Try to get the authentication info from the credential storage. Failing that,
get it from the persistent credential storage.

Stop storing RefPtr<SVGPaint> objects in the SVGRenderStyle for fill/stroke. These are the last
two objects that held references to CSSValues, they're all gone now, aligning better with RenderStyle.
It's also dangerous, as a SVGPaint object can be shared by multiple SVGRenderStyles (MappedAttribute will
once create a CSSStyleDeclaration for fill="red" and reuse it where possible), and it was easy to
accidently mutate the object, affecting multiple styles. Instead store a Color, an URI and a paint
type in SVGRenderStyle, enough to create a SVGPaint object, if needed (eg for computed styles).

In order to fix to bug we have to resolve all currentColor values for SVGPaint objects, in SVGCSSStyleSelector,
as it's already done for SVGColor objects (stop-color, flood-color, etc.) instead of in RenderSVGResource::fill/strokePaintingResource,
when trying to use the paint server. The correct "color" value that should be used from the RenderStyle, is directly
available in CSSStyleSelector: in applyProperty m_style->color() gives the desired value. In CSSStyleSelector it's handled
exactly this way for non-SVG currentColor properties. Also fix computed styles, which did not resolve currentColor for SVGPaint/SVGColor.

A previous patch implemented the SVGPaint/SVGColor API. SVG demands these CSSValues to be mutable. Introduce
CSSMutableValue, which extends CSSValue by a Node pointer, and let SVGPaint/SVGColor inherit from it.
Mutating a SVGPaint/SVGColor object now takes immediate effect, which is reflected in the inline style / computed style.
(Note that getPresentationAttribute() already takes care of removing the CSSValue from the mapped attribute cache, so that it's no longer shared.)

Use a File object to store the downloaded file reference rather than
just the path. This keeps the file and permissions in scope (using the
already-existing blob system) so the browser won't delete the file
when the load is complete. Instead, the file will be cleaned up when
the request objects are deleted.​https://bugs.webkit.org/show_bug.cgi?id=60281

(WindowGeometryInitializedBeforeSetWindow::NPP_SetWindow): Only check the window's size, not
its position. In WebKit2, the position won't have been set yet, so we can't test it. But it
turns out only the size mattered for <​http://webkit.org/b/46716>, which this test was
created for.

(WindowRegionIsSetToClipRect::WindowRegionIsSetToClipRect): Converted to be a
WindowedPluginTest, and initialized new members.
(WindowRegionIsSetToClipRect::startTest): Make our plugin window visible, and set things up
to ensure we get a WM_WINDOWPOSCHANGED message about it becoming visible.
(WindowRegionIsSetToClipRect::finishTest): Check that the window region is what we expect,
then clean up and tell the test harness we're done.
(WindowRegionIsSetToClipRect::checkWindowRegion): Moved code to check the window region here
from NPP_SetWindow. Changed to use the fancy new log() function instead of pluginLog().
(WindowRegionIsSetToClipRect::showTestHarnessWindowIfNeeded): Show the test harness's window
if it is hidden. This is needed to ensure we get a WM_WINDOWPOSCHANGED message when our own
window becomes visible.
(WindowRegionIsSetToClipRect::hideTestHarnessWindowIfNeeded): Hide the test harness's window
if it was hidden at the start of the test.
(WindowRegionIsSetToClipRect::wndProc): When our timer fires, tell the UI process to paint.
This should cause our window to become visible and our window region to get set. When we get
a WM_WINDOWPOSCHANGED message, we can finally finish the test.
(WindowRegionIsSetToClipRect::NPP_GetValue): Return our script object.
(WindowRegionIsSetToClipRect::ScriptObject::hasMethod): We only have one method:
"startTest".
(WindowRegionIsSetToClipRect::ScriptObject::invoke): Call through to the PluginTest object.

DumpRenderTree/TestNetscapePlugIn/win/WindowedPluginTest.cpp:

(WindowedPluginTest::testHarnessWindow):

DumpRenderTree/TestNetscapePlugIn/win/WindowedPluginTest.h:

Added this helper function. Code came from NPNInvalidateRectInvalidatesWindow.

SpellChecker uses TextCheckerClient, which belongs Page object,
which is possibly destroyed during SpellChecker's lifetime.
This change added to a guard before using TextCheckerClient to
ensure it being live.

This patch lays the ground for refactoring the drag start logic. It moves draggableNode to
DragController to avoid the awkward plumbing of calling DragController from RenderObject and
also moves EventHandlerDragState out from EventHandler so it can be shared between
EventHandler and DragController where appropriate.

When animating into and out of full screen, order out and back in the original webView window,
disabling animations when necessary. The exitFullscreen method was targeting the wrong window,
as the webView is hosted in the full screen window when we ask for it's parent window.

When animating into and out of full screen, order out and back in the original webView window,
disabling animations when necessary. The beganExitFullScreenAnimation method was targeting the wrong window,
as the webView is hosted in the full screen window when we ask for it's parent window.

The UI process’s wait for DidUpdateBackingStoreState would always time out because the Web process
was blocked on a synchronous message the UI process trying to get the connections for plug-ins in
the view. This is avoided by deferring the call to Page::setCanStartMedia().

WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::WebPage): Initialize the new m_setCanStartMediaTimer.
(WebKit::WebPage::setCanStartMediaTimerFired): Added. Calls setCanStartMedia(true) when the timer
fires.
(WebKit::WebPage::setIsInWindow): When going out of a window, stop the timer. When going into a
window, start it.

Have ChromeClient manage the GtkAdjustments of the parent widget instead of passing
them to WebCore to manage. This simplifies the code quite a bit and should be less
crash prone in the future.

GNUmakefile.am: Added new GtkAdjustmentWatcher class to the sources list.

WebCoreSupport/ChromeClientGtk.cpp: Added new GtkAdjustmentWatcher member.
(WebKit::ChromeClient::ChromeClient) Initialize the new member.
(WebKit::ChromeClient::scroll): Poke the adjustment watcher to update the adjustments.
(WebKit::ChromeClient::contentsSizeChanged): Ditto.
(WebKit::ChromeClient::scrollbarsModeDidChange): This may now be called at a time when there
is no main frame, so do an early return in that case.

WebCoreSupport/ChromeClientGtk.h: Add the new member.
(WebKit::ChromeClient::adjustmentWatcher): Add this getter for WebKitWebView.

When eval is disabled, we need to block the use of the function
constructor. However, the WebCore JSC bindings call the function
constructor directly to create inline event listeners. To support that
use, this patch adds an entrypoint that bypasses the check for whether
eval is enabled.

Spawn a plug-in process and let it create the plist. For now, we'll do this on the
main thread since it's a rare one-time computation and we have an API function,
WKFrameCanShowMIMEType, which would have to block anyway.

PluginProcess/mac/PluginProcessMainMac.mm:
(WebKit::PluginProcessMain):
If -createPluginMIMETypesPreferences is one of the command line argument keys,
the plug-in path will be the argument value. Call NetscapePluginModule::createPluginMIMETypesPreferences
to create the preferences file and then exit.

Shared/Plugins/Netscape/mac/NetscapePluginModuleMac.mm:
(WebKit::contentsOfPropertyListAtURL):
Move code to read a property list out into a helper function.

(WebKit::NetscapePluginModule::createPluginMIMETypesPreferences):
Load the plug-in, find the BP_CreatePluginMIMETypesPreferences and call it.

UIProcess/Plugins/mac/PluginProcessProxyMac.mm:
(WebKit::PluginProcessProxy::createPropertyListFile):
Spawn a plug-in process and pass the -createPluginMIMETypesPreferences flag to it and then wait
for it to exit.

We don't need to filter most http-equiv attributes. This patch
introduces a blacklist for two that we probably do want to filter.
It's possible a whitelist would be more appropriate, but I'm inclined
to start with a blacklist and see how it works.

This patch will hopefully fix a false positive that is causing errors
with copy-and-pasted text in Gmail in some configurations (due to using
the <meta> tag to request UTF-8 encoding both in the pasted text and in
the page itself).

This function is new in the patch and includes a blacklist of
dangerous http-equivs. Many of the other functions listed here
are just being moved from an anonymous namespace to use static
for internal linkage.

platform/graphics/qt/FontPlatformDataQt.cpp:
(WebCore::FontPlatformData::FontPlatformData): In the FontPlatformData constructor
used by SimpleFontData::scaledFontData(), pass the pixel size to both QFont and QRawFont
to make small caps and emphasis marks have the correct size when rendered through
the fast font path.

WebPage::platformInitialize and WebPage::platformPreferencesDidChange were fighting over the
font rendering mode. The platformInitialize code predates preference-based font rendering
mode support, and is now redundant and incorrect.

Fixes <​http://webkit.org/b/60494> WebKit2 uses GDI text instead of CG text when
FontSmoothing preference is set to kWKFontSmoothingLevelNoSubpixelAntiAliasing in a .plist
on disk

Reviewed by Sam Weinig.

WebProcess/WebPage/win/WebPageWin.cpp:

(WebKit::WebPage::platformInitialize): Removed code to set the font rendering mode.
platformPreferencesDidChange will take care of this for us.

from react-to-vsprops-changes.py.
(top level): Moved a constant here from main.
(main): Moved most code from here to react_to_vsprops_changes. Added a call to the new
react_to_webkit1_interface_changes function.
(react_to_vsprops_changes): Moved code here from main. Updated to use the
TOP_LEVEL_DIRECTORY global. Moved some code from here to mtime_of_newest_file_matching_globa
and touch_if_older_than.
(react_to_webkit1_interface_changes): Added. Touches WebKit.idl if any other WebKit1 IDL
file has changed.
(mtime_of_newest_file_matching_glob): Added. Code came from main.
(touch_if_older_than): Added. Code came from main.

Update the expected results for the argument types after the lastest updates
in the getUserMedia specification. The test has been disabled temporarily
and will be re-enabled by 60177 since some exceptions are risen after parsing
the provided options.

Layer name now has "Tiled" prepended if it is a TiledLayer. This is true on Mac where
the layer is a CATiledLayer and on Win where the layer is actually still a CACFLayer
but implements a tiled layer. I also now print the address of the CALayer or CACFLayer
instead of the PlatformCALayer everywhere.

dom/Node.h: Removed canSelectAll and selectAll as they are left over from WMLSelectElement.

editing/FrameSelection.cpp:
(WebCore::FrameSelection::selectAll): Dispatch selectstart event on selectStartTarget, which is
input element or textarea element when the current selection is inside a shadow DOM, and the root
editable element if it's inside a non-shadow editable region, and the body element otherwise.

html/HTMLSelectElement.h: Made canSelectAll and selectAll public since they are no longer
declared in Node.

Extracted CaretBase and DragCaretController from FrameSelection. CaretBase is a base class for
DragCaretController and FrameSelection and provides functions to paint caret.

Since DragCaretController doesn't need to store selection, it only holds one VisiblePosition.

WebCore.exp.in:

editing/FrameSelection.cpp:
(WebCore::CaretBase::CaretBase): Added.
(WebCore::DragCaretController::DragCaretController): Added; Set m_caretVisible true.
(WebCore::DragCaretController::isContentRichlyEditable): Added.
(WebCore::FrameSelection::FrameSelection): Several member variables are move to CaretBase.
(WebCore::DragCaretController::setCaretPosition): Extracted from FrameSelection::setSelection.
(WebCore::FrameSelection::setSelection): Removed an early exit for DragCaretController.
(WebCore::clearRenderViewSelection): Extracted from FrameSelection::respondToNodeModification.
(WebCore::DragCaretController::nodeWillBeRemoved): Extracted from FrameSelection::nodeWillBeRemoved
and respondToNodeModification. Note that the position DragCaretController holds is equivalent to
FrameSelection's base or start so when removingNodeRemovesPosition returns true for m_position,
we used to execute the first if clause and cleared render tree selection and DOM tree selection.
This is exactly what new DragCaretController::nodeWillBeRemoved does.
(WebCore::FrameSelection::nodeWillBeRemoved): Simplified early exist conditions.
(WebCore::FrameSelection::respondToNodeModification): Calls clearRenderViewSelection.
(WebCore::CaretBase::updateCaretRect): Takes document, caretPosition, selection type, and boolean isOrphaned.
Note that we can't obtain the document from caretPosition because VisiblePosition can be null even if
FrameSelection's start was not null.
(WebCore::caretRendersInsideNode): Moved; Made static local.
(WebCore::CaretBase::caretRenderer): Extracted from FrameSelection::caretRenderer.
(WebCore::FrameSelection::caretRenderer): Calls CaretBase::caretRenderer.
(WebCore::DragCaretController::caretRenderer): Ditto.
(WebCore::FrameSelection::localCaretRect): Calls updateCaretRect with extra arguments.
(WebCore::CaretBase::absoluteBoundsForLocalRect): Moved from FrameSelection; Takes Node*.
(WebCore::CaretBase::caretRepaintRect): Ditto.
(WebCore::FrameSelection::recomputeCaretRect): Calls absoluteBoundsForLocalRect, caretRepaintRect,
and shouldRepaintCaret with extra arguments.
(WebCore::CaretBase::shouldRepaintCaret): Takes a boolean isContentEditable.
(WebCore::FrameSelection::invalidateCaretRect): Calls CaretBase::invalidateCaretRect.
(WebCore::CaretBase::invalidateCaretRect): Extracted from FrameSelection::invalidateCaretRect.
(WebCore::FrameSelection::paintCaret): Calls CaretBase::paintCaret.
(WebCore::CaretBase::paintCaret): Extracted from FrameSelection::paintCaret.
(WebCore::FrameSelection::updateAppearance): Removed an assertion that this function is never called for
DragCaretController.
(WebCore::DragCaretController::paintDragCaret): Moved from FrameSelection::paintDragCaret.

(WebCore::RenderBox::computeReplacedLogicalHeightUsing): Do not apply the logic to prevent precent-height
replaced elements from being squeezed by table cells when the replaced element is positioned (and thus
doesn’t affect the table cell’s height).

In cases where the tree has a small number of persistent failures but a
patch has a large number of failures, we weren't believing any results.
That lead to us retrying the patch forever while we waited for
trustworthy results that would never come.

This patch loosens the semantics of unexpected_failures to return a
subset (rather than the exact set) of unexpected failures. In the case
where the tree has a bounded number of failures and the patch has an
unbounded number of failures, we can accurately compute such a subset
and reject the patch.

(WebCore::defaultSessionCookieStorage):
Keep track of the default storage session cookie storage.
(WebCore::currentCookieStorage):
Call defaultCookieStorage to get the default cookie storage.
(WebCore::defaultCookieStorage):
If there is a default storage session cookie storage, prefer that over getting the default
cookie storage. In the Web Process, asking CFNetwork for the default cookie storage directly
without specifying a storage session will not get the cookie storage being shared by the UI
and Web Processes.

platform/network/ResourceHandle.h:

platform/network/cf/ResourceHandleCFNet.cpp:

(WebCore::willSendRequest):
Make sure to set the current storage session on any requests used by the Web
Process before CFNetwork has to do anything with them, in order for CFNetwork to avoid
doing anything with the Web Process's default storage session (which is not the one shared
with the UI Process).
(WebCore::makeFinalRequest):
Ditto.
(WebCore::ResourceHandle::willSendRequest):
Ditto.
(WebCore::ResourceHandle::currentStorageSession):
If there is a Private Browsing storage session, return that.
If not, on Windows return the default storage session that is being shared with the UI
Process and on Mac return 0.
(WebCore::defaultCFURLStorageSession):
(WebCore::ResourceHandle::setDefaultStorageSession):
(WebCore::ResourceHandle::defaultStorageSession):

platform/network/cf/ResourceRequestCFNet.cpp:

(WebCore::ResourceRequest::doUpdatePlatformRequest):
Make sure to set the current storage session on any requests used by the Web
Process before CFNetwork has to do anything with them, in order for CFNetwork to avoid
doing anything with the Web Process's default storage session (which is not the one shared
with the UI Process).

Source/WebKit/win:

WebView.cpp:

(WebView::setCacheModel):
Pass 0 to wkCopyFoundationCacheDirectory so that it uses the default session.

Add a parameter for a serialized default storage session, used only on Windows.

Shared/win/WebCoreArgumentCodersWin.cpp:

(CoreIPC::decodeResourceRequest):
Make sure to set the current storage session on any requests used by the Web
Process before CFNetwork has to do anything with them, in order for CFNetwork to avoid
doing anything with the Web Process's default storage session.

UIProcess/win/WebContextWin.cpp:

(WebKit::WebContext::platformInitializeWebProcess):
Serialize the default storage session in the UI Process and add it to the
WebProcessCreationParameters.

WebProcess/WebPage/win/WebPageWin.cpp:

(WebKit::cachedResponseForURL):
Use the cache associated with the current storage session and make sure the request has the
current storage session set on it before doing anything with it.

WebProcess/win/WebProcessWin.cpp:

(WebKit::WebProcess::platformSetCacheModel):
Use the default storage session.
(WebKit::WebProcess::platformClearResourceCaches):
Ditto.
(WebKit::WebProcess::platformInitializeWebProcess):
Deserialize the default storage session passed in by the UI Process and hand it to the
ResourceHandle.

html/TextFieldInputType.cpp:
(WebCore::replaceEOLAndLimitLength): Moved from InputElement.cpp.
(WebCore::TextFieldInputType::sanitizeValue): Implement with replaceEOLAndLimitLength().
(WebCore::TextFieldInputType::handleBeforeTextInsertedEvent):
Move the code from InputElement::handleBeforeTextInsertedEvent().

html/TextFieldInputType.h: Update declarations.

rendering/RenderTextControlSingleLine.cpp:

Remove ASSERT(node()->isHTMLElement()) because it is checked in the constructor.

The original message implied (correctly, at-the-time) that​http://code.google.com/p/git-osx-installer/ doesn't provide 64-bit
binaries. The new message notes that they do. This might prevent someone
else from spending a few minutes confused.

This CSP directive is not in the CSP spec. This patch is somewhat of
an experiment to see whether this feature is useful. Based on our
implementation experience, we will coordinate with folks via the W3C to
see if this makes sense to add to the spec.

Use a File object to store the downloaded file reference rather than
just the path. This keeps the file and permissions in scope (using the
already-existing blob system) so the browser won't delete the file
when the load is complete. Instead, the file will be cleaned up when
the request objects are deleted.​https://bugs.webkit.org/show_bug.cgi?id=60281

These two test suites account for 2/3 of test-webkitpy's running time
because they're not actually unit tests. They're integration tests.
This patch adds the ability to skip integration tests by passing a
command line argument to test-webkitpy. The buildbots will continue to
run these integration tests to make sure they don't regress. This
option is for use by developers when working on parts of the code that
are well-covered by unit tests.

Make simplified layout skip from a positioned object out to its containing block. There is no
need to dirty the intermediate inlines, and in this case it's actively harmful, since the
block responsible for the layout of the positioned object doesn't get m_posChildNeedsLayout set.

Fixes <​http://webkit.org/b/60285> <rdar://problem/9152400> REGRESSION (WebKit2): A white
rectangle covers up important UI elements when composing a new message at mail.yahoo.com
with BrowserPlus! plug-in installed

(WebKit::WebView::updateChildWindowGeometries): Show or hide the window as specified in the
geometry.

WebProcess/Plugins/Netscape/NetscapePlugin.cpp:

(WebKit::NetscapePlugin::visibilityDidChange):

WebProcess/Plugins/Netscape/NetscapePlugin.h:

Added. Calls through to platform-specific code.

WebProcess/Plugins/Netscape/mac/NetscapePluginMac.mm:

(WebKit::NetscapePlugin::platformVisibilityDidChange):

WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:

(WebKit::NetscapePlugin::platformVisibilityDidChange):
Stubbed out.

WebProcess/Plugins/Netscape/win/NetscapePluginWin.cpp:

(WebKit::NetscapePlugin::platformGeometryDidChange): Moved most logic from here to
scheduleWindowedGeometryUpdate.
(WebKit::NetscapePlugin::platformVisibilityDidChange): Added. Calls through to
scheduleWindowedGeometryUpdate.
(WebKit::NetscapePlugin::scheduleWindowedGeometryUpdate): Added. Code came from
platformGeometryDidChange. Now also records whether the plugin element is visible.

WebProcess/Plugins/Plugin.h: Added visibilityDidChange.

WebProcess/Plugins/PluginController.h: Added isPluginVisible.

WebProcess/Plugins/PluginProxy.cpp:

(WebKit::PluginProxy::visibilityDidChange):

WebProcess/Plugins/PluginProxy.h:

Stubbed out.

WebProcess/Plugins/PluginView.cpp:

(WebKit::PluginView::show):
(WebKit::PluginView::hide):
Added. These Widget overrides were based on WebCore's PluginView class.

(WebKit::PluginView::viewVisibilityDidChange): Added. Similar to viewGeometryDidChange.
Calls down to the plugin if it's been initialized.
(WebKit::PluginView::isPluginVisible): Added. Just calls up to the Widget base class.

Currently results.zip created by the Chromium EWS bot contain roughly
1000 tests that we expect to fail. These test results are not helpful
to contributors.

There are several approaches to solving this problem:

1) We could be more selective about which files to include in the zip.
2) We could ask new-run-webkit-tests not to generate results for

expected failures.

3) We could ask new-run-webkit-tests not to run tests that we expect to

fail.

This patch takes approach (3). Currently, we're ignoring the outcome
of failing tests anyway, so there's not much point in actually running
them. As a side benefit, this will speed up the test run by about 6%.
In the future, we might revisit this decision and choose another
approach.

Allow for empty scissor rects, which implies scissoring to the render
surface. The previous code and previous patch on this bug both didn't
take into account that the scissor rect should be the render surface
and not the projection of the layer itself, because child layers
aren't necessarily contained within the bounds of their superlayer.

Change WebSocket::connect to take the raw URL string and parse it
internally using the simple KURL constructor, which expects an absolute
UTF-8 encoded URL. This ensures that all code that creates a WebSocket
goes through this method instead of completeURL.

When enabling support of c++0x the compilation fails because of an
ambiguous overload error. In this code when constructing the pair
we use the new c++0x rvalue reference feature (&&). It means we are
calling String(const WTF::AtomicString&) which becomes ambiguous because
it has an overload WTF::String::String(const WTF::String&) and usually one
with the native port string type (e.g. QString). In this code we want the
String version because the pair store Strings.