When we update compositing layers (which can happen on scrolling, when there are fixed position elements
on the page), we can end up redundantly setting images as layer contents if we have to color-correct
the image. This is because we call CGImageCreateCopyWithColorSpace(), which hands back a new image
every time.

Avoid this by storing a reference to the original uncorrected image, which is used to then
avoid work if the image does not change.

window.openDatabase() always fails for new databases when using WebKit nightly with Safari 4.0.5. This is caused by a SecurityOrigin pointer comparison that I should have switched to be a hash comparison in r56293 [bug 34991].​https://bugs.webkit.org/show_bug.cgi?id=36671

No new tests. Requires testing on Safari on Windows.

storage/DatabaseTracker.cpp:
(WebCore::DatabaseTracker::fullPathForDatabaseNoLock): Convert a pointer comparison to use SecurityOriginHash::hash() instead, and move it to the end of the clause for speed in the easy-out case.

When we moved the "builders are red" check into the master process, we
forgot about rollouts. I thought we had a test covering this case, but
looking at the test, it was a bit too loose. I added a new test and
introduced some new logging technology into MockTool to make the test
tighter.

Configure multi-language movies: when QuickTime has sufficiently loaded
the movie, call into wkQTMovieSelectPreferredAlternates to select the
movie's alternate tracks according to the user's language preferences.

platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
(WebCore::MediaPlayerPrivate::updateStates): If the movie is sufficiently loaded,
call wkQTMovieSelectPreferredAlternates to set up the alternate tracks.

RenderBlock::layoutInlineChildren is 351 lines long and very difficult
to comprehend or edit safely. This patch splits it up into a few
slightly smaller functions. Most of the code is now in the 241 line
layoutRunsAndFloats() which is a slight improvement.

Perf neutral on the page cyclers. This doesn't introduce any function
calls into the hottest layout paths inside layoutRunsAndFloats and
findNextLineBreak.

When a page specifies the generic "monospace" font and the user's
browser-configured monospace font doesn't exist, we previously relied
on getLastResortFallbackFont to eventually pick a monospace font for us.

But that doesn't quite work: WebKit first falls back to the user's
"preferred standard font" before hitting the last resort code path.
So if the above conditions hold but this font exists, we'll end up
never hitting the last resort codepath.

The fix is to allow OS-level font fallback when first attempting to
resolve monospace. The existing code tried to do this, but the logic
was wrong. We would eventually fall back to the correct font anyway
so we didn't notice the logic was wrong.

This code is all handling cases where particular fonts aren't installed,
so I can't think of a way to test it; existing tests should still pass.

CanvasRenderingContext::canvas() being an HTMLElement(), so that this usage
can be dealt with in one place.
(WebCore::CanvasSurface::securityOrigin): Only used by methods that are
only run in the document context.
(WebCore::CanvasSurface::renderBox): Will likely return 0 in a worker context.
(WebCore::CanvasSurface::computedStyle): Used by setFont. Return value is TBD for
the worker context.
(WebCore::CanvasSurface::styleSelector): Ditto.

dom/CanvasSurface.h:

html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::getContext): Passing in information into
the CanvasRenderingContext2D constructor to eliminate some uses of document
inside of the CanvasRenderingContext2D class.

html/HTMLCanvasElement.h:

(WebCore::HTMLCanvasElement::renderBox): Added to disambiguate between the
two parent class versions of the method.
(WebCore::HTMLCanvasElement::computedStyle): Ditto.

html/canvas/CanvasRenderingContext2D.cpp: All of these changes are about

removing document usage either by using a bool that is set in the constructor or
by calling one of the new methods added to CanvasSurface.
(WebCore::CanvasRenderingContext2D::CanvasRenderingContext2D):
(WebCore::CanvasRenderingContext2D::clearPathForDashboardBackwardCompatibilityMode):
(WebCore::CanvasRenderingContext2D::checkOrigin):
(WebCore::CanvasRenderingContext2D::prepareGradientForDashboard):
(WebCore::CanvasRenderingContext2D::createPattern):
(WebCore::CanvasRenderingContext2D::setFont):
(WebCore::CanvasRenderingContext2D::drawTextInternal):

fast/canvas/webgl/index-validation-expected.txt: Gathering more information about the cause of the failure. It's not a fix, and it won't worse change the current test behavior either, i.e., it won't make it better or worse.

To fix this issue, we don't save values if it is not changed from
the default value.

Updating the value IDL attribute of some controls such as
type=hidden also updates the value content attribute, and it's
impossible to distinguish the initial value and the current
value. The values of such controls are not saved. It won't be a
problem because we want to save and restore user-edited values.

Test: fast/forms/state-restore-to-non-edited-controls.html

html/HTMLInputElement.cpp:
(WebCore::HTMLInputElement::saveFormControlState):
Do not save the value if it is same as the default value.

html/HTMLFormControlElement.cpp:
(WebCore::HTMLFormControlElementWithState::autoComplete):
Added. It return autocomplete state of the form.
(WebCore::HTMLFormControlElementWithState::shouldSaveAndRestoreFormControlState):
Added. It returns the result of autoComplete().
(WebCore::HTMLFormControlElementWithState::finishParsingChildren):
Do not restore state if shouldSaveAndRestoreFormControlState() is false.

bindings/v8/V8DOMWrapper.cpp:
(WebCore::V8DOMWrapper::setHiddenReference): Split common logic out of hidden setHiddenWindowReference
(WebCore::V8DOMWrapper::setHiddenWindowReference): Now contains logic specific to putting a
hidden reference on a global object.
(WebCore::globalObjectPrototypeIsDOMWindow): Be more thorough in the COMPILE_ASSERTs.
(WebCore::V8DOMWrapper::convertEventTargetToV8Object): Cleanup: Remove a duplicate if statement.

The contract between apply_reverse_diff and PrepareChangeLogForRevert
was unclear. I broke filling out the ChangeLog during rollout earlier
when I changed apply_reverse_diff to revert the ChangeLogs because
PrepareChangeLogForRevert thought that it was supposed to do that.
I've now taught PrepareChangeLogsForRevert the new contract.

It's unclear to me how to test this change because it's essentially an
integration issue that requires the file system. At some point we
should think about a testing strategy for integration. As the system
becomes larger, we're running into more of these issues.

The purpose of this patch is also to provide a mini-tutorial on
how to unit-test Python logging.py messages.

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

Unit-tested the log messages in test_retry().

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

Adjusted the LogTesting class by moving the code that clears
the array of log messages into a finally block. This prevents
redundant AssertionErrors from getting rendered to the screen
while running unit tests.

Added a LoggingTestCase class so the setUp() and tearDown()
methods do not need to be implemented in order to test logging.
Rather, TestCase classes can simply inherit from this class.

r56943 introduced a check to see if there were any unprocessed
SQL commands after calling sqlite3_prepare16_v2.

Accessing the remaining data via pointer wasn't possible since
the query string is deallocated immediately after the
query runs. The String returned from strippedWhiteSpace
goes out of scope at that point.

Fix is to store the strippedWhiteSpace in a temporary String
so we can access it via character ptr later in the function.

This rewrite puts the disabling not in the PythonProcessor but
in the calling code's default filter rule configuration. This
allows the user to check line-length style from the command-line
if desired.

Scripts/webkitpy/style/checker.py:

Added "-pep8/E501" to the _BASE_FILTER_RULES configuration
variable to disable the line-length check.

Added "-pep8/E501" to the list of recognized style categories
to permit the category to be checked from the command line.

This is a follow up to commit r56906. The fourth filter example,
feMorphology, shouldn't be displayed. filterRes causes a scaling of the filter
parameters, so that one value of 'radius' is lower than one.
The spec want us to round filter values down and a value of zero
for 'radius' stops the rendering process of feMorphology.

This patch does a few things to make the error handling in rollout a
bit more robust.

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

The old logic here was wrong. We don't want to resolve the
ChangeLogs (that would remove the old ChangeLog entry). Instead,
we want to revert the ChangeLogs so we can fill them with the new
message.

Scripts/webkitpy/tool/commands/download_unittest.py:

Update test expectations because we're using a different mock object.

Scripts/webkitpy/tool/commands/download.py:

Added an update command to make updating from the SheriffBot more
robust.

Now that we have CommitInfo, we can automatically CC the
responsible parties on the bug we create.

Re-ordered the steps in create-rollout. Our original thinking
was that we always wanted to create the bug, but that's not
really true given how things appear to be playing out. If we
fail to apply the reverse diff, we don't want to create the bug.

WebViewHost class
It's an implementation of some delegates required by Chromium
WebKit API, and manages painting of a WebView. It's base on
src/webkit/tools/test_shell/test_webview_delegate.{cc,h} of
Chromium rev.40492.

TestShell class
The TestShell instance holds global states of DumpRenderTree process.
Unlike TestShell class of Chromium test_shell, TestShell instance is
created just once.

Fix bug: CSS3 :not selector with ID simple selector sequence test fails
As per ​http://www.w3.org/TR/css3-selectors/#negation, :not(X) takes a simple selector as an argument.
WebKit was accepting a simple selector *sequence*.
This patch adds WebCore::CSSSelector::isSimple which judges if the selector is simple.
The method is used in CSSGrammar.y to decide whether to accept the selector as the argument of :not().​https://bugs.webkit.org/show_bug.cgi?id=36276

[chromium] FindInPage on multi-frame pages wasn't always updating
tickmarks on scrollbars for the subframes. It was calling invalidateRect
on the View and specifying a rect that's in window coordinates, whereas
the invalidateRect expects frame coordinates.

xml/XSLStyleSheetLibxslt.cpp:
(WebCore::XSLStyleSheet::parseString):
Handle an empty string gracefully. An empty string has a NULL
buffer, which we pass in to xmlCreateMemoryParserCtxt(). It returns
NULL if it is passed a NULL buffer.
In the top-level XSL case, the current code does not crash "by luck"
because the other APIs used can handle a NULL argument. In the
@import case, additional code runs which will deference the NULL.

If a file's modification time is modified, but the contents are not,
then diff-index will think the file has been modified unless you do
some crazy update-index call. Instead, call diff --name-only, which
has the index update builtin.

Tried to write a test, but could not reproduce this in a unittest.
To test manually:

Fix assertions added in r56017. That changed replaced calls to needsToBeComposited()
with use of the local 'willBeComposited' variable, but that fails to take into
account the fact that needsToBeComposited() also tests layer->isSelfPaintingLayer().

Fix by adding a canBeComposited() method that we call before testing
whether the layer should go into compositing mode.

Test: compositing/self-painting-layers2.html

rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::calculateCompositedBounds): Repace use of isSelfPaintingLayer()
with a call to canBeComposited().
(WebCore::RenderLayerCompositor::computeCompositingRequirements): Call canBeComposited() to ensure
that we only toggle 'willBeComposited' for layers that can.
(WebCore::RenderLayerCompositor::needsToBeComposited): Call canBeComposited().
(WebCore::RenderLayerCompositor::canBeComposited): Test if compositing is enabled, and whether
the layer is self-painting.

RenderLayer::updateLayerPositions() makes a recursive walk through all RenderLayers and updates the repaint rectangles on each.
These rectangles have to be calculated in the repaint container's coordinates using RenderObject::mapLocalToContainer to walk
up to the repaint container. This patch keeps track of the offset to the root and uses that offset instead of walking back up to
the root every time.

Plugins/Hosted/NetscapePluginInstanceProxy.mm:
(WebKit::NetscapePluginInstanceProxy::LocalObjectMap::get): The HashTable assertions aren't
there to catch potential future attempts to store empty/deleted values before these happen -
it's actually wrong to try to look up these values. Added an early return.
(WebKit::NetscapePluginInstanceProxy::LocalObjectMap::forget): Ditto.

Dan asked me to investigate why 19006 is no longer needed. I have two answers:

(1) I was also able to remove the synchronous call to updateFromElement().
That call was the proximate cause of the crash that 19006 fixed.

(2) updateFromElement() no longer calls HTMLElement::setInnerText()
in the way that it used to. (However, it doesn't seem prudent to
rely on this happy coincidence.)

html/HTMLInputElement.cpp:

(WebCore::HTMLInputElement::setValue): Simplified some logic here. Moved
setNeedsValidityCheck() outside of individual 'if' clauses, since they all
called it.

Removed call to updateStyleIfNeeded(), which does rendering synchronously,
since that was the performance problem. (setNeedsStyleRecalc() ensures
that rendering will happen asynchronously.) Also removed comment about
ordering dangers introduced by updateStyleIfNeeded().

Removed call to updateFromElement(), since it's dangerous and also a minor
performance problem. (setNeedsStyleRecalc() ensures that updateFromElement()
will happen asynchronously, too.)

html/HTMLTextAreaElement.cpp:

(WebCore::HTMLTextAreaElement::setNonDirtyValue): Ditto. Here, I had to
add a call to setNeedsStyleRecalc(), since there wasn't one before.

Plugins/Hosted/NetscapePluginInstanceProxy.mm:
(WebKit::NetscapePluginInstanceProxy::LocalObjectMap::get): Use find() instead of get(),
because the latter fails with an assertion when looking up 0 or -1.
(WebKit::NetscapePluginInstanceProxy::LocalObjectMap::forget): Be prepared for unexpected
object IDs coming from plug-in host.

Web Inspector: Sometimes js code can detach page from it's frame and in that case
Dispatch Events will stay in the TimelineAgent's events stack. Only immediate events will
appear at frontend.​https://bugs.webkit.org/show_bug.cgi?id=36890

RenderText's implementation of clippedOverflowRectForRepaint() uses containingBlock()
to get the renderer to use for computing the repaint rect. However, the renderer returned
by containingBlock() may be an ancestor of the repaintContainer, and containingBlock()
doesn't have the 'repaintContainerSkipped' logic that container() has.

So in this case, check to see whether repaintContainer is actually a descendant of the
containing block, and in that case just repaint the entire repaintContainer.

[chromium] FindInPage should clear the focused node when a match has
been found. This is because WebFrameImpl::setFocus will try to refocus
editable elements if it thinks they have focus, causing the page to
scroll.

Rewrite getCTM() / getScreenCTM() handling in an iterative way, fixing all known problems/limitations.
The bug mentioned above is actually not a regression, getScreenCTM() only worked before, because we
did not handle non-SVG CSS box parents properly. When support was added to handle those cases, the
getScreenCTM() handling was completly off, causing a lot of trouble in real-life SVG applications (carto.net for instance)

Share code between the different svgsvgelement-ctm*.xhtm tests, placed in svg/custom/resources.
Add several new tests covering getCTM()/getScreenCTM() on text, inner and outer svg elements and containers.

These changes will let us autoinstall pep8.py from the web and put
our third-party autoinstalled code in an explicit directory like
webkitpy/thirdparty/autoinstalled. These changes should also speed
up the execution of autoinstalled *.zip packages slightly since
*.pyc files cannot be generated when importing from zipped
packages using the current autoinstall.

Scripts/test-webkitpy:

Addressed the FIXME to enable auto-install logging once
autoinstall was rewritten not to log as verbosely.

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

Updated mechanize import statement.

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

Updated mechanize import statement.

Scripts/webkitpy/common/net/irc/ircbot.py:

Updated ircbot and irclib import statements.

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

Updated mechanize import statement.

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

Updated mechanize import statement.

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

Updated mechanize import statement.

Scripts/webkitpy/common/system/autoinstall.py: Added.

Added AutoInstaller class.

Added sample/testing usage to the main block.

Scripts/webkitpy/thirdparty/init.py:

Updated the autoinstall lines to use the new autoinstall methods.

Added pep8.py to the list of auto-installed packages.

Added a README file to the target autoinstallation directory
so users know that the directory is safe to delete.

Scripts/webkitpy/thirdparty/autoinstall.py: Removed.

This is replaced by the rewritten autoinstall
webkitpy/common/system/autoinstall.py.

Document::setTitle() invoked HTMLTitleElement::setText(), which
contains DOM tree modification, even when setTitle() is called
from HTMLTitleElement::childrenChanged(). Fix to skip setText()
when setTitle() is called childrenChanged() to avoid cascading
DOM mutations between Document and HTMLTitleElement.

This patch adds to the LogTesting class's tearDown() method a line
asserting that the array of remaining log messages is empty. This
ensures that no extra log messages are getting logged that the caller
might not be aware of or may have forgotten to check for.

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

Modified the tearDown() method as described above.

Also modified the assertMessages() method to clear the array
of log messages after asserting.

Verbose logging is useful for debugging test-webkitpy code that
runs before the actual unit tests -- things like autoinstalling and
unit-test auto-detection logic. This is different from verbose
logging of the unit tests themselves (which corresponds to the
unittest module's --verbose flag).

Scripts/test-webkitpy:

In the configure_logging() method--

Added an is_verbose_logging parameter that sets the logging
level to logging.DEBUG instead of logging.INFO.

Changed the method to throttle the logging level on the
root logger's handler instead of directly on the root logger
itself.

Enabled logging of the autoinstall module when the flag is set.

Scripts/webkitpy/thirdparty/autoinstalled/init.py:

Added a work-around for a bug in Python 2.6's logging module
that was discovered while working on this patch.

The root of the problem was that ChangeLog.init expects a path
relative to the current working directory, and SCM expects to
return paths relative to the SCM root. Fix it by converting from
SCM-relative to absolute paths in Checkout.modified_changelogs

(WebCore::KURL::port): Explicitly handle the case of a colon being present in the URL after the host name but with
no port number before the path. This is handled in the same manner as the colon and port being omitted completely.

LayoutTests:

Add explicit tests for handling of allowed ports. We currently only test the ports that map to port 80: 0, 80, and "".

Remove dependency on TextBreakIterator from StringImpl.cpp,
and from member methods of String.

Reviewed by Oliver Hunt.

Make 'numGraphemeClusters' & 'numCharactersInGraphemeClusters'
global function defined in PlatformString.h, rather than
member methods on String (these can be implemented purely
using the characters() and length() public interface),
and make 'makeCapitalized' a static function in RenderText.cpp.

General idea: SerializedScriptValue must be deserialized only once
and in the context of the intended MessageEvent recepient. The
approach we take for now is to eagerly deserialize when a
JavaScript wrapper for MessageEvent is created.

A better fix would be to keep a reference to the context in
MessageEvent and use it when lazily deserializing. It's harder to
do since the API doesn't have a clean method to have such a reference.

Tested by fast/dom/Window/window-postmessage-clone-frames.html. This
test still fails but only for the types which we can't serialize yet.

Removed the nutty ScheduledRedirection struct in favor of a hierarchy
of classes to represent the various kinds of scheduled redirects.
Doing this lets us get rid of the pseudo RTTI switch statements on
"type" in favour of calling virtual functions.

No new tests because this change should be API identical with the
existing RedirectScheduler.

Fix logging in new-run-webkit-tests so that we don't report IMAGE
expected failures as unexpected passes when we run with pixel tests
disabled.

This change splits some of the logic embedded into the TestExpectations
classes out into separate pure functions (result_was_expected,
remove_image_failures) to make them easier to test. This also adds
a parameter to matches_an_expected_result() to indicate whether or
not pixel test results should be included in the expectations.

rendering/RenderWidget.cpp:
(WebCore::RenderWidget::setWidgetGeometry): This method isn't called when an iframe containing
the widget moves, so we should store a value that is not dependent on current scroll offset.
(WebCore::RenderWidget::windowClipRect): Apply scroll offset and window clip now.

rendering/RenderWidget.h: Renamed m_windowClipRect to m_clipRect, because it is no longer
in window coordinates.

This patch adds an optimistic path to commit-queue and a "fail twice"
requirement for rejecting patches. That means we'll land good patches
faster (via the optmistic first run) and we'll reject many fewer
patches due to flaky tests.

Implements cancelGeolocationPermissionRequestForFrame.
Similar to requestGeolocationPermissionForFrame(), passes Geolocation* to cancelGeolocationPermissionRequestForFrame(),
so that the embedder can identify which Geolocation object is cancelling the pending permission request.
Calls cancelGeolocationPermissionRequestForFrame() before stopUpdating() so it better matches the startUpdating() / requestPermission() flow.​https://bugs.webkit.org/show_bug.cgi?id=35031

Check that injected script can still access inspected window object when wrapping console object. When the window cannot be access serialize objects as strings. Also don't call InjectedScript.dispatch if the window cannot be accessed (due to frame navigation).

Allow generic resource URLs for cookie handling in the inspector. This
enables display of all cookies, not only those that are associated
with resources accessed through http, https or file.​https://bugs.webkit.org/show_bug.cgi?id=36877

Been able to depend on Python 2.6
Instead I've added a bunch of hack code, but at least now
we should never have to update this string again as the location
of committers.py is fully dynamically discovered. :p

html/canvas/WebGLArray.cpp: Use memmove instead of memcpy; with memmove, copying takes place as if an intermediate buffer was used, allowing the destination and source to overlap.
(WebCore::WebGLArray::setImpl):

Fix LayoutTests/fast/dom/Window/window-resize.html
The test failed on Mac if Dock is placed on the left or the right because the window's width
and horizontal position can be adjusted by the OS.
This patch fixes it by using window.availWidth instead of window.width as the expected
values and by avoid using constant expected values.
As a side effect, the expected values become platform independent.

platform/chromium/test_expectations.txt:
Removed the failing expectation for
platform/chromium-win/svg/custom/scrolling-embedded-svg-file-image-repaint-problem.html
because the difference in only in the scroll bar, there is not difference in the image content.
Also fixed a grammar problem in last commit.

The clickCausedFocus flag is not being set in method
mousePressEvent(QGraphicsSceneMouseEvent* ev). This flag is used
in conjunction with QStyle::RSIP_OnMouseClickAndAlreadyFocused when
deciding to launch the software input panel.

platform/cocoa/KeyEventCocoa.mm:
(WebCore::windowsKeyCodeForKeyCode): This is now the primary function for determining
Windows key code - there is no reason to round trip a virtual key code via character code to
get Windows virtual key code, and this can't work for non-Roman alphabets.
(WebCore::windowsKeyCodeForCharCode): Removed keys that are now handled in windowsKeyCodeForKeyCode(),
only keeping those for which we don't have known key codes (yet?).

Adjusted test-webkitpy to delete all orphaned *.pyc files
from webkitpy/ prior to importing any modules from webkitpy.
This ensures that no import statements in webkitpy falsely
succeed because of leftover *.pyc files.

A new QtAbstractWebPopup descendant class to be used for maemo menu lists.
This is the first step. The next step will be the dialogs implementation that
will come in bug 36789 and finally to use QtMaemoWebPopup instead of QtFallbackWebPopup
that will come in bug 36368.

Add the "singleton" IndexedDatabase object to PageGroup
IndexedDatabase now has a create() method since PageGroup can own the instance (at least for now)
Rip out the IDBRequest stuff (now obsolete).
DOMWindow now can instantiate indexedDatabase objects on demand.

New layout tests starting with the next patch (which should make indexedDB.open() "work").

subproess.Popen() on Python 2.4/Windows with stdout,stdout, but no stdin will fail, because it uses return value of GetStdHandle(STD_INPUT_HANDLE), but DuplicateHandle requires integer, not the handle.
We don't need stdin, so use devnull as stdin.
Same as ​https://bugs.webkit.org/show_bug.cgi?id=36586

Scripts/webkitpy/layout_tests/port/chromium_win.py: open os.devnull for stdin

There is a build break due to the disabled() when wml feature is
enabled. This break comes from the Bug 35056 - Disabled menu options
are still submitted.(​https://bugs.webkit.org/show_bug.cgi?id=35056)
The WMLOptionElement.h needs to define the disabled() as well.
And, there is an additional break due to Bug 36177 - Multiselect Popup

Don't suppress scrollbar change for non-first layouts.
In the first layout, the scrollbar change will happen in later
adjustViewSize() call, but in other layouts, adjustViewSize() may
not be called when the size of contents doesn't change.

Change NotificationPresenter::checkPermission() to take the source frames full KURL,
rather than its SecurityOrigin. This will aid chromium in having more fine grained
permissions to control notification spam.

Change NotificationPresenter::checkPermission() to take the source frames full KURL,
rather than its SecurityOrigin. This will aid chromium in having more fine grained
permissions to control notification spam.

Change NotificationPresenter::checkPermission() to take the source frames full KURL,
rather than its SecurityOrigin. This will aid chromium in having more fine grained
permissions to control notification spam.

This seems to be caused by:​http://buildbot.net/trac/ticket/753
I have no work-around, but for now at least we're logging
the error better. I also added allow_none to our ServerProxy
creation in case that fixes things for other versions of python.

This function, which was moved from WebKit/chromium/src/FrameClientImpl.cpp,
is used to check whether or not a request is supposed to be rendered or
simply downloaded based on the "Content-Disposition" header sent by the
web server. The intent of code refactoring is to avoid code duplication
so that this piece of code can be used by other implementations such asQtWebKit.

ValidateReviewer logic was commented out in​http://trac.webkit.org/changeset/56744
That was a symptom of the fact that validatereviewer.py
is too inflexible to be used when real humans are driving webkit-patch.
For now we just disable ValidateReviewer when humans are at the keyboard.

In order to speed up multiple calls to CSSPrimitiveValue::cssText(),
this CL caches the String result. When m_value is changed, the
cached string is cleared. This gives a good speedup on benchmarks
which do a lot of CSS property gets, such as Peacekeeper.
The processing cost should be negligible, since the strings are
refcounted. The memory cost is an additional 4 bytes per
CSSPrimitiveValue, and the extended lifetime of the computed string
(potentially, the same as the lifetime of the CSSPrimitiveValue).

Fix regression introduced in ​http://trac.webkit.org/changeset/54526.
Restarting the request timer unconditionally from the timer callback is a bad idea.
Instead, start the timer when a non-cached request completes.

This implementation simply saves the context and the global object
just before the frame is navigated to a new url. At restore time,
the global object is reattached to the context and the context
is attached to the window shell of the frame.

Note that isolated worlds are not taken into account in any way,
as Android does not use them.

Protect global object from being GC'ed if there are messages written to console from the iframe with that global object.

Whent serializing objects in the injected script check that global object properties are still defined before using them as arguments. The may become undefined if owning frame navigated to a different domain.