CC Animation: Move files from cc_blink to Source/platform/animation

third_party/WebKit/Source/platform/scroll/ScrollAnimatorCompositorCoordinator.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/scroll/ScrollAnimatorCompositorCoordinator.h"
 
+#include "cc/animation/animation_player.h"

[jbroman, 2016/02/01 15:44:36]

Are cc includes needed here?

[loyso (OOO), 2016/02/04 05:49:29]

I wanted to use forward declaration of cc::AnimationPlayer/Timeline for
blink::CompositorAnimationPlayer/CompositorAnimationTimeline (surprisingly,
clang and gcc tolerate scoped_refptr for a forward-declared class with intrusive
refcounted base). MSVC doesn't tolerate that, so it forces one to include CC's
AnimationPlayer header if you include CompositorAnimationPlayer.h.

That's weird. Let's include full headers then. Must work ok.

+#include "cc/animation/animation_timeline.h"
+#include "platform/CompositorFactory.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/animation/CompositorAnimationPlayer.h"
+#include "platform/animation/CompositorAnimationTimeline.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "public/platform/Platform.h"
-#include "public/platform/WebCompositorAnimationPlayer.h"
-#include "public/platform/WebCompositorAnimationTimeline.h"
 #include "public/platform/WebCompositorSupport.h"
 
 namespace blink {
 
 ScrollAnimatorCompositorCoordinator::ScrollAnimatorCompositorCoordinator()
     : m_compositorAnimationAttachedToLayerId(0)
     , m_runState(RunState::Idle)
     , m_compositorAnimationId(0)
     , m_compositorAnimationGroupId(0)
 {
     if (RuntimeEnabledFeatures::compositorAnimationTimelinesEnabled()) {
         ASSERT(Platform::current()->compositorSupport());
-        m_compositorPlayer = adoptPtr(Platform::current()->compositorSupport()->createAnimationPlayer());
+        m_compositorPlayer = adoptPtr(CompositorFactory::current().createAnimationPlayer());
         ASSERT(m_compositorPlayer);
         m_compositorPlayer->setAnimationDelegate(this);
     }
 }
 
 ScrollAnimatorCompositorCoordinator::~ScrollAnimatorCompositorCoordinator()
 {
     if (m_compositorPlayer) {
         m_compositorPlayer->setAnimationDelegate(nullptr);
         m_compositorPlayer.clear();
@@ skipping 17 matching lines @@
     case RunState::RunningOnMainThread:
     case RunState::RunningOnCompositorButNeedsUpdate:
     case RunState::WaitingToCancelOnCompositor:
         return true;
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
 bool ScrollAnimatorCompositorCoordinator::addAnimation(
-    PassOwnPtr<WebCompositorAnimation> animation)
+    PassOwnPtr<CompositorAnimation> animation)
 {
     if (m_compositorPlayer) {
         if (m_compositorPlayer->isLayerAttached()) {
             m_compositorPlayer->addAnimation(animation.leakPtr());
             return true;
         }
     } else {
         return scrollableArea()->layerForScrolling()->addAnimation(animation);
     }
     return false;
@@ skipping 64 matching lines @@
     case RunState::WaitingToSendToCompositor:
         break;
     case RunState::RunningOnCompositor:
     case RunState::RunningOnCompositorButNeedsUpdate:
     case RunState::WaitingToCancelOnCompositor:
         resetAnimationState();
     }
 }
 
 void ScrollAnimatorCompositorCoordinator::reattachCompositorPlayerIfNeeded(
-    WebCompositorAnimationTimeline* timeline)
+    CompositorAnimationTimeline* timeline)
 {
     int compositorAnimationAttachedToLayerId = 0;
     if (scrollableArea()->layerForScrolling())
         compositorAnimationAttachedToLayerId = scrollableArea()->layerForScrolling()->platformLayer()->id();
 
     if (compositorAnimationAttachedToLayerId != m_compositorAnimationAttachedToLayerId) {
         if (m_compositorPlayer && timeline) {
             // Detach from old layer (if any).
             if (m_compositorAnimationAttachedToLayerId) {
                 if (m_compositorPlayer->isLayerAttached())
@@ skipping 24 matching lines @@
 }
 
 void ScrollAnimatorCompositorCoordinator::notifyAnimationAborted(
     double monotonicTime, int group)
 {
     // An animation aborted by the compositor is treated as a finished
     // animation.
     notifyCompositorAnimationFinished(group);
 }
 
-WebCompositorAnimationPlayer* ScrollAnimatorCompositorCoordinator::compositorPlayer() const
+CompositorAnimationPlayer* ScrollAnimatorCompositorCoordinator::compositorPlayer() const
 {
     return m_compositorPlayer.get();
 }
 
 } // namespace blink