tree a145abbae30eda1fb1f75f2008dc77e09ae852dd
parent b55d85ef344b55a8b3db2f8cb0de23e7d6ec633b
author paulmeyer <paulmeyer@chromium.org> 1481662472 -0800
committer Commit bot <commit-bot@chromium.org> 1481662635 +0000

Revert of Collect active stylesheets and and apply asynchronously. (patchset #4 id:60001 of https://codereview.chromium.org/2557533005/ )

Reason for revert:
Suspected cause of failing WebKit tests on bots. Example: https://uberchromegw.corp.google.com/i/chromium.webkit/builders/WebKit%20Mac10.11%20%28dbg%29/builds/6390

BUG=673850

Original issue's description:
> Collect active stylesheets and and apply asynchronously.
>
> This CL enables asynchronously updating the lists of active stylesheets
> applying any style changes using rule set invalidations. This means we
> more often avoid full style recalcs when we add or remove stylesheets
> from the document as well as when the evaluation of media queries
> change.
>
> In general, we now alway compare new and old stylesheets by comparing
> their rulesets and schedule style invalidations for removed and added
> rulesets.
>
> When media queries changes, we used to give completely in and
> recalculate all style once we discovered a media query changed its
> evaluation. With this patch, we clear rule sets for sheets which
> contain media queries which means we will invalidate rules for the sets
> before and after the query change. This can be further refined by only
> clearing rule sets when the sheets has a media query which actually did
> change evaluation, and also just schedule invalidations for rules which
> are inside @media rules.
>
> TreeScopeStyleSheetCollectionTest.cpp is removed as it is replaced by
> ActiveStyleSheetsTest.cpp which landed earlier.
>
> updateActiveStyle() has been added a few places where
> ensureStyleResolver() previously caused active stylesheets to be up-to-
> date. ensureStyleResolver() is now merely a method which creates the
> StyleResolver if necessary and returns it.
>
> There are some cleanups and code removal which needs to be done after
> this CL, but I have left those out to make this CL as small as
> possible. For instance resolverChanged(), which synchronously updated
> the active stylesheets, has an empty implementation instead of
> including a lot of removals in this CL. The code for lazy-appending
> stylesheets in StyleResolver is still there, but not in use.
>
> R=meade@chromium.org
> BUG=567021
>
> Committed: https://crrev.com/9fb5b60edfb769134733009f9447bad3eaf347b0
> Cr-Commit-Position: refs/heads/master@{#438148}

TBR=esprehn@chromium.org,meade@chromium.org,sashab@chromium.org,rune@opera.com
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=567021

Review-Url: https://codereview.chromium.org/2572473006
Cr-Commit-Position: refs/heads/master@{#438278}
