Revert of Ensure DOMWrapperWorld always exists in all webkit_unit_tests

Source/core/animation/AnimationTest.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 "config.h"
 #include "core/animation/Animation.h"
 
 #include "bindings/v8/Dictionary.h"
 #include "core/animation/AnimatableLength.h"
 #include "core/animation/AnimationClock.h"
@@ skipping 18 matching lines @@
         EXPECT_EQ(0, document->timeline().currentTime());
     }
 
     RefPtr<Document> document;
     RefPtr<Element> element;
 };
 
 class AnimationAnimationV8Test : public AnimationAnimationTest {
 protected:
     AnimationAnimationV8Test()
-        : m_isolate(v8::Isolate::GetCurrent())
-        , m_scope(V8BindingTestScope::create(m_isolate))
+        : isolate(v8::Isolate::GetCurrent())
+        , scope(isolate)
+        , context(v8::Context::New(isolate))
+        , contextScope(context)
     {
     }
 
+    v8::Isolate* isolate;
+    v8::HandleScope scope;
+    v8::Local<v8::Context> context;
+    v8::Context::Scope contextScope;
+
     PassRefPtr<Animation> createAnimation(Element* element, Vector<Dictionary> keyframeDictionaryVector, Dictionary timingInput)
     {
         return Animation::createUnsafe(element, keyframeDictionaryVector, timingInput);
     }
 
     PassRefPtr<Animation> createAnimation(Element* element, Vector<Dictionary> keyframeDictionaryVector, double timingInput)
     {
         return Animation::createUnsafe(element, keyframeDictionaryVector, timingInput);
     }
 
     PassRefPtr<Animation> createAnimation(Element* element, Vector<Dictionary> keyframeDictionaryVector)
     {
         return Animation::createUnsafe(element, keyframeDictionaryVector);
     }
-
-    v8::Isolate* m_isolate;
-
-private:
-    OwnPtr<V8BindingTestScope> m_scope;
 };
 
 TEST_F(AnimationAnimationV8Test, CanCreateAnAnimation)
 {
     Vector<Dictionary> jsKeyframes;
-    v8::Handle<v8::Object> keyframe1 = v8::Object::New(m_isolate);
-    v8::Handle<v8::Object> keyframe2 = v8::Object::New(m_isolate);
+    v8::Handle<v8::Object> keyframe1 = v8::Object::New(isolate);
+    v8::Handle<v8::Object> keyframe2 = v8::Object::New(isolate);
 
     setV8ObjectPropertyAsString(keyframe1, "width", "100px");
     setV8ObjectPropertyAsString(keyframe1, "offset", "0");
     setV8ObjectPropertyAsString(keyframe1, "easing", "ease-in-out");
     setV8ObjectPropertyAsString(keyframe2, "width", "0px");
     setV8ObjectPropertyAsString(keyframe2, "offset", "1");
     setV8ObjectPropertyAsString(keyframe2, "easing", "cubic-bezier(1, 1, 0.3, 0.3)");
 
-    jsKeyframes.append(Dictionary(keyframe1, m_isolate));
-    jsKeyframes.append(Dictionary(keyframe2, m_isolate));
+    jsKeyframes.append(Dictionary(keyframe1, isolate));
+    jsKeyframes.append(Dictionary(keyframe2, isolate));
 
     String value1;
     ASSERT_TRUE(jsKeyframes[0].get("width", value1));
     ASSERT_EQ("100px", value1);
 
     String value2;
     ASSERT_TRUE(jsKeyframes[1].get("width", value2));
     ASSERT_EQ("0px", value2);
 
     RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, 0);
@@ skipping 43 matching lines @@
 {
     Vector<Dictionary, 0> jsKeyframes;
     RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, -2);
     EXPECT_EQ(0, animation->specifiedTiming().iterationDuration);
 }
 
 TEST_F(AnimationAnimationV8Test, SpecifiedGetters)
 {
     Vector<Dictionary, 0> jsKeyframes;
 
-    v8::Handle<v8::Object> timingInput = v8::Object::New(m_isolate);
+    v8::Handle<v8::Object> timingInput = v8::Object::New(isolate);
     setV8ObjectPropertyAsNumber(timingInput, "delay", 2);
     setV8ObjectPropertyAsNumber(timingInput, "endDelay", 0.5);
     setV8ObjectPropertyAsString(timingInput, "fill", "backwards");
     setV8ObjectPropertyAsNumber(timingInput, "iterationStart", 2);
     setV8ObjectPropertyAsNumber(timingInput, "iterations", 10);
     setV8ObjectPropertyAsNumber(timingInput, "playbackRate", 2);
     setV8ObjectPropertyAsString(timingInput, "direction", "reverse");
     setV8ObjectPropertyAsString(timingInput, "easing", "step-start");
-    Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), m_isolate);
+    Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), isolate);
 
     RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary);
 
     RefPtr<TimedItemTiming> specified = animation->specified();
     EXPECT_EQ(2, specified->delay());
     EXPECT_EQ(0.5, specified->endDelay());
     EXPECT_EQ("backwards", specified->fill());
     EXPECT_EQ(2, specified->iterationStart());
     EXPECT_EQ(10, specified->iterations());
     EXPECT_EQ(2, specified->playbackRate());
     EXPECT_EQ("reverse", specified->direction());
     EXPECT_EQ("step-start", specified->easing());
 }
 
 TEST_F(AnimationAnimationV8Test, SpecifiedDurationGetter)
 {
     Vector<Dictionary, 0> jsKeyframes;
 
-    v8::Handle<v8::Object> timingInputWithDuration = v8::Object::New(m_isolate);
+    v8::Handle<v8::Object> timingInputWithDuration = v8::Object::New(isolate);
     setV8ObjectPropertyAsNumber(timingInputWithDuration, "duration", 2.5);
-    Dictionary timingInputDictionaryWithDuration = Dictionary(v8::Handle<v8::Value>::Cast(timingInputWithDuration), m_isolate);
+    Dictionary timingInputDictionaryWithDuration = Dictionary(v8::Handle<v8::Value>::Cast(timingInputWithDuration), isolate);
 
     RefPtr<Animation> animationWithDuration = createAnimation(element.get(), jsKeyframes, timingInputDictionaryWithDuration);
 
     RefPtr<TimedItemTiming> specifiedWithDuration = animationWithDuration->specified();
     bool isNumber = false;
     double numberDuration = std::numeric_limits<double>::quiet_NaN();
     bool isString = false;
     String stringDuration = "";
     specifiedWithDuration->getDuration("duration", isNumber, numberDuration, isString, stringDuration);
     EXPECT_TRUE(isNumber);
     EXPECT_EQ(2.5, numberDuration);
     EXPECT_FALSE(isString);
     EXPECT_EQ("", stringDuration);
 
 
-    v8::Handle<v8::Object> timingInputNoDuration = v8::Object::New(m_isolate);
-    Dictionary timingInputDictionaryNoDuration = Dictionary(v8::Handle<v8::Value>::Cast(timingInputNoDuration), m_isolate);
+    v8::Handle<v8::Object> timingInputNoDuration = v8::Object::New(isolate);
+    Dictionary timingInputDictionaryNoDuration = Dictionary(v8::Handle<v8::Value>::Cast(timingInputNoDuration), isolate);
 
     RefPtr<Animation> animationNoDuration = createAnimation(element.get(), jsKeyframes, timingInputDictionaryNoDuration);
 
     RefPtr<TimedItemTiming> specifiedNoDuration = animationNoDuration->specified();
     isNumber = false;
     numberDuration = std::numeric_limits<double>::quiet_NaN();
     isString = false;
     stringDuration = "";
     specifiedNoDuration->getDuration("duration", isNumber, numberDuration, isString, stringDuration);
     EXPECT_FALSE(isNumber);
     EXPECT_TRUE(std::isnan(numberDuration));
     EXPECT_TRUE(isString);
     EXPECT_EQ("auto", stringDuration);
 }
 
 TEST_F(AnimationAnimationV8Test, SpecifiedSetters)
 {
     Vector<Dictionary, 0> jsKeyframes;
-    v8::Handle<v8::Object> timingInput = v8::Object::New(m_isolate);
-    Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), m_isolate);
+    v8::Handle<v8::Object> timingInput = v8::Object::New(isolate);
+    Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), isolate);
     RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary);
 
     RefPtr<TimedItemTiming> specified = animation->specified();
 
     EXPECT_EQ(0, specified->delay());
     specified->setDelay(2);
     EXPECT_EQ(2, specified->delay());
 
     EXPECT_EQ(0, specified->endDelay());
     specified->setEndDelay(0.5);
@@ skipping 20 matching lines @@
     EXPECT_EQ("reverse", specified->direction());
 
     EXPECT_EQ("linear", specified->easing());
     specified->setEasing("step-start");
     EXPECT_EQ("step-start", specified->easing());
 }
 
 TEST_F(AnimationAnimationV8Test, SetSpecifiedDuration)
 {
     Vector<Dictionary, 0> jsKeyframes;
-    v8::Handle<v8::Object> timingInput = v8::Object::New(m_isolate);
-    Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), m_isolate);
+    v8::Handle<v8::Object> timingInput = v8::Object::New(isolate);
+    Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), isolate);
     RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary);
 
     RefPtr<TimedItemTiming> specified = animation->specified();
 
     bool isNumber = false;
     double numberDuration = std::numeric_limits<double>::quiet_NaN();
     bool isString = false;
     String stringDuration = "";
     specified->getDuration("duration", isNumber, numberDuration, isString, stringDuration);
     EXPECT_FALSE(isNumber);
@@ skipping 104 matching lines @@
     player->setCurrentTime(150);
     EXPECT_EQ(inf, animation->timeToForwardsEffectChange());
     EXPECT_EQ(0, animation->timeToReverseEffectChange());
 
     player->setCurrentTime(200);
     EXPECT_EQ(inf, animation->timeToForwardsEffectChange());
     EXPECT_EQ(50, animation->timeToReverseEffectChange());
 }
 
 } // namespace WebCore