blink: Rename bindings/ methods to prefix with get when they collide.

third_party/WebKit/Source/bindings/core/v8/ScriptPromisePropertyTest.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 "bindings/core/v8/ScriptPromiseProperty.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 68 matching lines @@
     size_t& m_callCount;
 };
 
 class GarbageCollectedHolder : public GarbageCollectedScriptWrappable {
 public:
     typedef ScriptPromiseProperty<Member<GarbageCollectedScriptWrappable>, Member<GarbageCollectedScriptWrappable>, Member<GarbageCollectedScriptWrappable>> Property;
     GarbageCollectedHolder(ExecutionContext* executionContext)
         : GarbageCollectedScriptWrappable("holder")
         , m_property(new Property(executionContext, toGarbageCollectedScriptWrappable(), Property::Ready)) { }
 
-    Property* property() { return m_property; }
+    Property* getProperty() { return m_property; }
     GarbageCollectedScriptWrappable* toGarbageCollectedScriptWrappable() { return this; }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         GarbageCollectedScriptWrappable::trace(visitor);
         visitor->trace(m_property);
     }
 
 private:
     Member<Property> m_property;
 };
 
 class RefCountedHolder : public RefCountedScriptWrappable {
 public:
     // Do not resolve or reject the property with the holder itself. It leads
     // to a leak.
     typedef ScriptPromiseProperty<RefCountedScriptWrappable*, RefPtr<RefCountedScriptWrappable>, RefPtr<RefCountedScriptWrappable>> Property;
     static PassRefPtr<RefCountedHolder> create(ExecutionContext* executionContext)
     {
         return adoptRef(new RefCountedHolder(executionContext));
     }
-    Property* property() { return m_property; }
+    Property* getProperty() { return m_property; }
     RefCountedScriptWrappable* toRefCountedScriptWrappable() { return this; }
 
 private:
     RefCountedHolder(ExecutionContext* executionContext)
         : RefCountedScriptWrappable("holder")
         , m_property(new Property(executionContext, toRefCountedScriptWrappable(), Property::Ready)) { }
 
     Persistent<Property> m_property;
 };
 
@@ skipping 53 matching lines @@
 class ScriptPromisePropertyGarbageCollectedTest : public ScriptPromisePropertyTestBase, public ::testing::Test {
 public:
     typedef GarbageCollectedHolder::Property Property;
 
     ScriptPromisePropertyGarbageCollectedTest()
         : m_holder(new GarbageCollectedHolder(&document()))
     {
     }
 
     GarbageCollectedHolder* holder() { return m_holder; }
-    Property* property() { return m_holder->property(); }
-    ScriptPromise promise(DOMWrapperWorld& world) { return property()->promise(world); }
+    Property* getProperty() { return m_holder->getProperty(); }
+    ScriptPromise promise(DOMWrapperWorld& world) { return getProperty()->promise(world); }
 
 private:
     Persistent<GarbageCollectedHolder> m_holder;
 };
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Promise_IsStableObjectInMainWorld)
 {
-    ScriptPromise v = property()->promise(DOMWrapperWorld::mainWorld());
-    ScriptPromise w = property()->promise(DOMWrapperWorld::mainWorld());
+    ScriptPromise v = getProperty()->promise(DOMWrapperWorld::mainWorld());
+    ScriptPromise w = getProperty()->promise(DOMWrapperWorld::mainWorld());
     EXPECT_EQ(v, w);
     ASSERT_FALSE(v.isEmpty());
     {
         ScriptState::Scope scope(mainScriptState());
         EXPECT_EQ(v.v8Value().As<v8::Object>()->CreationContext(), toV8Context(&document(), mainWorld()));
     }
-    EXPECT_EQ(Property::Pending, property()->getState());
+    EXPECT_EQ(Property::Pending, getProperty()->getState());
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Promise_IsStableObjectInVariousWorlds)
 {
-    ScriptPromise u = property()->promise(otherWorld());
-    ScriptPromise v = property()->promise(DOMWrapperWorld::mainWorld());
-    ScriptPromise w = property()->promise(DOMWrapperWorld::mainWorld());
+    ScriptPromise u = getProperty()->promise(otherWorld());
+    ScriptPromise v = getProperty()->promise(DOMWrapperWorld::mainWorld());
+    ScriptPromise w = getProperty()->promise(DOMWrapperWorld::mainWorld());
     EXPECT_NE(mainScriptState(), otherScriptState());
     EXPECT_NE(&mainWorld(), &otherWorld());
     EXPECT_NE(u, v);
     EXPECT_EQ(v, w);
     ASSERT_FALSE(u.isEmpty());
     ASSERT_FALSE(v.isEmpty());
     {
         ScriptState::Scope scope(otherScriptState());
         EXPECT_EQ(u.v8Value().As<v8::Object>()->CreationContext(), toV8Context(&document(), otherWorld()));
     }
     {
         ScriptState::Scope scope(mainScriptState());
         EXPECT_EQ(v.v8Value().As<v8::Object>()->CreationContext(), toV8Context(&document(), mainWorld()));
     }
-    EXPECT_EQ(Property::Pending, property()->getState());
+    EXPECT_EQ(Property::Pending, getProperty()->getState());
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Promise_IsStableObjectAfterSettling)
 {
     ScriptPromise v = promise(DOMWrapperWorld::mainWorld());
     GarbageCollectedScriptWrappable* value = new GarbageCollectedScriptWrappable("value");
 
-    property()->resolve(value);
-    EXPECT_EQ(Property::Resolved, property()->getState());
+    getProperty()->resolve(value);
+    EXPECT_EQ(Property::Resolved, getProperty()->getState());
 
     ScriptPromise w = promise(DOMWrapperWorld::mainWorld());
     EXPECT_EQ(v, w);
     EXPECT_FALSE(v.isEmpty());
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Promise_DoesNotImpedeGarbageCollection)
 {
     ScriptValue holderWrapper = wrap(mainWorld(), holder()->toGarbageCollectedScriptWrappable());
 
     Persistent<GCObservation> observation;
     {
         ScriptState::Scope scope(mainScriptState());
         observation = GCObservation::create(promise(DOMWrapperWorld::mainWorld()).v8Value());
     }
 
     gc();
     EXPECT_FALSE(observation->wasCollected());
 
     holderWrapper.clear();
     gc();
     EXPECT_TRUE(observation->wasCollected());
 
-    EXPECT_EQ(Property::Pending, property()->getState());
+    EXPECT_EQ(Property::Pending, getProperty()->getState());
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Resolve_ResolvesScriptPromise)
 {
-    ScriptPromise promise = property()->promise(DOMWrapperWorld::mainWorld());
-    ScriptPromise otherPromise = property()->promise(otherWorld());
+    ScriptPromise promise = getProperty()->promise(DOMWrapperWorld::mainWorld());
+    ScriptPromise otherPromise = getProperty()->promise(otherWorld());
     ScriptValue actual, otherActual;
     size_t nResolveCalls = 0;
     size_t nOtherResolveCalls = 0;
 
     {
         ScriptState::Scope scope(mainScriptState());
         promise.then(stub(currentScriptState(), actual, nResolveCalls), notReached(currentScriptState()));
     }
 
     {
         ScriptState::Scope scope(otherScriptState());
         otherPromise.then(stub(currentScriptState(), otherActual, nOtherResolveCalls), notReached(currentScriptState()));
     }
 
     EXPECT_NE(promise, otherPromise);
 
     GarbageCollectedScriptWrappable* value = new GarbageCollectedScriptWrappable("value");
-    property()->resolve(value);
-    EXPECT_EQ(Property::Resolved, property()->getState());
+    getProperty()->resolve(value);
+    EXPECT_EQ(Property::Resolved, getProperty()->getState());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nResolveCalls);
     EXPECT_EQ(1u, nOtherResolveCalls);
     EXPECT_EQ(wrap(mainWorld(), value), actual);
     EXPECT_NE(actual, otherActual);
     EXPECT_EQ(wrap(otherWorld(), value), otherActual);
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, ResolveAndGetPromiseOnOtherWorld)
 {
-    ScriptPromise promise = property()->promise(DOMWrapperWorld::mainWorld());
-    ScriptPromise otherPromise = property()->promise(otherWorld());
+    ScriptPromise promise = getProperty()->promise(DOMWrapperWorld::mainWorld());
+    ScriptPromise otherPromise = getProperty()->promise(otherWorld());
     ScriptValue actual, otherActual;
     size_t nResolveCalls = 0;
     size_t nOtherResolveCalls = 0;
 
     {
         ScriptState::Scope scope(mainScriptState());
         promise.then(stub(currentScriptState(), actual, nResolveCalls), notReached(currentScriptState()));
     }
 
     EXPECT_NE(promise, otherPromise);
     GarbageCollectedScriptWrappable* value = new GarbageCollectedScriptWrappable("value");
-    property()->resolve(value);
-    EXPECT_EQ(Property::Resolved, property()->getState());
+    getProperty()->resolve(value);
+    EXPECT_EQ(Property::Resolved, getProperty()->getState());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nResolveCalls);
     EXPECT_EQ(0u, nOtherResolveCalls);
 
     {
         ScriptState::Scope scope(otherScriptState());
         otherPromise.then(stub(currentScriptState(), otherActual, nOtherResolveCalls), notReached(currentScriptState()));
     }
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nResolveCalls);
     EXPECT_EQ(1u, nOtherResolveCalls);
     EXPECT_EQ(wrap(mainWorld(), value), actual);
     EXPECT_NE(actual, otherActual);
     EXPECT_EQ(wrap(otherWorld(), value), otherActual);
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Reject_RejectsScriptPromise)
 {
     GarbageCollectedScriptWrappable* reason = new GarbageCollectedScriptWrappable("reason");
-    property()->reject(reason);
-    EXPECT_EQ(Property::Rejected, property()->getState());
+    getProperty()->reject(reason);
+    EXPECT_EQ(Property::Rejected, getProperty()->getState());
 
     ScriptValue actual, otherActual;
     size_t nRejectCalls = 0;
     size_t nOtherRejectCalls = 0;
     {
         ScriptState::Scope scope(mainScriptState());
-        property()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), actual, nRejectCalls));
+        getProperty()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), actual, nRejectCalls));
     }
 
     {
         ScriptState::Scope scope(otherScriptState());
-        property()->promise(otherWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), otherActual, nOtherRejectCalls));
+        getProperty()->promise(otherWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), otherActual, nOtherRejectCalls));
     }
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nRejectCalls);
     EXPECT_EQ(wrap(mainWorld(), reason), actual);
     EXPECT_EQ(1u, nOtherRejectCalls);
     EXPECT_NE(actual, otherActual);
     EXPECT_EQ(wrap(otherWorld(), reason), otherActual);
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Promise_DeadContext)
 {
-    property()->resolve(new GarbageCollectedScriptWrappable("value"));
-    EXPECT_EQ(Property::Resolved, property()->getState());
+    getProperty()->resolve(new GarbageCollectedScriptWrappable("value"));
+    EXPECT_EQ(Property::Resolved, getProperty()->getState());
 
     destroyContext();
 
-    EXPECT_TRUE(property()->promise(DOMWrapperWorld::mainWorld()).isEmpty());
+    EXPECT_TRUE(getProperty()->promise(DOMWrapperWorld::mainWorld()).isEmpty());
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Resolve_DeadContext)
 {
     {
         ScriptState::Scope scope(mainScriptState());
-        property()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), notReached(currentScriptState()));
+        getProperty()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), notReached(currentScriptState()));
     }
 
     destroyContext();
-    EXPECT_TRUE(!property()->getExecutionContext() || property()->getExecutionContext()->activeDOMObjectsAreStopped());
+    EXPECT_TRUE(!getProperty()->getExecutionContext() || getProperty()->getExecutionContext()->activeDOMObjectsAreStopped());
 
-    property()->resolve(new GarbageCollectedScriptWrappable("value"));
-    EXPECT_EQ(Property::Pending, property()->getState());
+    getProperty()->resolve(new GarbageCollectedScriptWrappable("value"));
+    EXPECT_EQ(Property::Pending, getProperty()->getState());
 
     v8::MicrotasksScope::PerformCheckpoint(v8::Isolate::GetCurrent());
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Reset)
 {
     ScriptPromise oldPromise, newPromise;
     ScriptValue oldActual, newActual;
     GarbageCollectedScriptWrappable* oldValue = new GarbageCollectedScriptWrappable("old");
     GarbageCollectedScriptWrappable* newValue = new GarbageCollectedScriptWrappable("new");
     size_t nOldResolveCalls = 0;
     size_t nNewRejectCalls = 0;
 
     {
         ScriptState::Scope scope(mainScriptState());
-        property()->resolve(oldValue);
-        oldPromise = property()->promise(mainWorld());
+        getProperty()->resolve(oldValue);
+        oldPromise = getProperty()->promise(mainWorld());
         oldPromise.then(stub(currentScriptState(), oldActual, nOldResolveCalls), notReached(currentScriptState()));
     }
 
-    property()->reset();
+    getProperty()->reset();
 
     {
         ScriptState::Scope scope(mainScriptState());
-        newPromise = property()->promise(mainWorld());
+        newPromise = getProperty()->promise(mainWorld());
         newPromise.then(notReached(currentScriptState()), stub(currentScriptState(), newActual, nNewRejectCalls));
-        property()->reject(newValue);
+        getProperty()->reject(newValue);
     }
 
     EXPECT_EQ(0u, nOldResolveCalls);
     EXPECT_EQ(0u, nNewRejectCalls);
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nOldResolveCalls);
     EXPECT_EQ(1u, nNewRejectCalls);
     EXPECT_NE(oldPromise, newPromise);
     EXPECT_EQ(wrap(mainWorld(), oldValue), oldActual);
     EXPECT_EQ(wrap(mainWorld(), newValue), newActual);
     EXPECT_NE(oldActual, newActual);
 }
 
 // Tests that ScriptPromiseProperty works with a ref-counted holder.
 class ScriptPromisePropertyRefCountedTest : public ScriptPromisePropertyTestBase, public ::testing::Test {
 public:
     typedef RefCountedHolder::Property Property;
 
     ScriptPromisePropertyRefCountedTest()
         : m_holder(RefCountedHolder::create(&document()))
     {
     }
 
     RefCountedHolder* holder() { return m_holder.get(); }
-    Property* property() { return m_holder->property(); }
+    Property* getProperty() { return m_holder->getProperty(); }
 
 private:
     RefPtr<RefCountedHolder> m_holder;
 };
 
 TEST_F(ScriptPromisePropertyRefCountedTest, Resolve)
 {
     ScriptValue actual;
     size_t nResolveCalls = 0;
 
     {
         ScriptState::Scope scope(mainScriptState());
-        property()->promise(DOMWrapperWorld::mainWorld()).then(stub(currentScriptState(), actual, nResolveCalls), notReached(currentScriptState()));
+        getProperty()->promise(DOMWrapperWorld::mainWorld()).then(stub(currentScriptState(), actual, nResolveCalls), notReached(currentScriptState()));
     }
 
     RefPtr<RefCountedScriptWrappable> value = RefCountedScriptWrappable::create("value");
-    property()->resolve(value.get());
-    EXPECT_EQ(Property::Resolved, property()->getState());
+    getProperty()->resolve(value.get());
+    EXPECT_EQ(Property::Resolved, getProperty()->getState());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nResolveCalls);
     EXPECT_EQ(wrap(mainWorld(), value), actual);
 }
 
 TEST_F(ScriptPromisePropertyRefCountedTest, Reject)
 {
     ScriptValue actual;
     size_t nRejectCalls = 0;
 
     {
         ScriptState::Scope scope(mainScriptState());
-        property()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), actual, nRejectCalls));
+        getProperty()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), actual, nRejectCalls));
     }
 
     RefPtr<RefCountedScriptWrappable> reason = RefCountedScriptWrappable::create("reason");
-    property()->reject(reason);
-    EXPECT_EQ(Property::Rejected, property()->getState());
+    getProperty()->reject(reason);
+    EXPECT_EQ(Property::Rejected, getProperty()->getState());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nRejectCalls);
     EXPECT_EQ(wrap(mainWorld(), reason), actual);
 }
 
 TEST_F(ScriptPromisePropertyRefCountedTest, ReSolveAndReset)
 {
     RefPtr<RefCountedScriptWrappable> value = RefCountedScriptWrappable::create("value");
 
     {
         ScriptState::Scope scope(mainScriptState());
-        property()->resolve(value);
+        getProperty()->resolve(value);
     }
 
     EXPECT_EQ(2, value->refCount());
-    property()->reset();
+    getProperty()->reset();
     EXPECT_EQ(1, value->refCount());
 }
 
 TEST_F(ScriptPromisePropertyRefCountedTest, RejectAndReset)
 {
     RefPtr<RefCountedScriptWrappable> value = RefCountedScriptWrappable::create("value");
 
     {
         ScriptState::Scope scope(mainScriptState());
-        property()->reject(value.get());
+        getProperty()->reject(value.get());
     }
 
     EXPECT_EQ(2, value->refCount());
-    property()->reset();
+    getProperty()->reset();
     EXPECT_EQ(1, value->refCount());
 }
 
 // Tests that ScriptPromiseProperty works with a non ScriptWrappable resolution
 // target.
 class ScriptPromisePropertyNonScriptWrappableResolutionTargetTest : public ScriptPromisePropertyTestBase, public ::testing::Test {
 public:
     template <typename T>
     void test(const T& value, const char* expected, const char* file, size_t line)
     {
@@ skipping 28 matching lines @@
 {
     test(String("hello"), "hello", __FILE__, __LINE__);
 }
 
 TEST_F(ScriptPromisePropertyNonScriptWrappableResolutionTargetTest, ResolveWithInteger)
 {
     test(-1, "-1", __FILE__, __LINE__);
 }
 
 } // namespace