Move rendering/RenderObject to layout/LayoutObject.

Source/core/animation/CompositorAnimationsTest.cpp

 /*
  * 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 25 matching lines @@
 #include "core/animation/Animation.h"
 #include "core/animation/AnimationPlayer.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorAnimationsImpl.h"
 #include "core/animation/CompositorAnimationsTestHelper.h"
 #include "core/animation/animatable/AnimatableDouble.h"
 #include "core/animation/animatable/AnimatableFilterOperations.h"
 #include "core/animation/animatable/AnimatableTransform.h"
 #include "core/animation/animatable/AnimatableValueTestHelper.h"
 #include "core/dom/Document.h"
-#include "core/rendering/RenderObject.h"
+#include "core/layout/LayoutObject.h"
 #include "platform/geometry/FloatBox.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/filters/FilterOperations.h"
 #include "platform/transforms/TransformOperations.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 #include "public/platform/WebCompositorAnimation.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
@@ skipping 190 matching lines @@
     }
 
     void simulateFrame(double time)
     {
         m_document->animationClock().updateTime(time);
         m_document->compositorPendingAnimations().update(false);
         m_timeline->serviceAnimations(TimingUpdateForAnimationFrame);
     }
 };
 
-class RenderObjectProxy : public RenderObject {
+class LayoutObjectProxy : public LayoutObject {
 public:
-    static RenderObjectProxy* create(Node* node)
+    static LayoutObjectProxy* create(Node* node)
     {
-        return new RenderObjectProxy(node);
+        return new LayoutObjectProxy(node);
     }
 
-    static void dispose(RenderObjectProxy* proxy)
+    static void dispose(LayoutObjectProxy* proxy)
     {
         proxy->destroy();
     }
 
     const char* renderName() const override { return nullptr; }
     void layout() override { }
 
 private:
-    explicit RenderObjectProxy(Node* node)
-        : RenderObject(node)
+    explicit LayoutObjectProxy(Node* node)
+        : LayoutObject(node)
     {
     }
 };
 
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 
 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositorKeyframeMultipleCSSProperties)
 {
     RefPtrWillBeRawPtr<AnimatableValueKeyframe> keyframeGoodMultiple = createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace);
@@ skipping 911 matching lines @@
     result[0].clear();
 }
 
 TEST_F(AnimationCompositorAnimationsTest, CancelIncompatibleCompositorAnimations)
 {
     WebCompositorSupportMock mockCompositor;
     setCompositorForTesting(mockCompositor);
 
     RefPtrWillBePersistent<Element> element = m_document->createElement("shared", ASSERT_NO_EXCEPTION);
 
-    RenderObjectProxy* renderer = RenderObjectProxy::create(element.get());
+    LayoutObjectProxy* renderer = LayoutObjectProxy::create(element.get());
     element->setRenderer(renderer);
 
     AnimatableValueKeyframeVector keyFrames;
     keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 0.0).get());
     keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity, AnimationEffect::CompositeReplace, 1.0).get());
     RefPtrWillBeRawPtr<AnimationEffect> animationEffect1 = AnimatableValueKeyframeEffectModel::create(keyFrames);
     RefPtrWillBeRawPtr<AnimationEffect> animationEffect2 = AnimatableValueKeyframeEffectModel::create(keyFrames);
 
     Timing timing;
     timing.iterationDuration = 1.f;
@@ skipping 19 matching lines @@
     player2->cancelIncompatibleAnimationsOnCompositor();
 
     EXPECT_FALSE(player1->hasActiveAnimationsOnCompositor());
     EXPECT_FALSE(player2->hasActiveAnimationsOnCompositor());
 
     simulateFrame(0);
     EXPECT_EQ(2U, element->activeAnimations()->players().size());
     simulateFrame(1.);
 
     element->setRenderer(nullptr);
-    RenderObjectProxy::dispose(renderer);
+    LayoutObjectProxy::dispose(renderer);
 
     player1.release();
     player2.release();
     Heap::collectAllGarbage();
     EXPECT_TRUE(element->activeAnimations()->players().isEmpty());
 }
 
 } // namespace blink