[SPv2] Decomposite otherwise-compositable animations that paint nothing.

third_party/WebKit/Source/core/animation/Animation.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Animation_h
 #define Animation_h
 
+#include <memory>

[pdr., 2017/03/16 21:20:04]

It took me a little while to page this back in. Can you add a summary to the
description?

The big points seem to be:
* In SPV1, layers are always created for composited animations so we are sure
the compositor gets the associated element id off the layer.
* In SPV2 we can optimize out even creating a paint chunk for opacity=0
animations, and the compositor never finds out about opacity=0 animations.
* This change ensures SPV2 only starts compositor animations with element ids
that were composited, effectively forcing non-composited animations back to the
main thread.

[wkorman, 2017/03/16 21:53:31]

Will do.
Rather than being about opacity = 0, this patch is aimed at the issue that, for
animated elements that paint no content at all, we never create a layer, thus
there is no layer to associated with a compositor element id in cc, and cc can't
run the composited animation.

The opacity = 0 issue you may be recalling is the one we addressed previously in
http://crrev.com/2652273004 but that case still involved elements that do
actually paint something (for example, they have a background with some color).
For elements that literally end up painting nothing at all because they have no
content, background or other painting-required style, we hit the case this bug
is about and this patch is trying to address.
Correct, I would rephrase the "element ids that were composited" bit slightly
for clarity. Something like, "...only starts compositor animations with element
ids for which we created a cc layer."

 #include "bindings/core/v8/ActiveScriptWrappable.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseProperty.h"
 #include "core/CSSPropertyNames.h"
 #include "core/CoreExport.h"
 #include "core/animation/AnimationEffectReadOnly.h"
 #include "core/dom/ContextLifecycleObserver.h"
 #include "core/dom/DOMException.h"
 #include "core/events/EventTarget.h"
 #include "platform/animation/CompositorAnimationDelegate.h"
 #include "platform/animation/CompositorAnimationPlayerClient.h"
+#include "platform/graphics/compositing/PaintArtifactCompositor.h"
 #include "platform/heap/Handle.h"
 #include "wtf/RefPtr.h"
-#include <memory>
 
 namespace blink {
 
 class AnimationTimeline;
 class CompositorAnimationPlayer;
 class Element;
 class ExceptionState;
 class TreeScope;
 
 class CORE_EXPORT Animation final : public EventTargetWithInlineData,
@@ skipping 83 matching lines @@
   // paused() and must never overlap with pausing via pause().
   void pauseForTesting(double pauseTime);
   void disableCompositedAnimationForTesting();
 
   // This should only be used for CSS
   void unpause();
 
   void setOutdated();
   bool outdated() { return m_outdated; }
 
-  bool canStartAnimationOnCompositor() const;
-  bool isCandidateForAnimationOnCompositor() const;
-  bool maybeStartAnimationOnCompositor();
+  bool canStartAnimationOnCompositor(const Optional<CompositorElementIdSet>&
+                                         compositedAnimationElementIds) const;
+  bool isCandidateForAnimationOnCompositor(
+      const Optional<CompositorElementIdSet>& compositedAnimationElementIds)
+      const;
+  bool maybeStartAnimationOnCompositor(
+      const Optional<CompositorElementIdSet>& compositedAnimationElementIds);
   void cancelAnimationOnCompositor();
   void restartAnimationOnCompositor();
   void cancelIncompatibleAnimationsOnCompositor();
   bool hasActiveAnimationsOnCompositor();
   void setCompositorPending(bool effectChanged = false);
   void notifyCompositorStartTime(double timelineTime);
   void notifyStartTime(double timelineTime);
   // CompositorAnimationPlayerClient implementation.
   CompositorAnimationPlayer* compositorPlayer() const override {
     return m_compositorPlayer ? m_compositorPlayer->player() : nullptr;
   }
 
   bool affects(const Element&, CSSPropertyID) const;
 
   // Returns whether we should continue with the commit for this animation or
   // wait until next commit.
-  bool preCommit(int compositorGroup, bool startOnCompositor);
+  bool preCommit(int compositorGroup,
+                 const Optional<CompositorElementIdSet>&,
+                 bool startOnCompositor);
   void postCommit(double timelineTime);
 
   unsigned sequenceNumber() const { return m_sequenceNumber; }
   int compositorGroup() const { return m_compositorGroup; }
 
   static bool hasLowerPriority(const Animation* animation1,
                                const Animation* animation2) {
     return animation1->sequenceNumber() < animation2->sequenceNumber();
   }
 
@@ skipping 156 matching lines @@
 
   bool m_currentTimePending;
   bool m_stateIsBeingUpdated;
 
   bool m_effectSuppressed;
 };
 
 }  // namespace blink
 
 #endif  // Animation_h