blink: Rename modules/ method to prefix with get when they collide.

third_party/WebKit/Source/bindings/core/v8/ScriptPromiseTest.cpp

 /*
  * Copyright (C) 2014 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 70 matching lines @@
     {
         // FIXME: We put this statement here to clear an exception from the isolate.
         createClosure(callback, v8::Undefined(m_scope.isolate()), m_scope.isolate());
 
         // Execute all pending microtasks
         v8::MicrotasksScope::PerformCheckpoint(isolate());
     }
 
     String toString(const ScriptValue& value)
     {
-        return toCoreString(value.v8Value()->ToString(scriptState()->context()).ToLocalChecked());
+        return toCoreString(value.v8Value()->ToString(getScriptState()->context()).ToLocalChecked());
     }
 
     Vector<String> toStringArray(const ScriptValue& value)
     {
         NonThrowableExceptionState exceptionState;
-        return toImplArray<Vector<String>>(value.v8Value(), 0, scriptState()->isolate(), exceptionState);
+        return toImplArray<Vector<String>>(value.v8Value(), 0, getScriptState()->isolate(), exceptionState);
     }
 
-    ScriptState* scriptState() const { return m_scope.scriptState(); }
+    ScriptState* getScriptState() const { return m_scope.getScriptState(); }
     v8::Isolate* isolate() const { return m_scope.isolate(); }
 
 protected:
     typedef ScriptPromise::InternalResolver Resolver;
     V8TestingScope m_scope;
 };
 
 TEST_F(ScriptPromiseTest, constructFromNonPromise)
 {
     v8::TryCatch trycatch(isolate());
-    ScriptPromise promise(scriptState(), v8::Undefined(isolate()));
+    ScriptPromise promise(getScriptState(), v8::Undefined(isolate()));
     ASSERT_TRUE(trycatch.HasCaught());
     ASSERT_TRUE(promise.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, thenResolve)
 {
-    Resolver resolver(scriptState());
+    Resolver resolver(getScriptState());
     ScriptPromise promise = resolver.promise();
     ScriptValue onFulfilled, onRejected;
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     resolver.resolve(v8String(isolate(), "hello"));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_EQ("hello", toString(onFulfilled));
     EXPECT_TRUE(onRejected.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, resolveThen)
 {
-    Resolver resolver(scriptState());
+    Resolver resolver(getScriptState());
     ScriptPromise promise = resolver.promise();
     ScriptValue onFulfilled, onRejected;
     resolver.resolve(v8String(isolate(), "hello"));
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_EQ("hello", toString(onFulfilled));
     EXPECT_TRUE(onRejected.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, thenReject)
 {
-    Resolver resolver(scriptState());
+    Resolver resolver(getScriptState());
     ScriptPromise promise = resolver.promise();
     ScriptValue onFulfilled, onRejected;
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     resolver.reject(v8String(isolate(), "hello"));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_EQ("hello", toString(onRejected));
 }
 
 TEST_F(ScriptPromiseTest, rejectThen)
 {
-    Resolver resolver(scriptState());
+    Resolver resolver(getScriptState());
     ScriptPromise promise = resolver.promise();
     ScriptValue onFulfilled, onRejected;
     resolver.reject(v8String(isolate(), "hello"));
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_EQ("hello", toString(onRejected));
 }
 
 TEST_F(ScriptPromiseTest, castPromise)
 {
-    ScriptPromise promise = Resolver(scriptState()).promise();
-    ScriptPromise newPromise = ScriptPromise::cast(scriptState(), promise.v8Value());
+    ScriptPromise promise = Resolver(getScriptState()).promise();
+    ScriptPromise newPromise = ScriptPromise::cast(getScriptState(), promise.v8Value());
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_EQ(promise.v8Value(), newPromise.v8Value());
 }
 
 TEST_F(ScriptPromiseTest, castNonPromise)
 {
     ScriptValue onFulfilled1, onFulfilled2, onRejected1, onRejected2;
 
-    ScriptValue value = ScriptValue(scriptState(), v8String(isolate(), "hello"));
-    ScriptPromise promise1 = ScriptPromise::cast(scriptState(), ScriptValue(value));
-    ScriptPromise promise2 = ScriptPromise::cast(scriptState(), ScriptValue(value));
-    promise1.then(Function::createFunction(scriptState(), &onFulfilled1), Function::createFunction(scriptState(), &onRejected1));
-    promise2.then(Function::createFunction(scriptState(), &onFulfilled2), Function::createFunction(scriptState(), &onRejected2));
+    ScriptValue value = ScriptValue(getScriptState(), v8String(isolate(), "hello"));
+    ScriptPromise promise1 = ScriptPromise::cast(getScriptState(), ScriptValue(value));
+    ScriptPromise promise2 = ScriptPromise::cast(getScriptState(), ScriptValue(value));
+    promise1.then(Function::createFunction(getScriptState(), &onFulfilled1), Function::createFunction(getScriptState(), &onRejected1));
+    promise2.then(Function::createFunction(getScriptState(), &onFulfilled2), Function::createFunction(getScriptState(), &onRejected2));
 
     ASSERT_FALSE(promise1.isEmpty());
     ASSERT_FALSE(promise2.isEmpty());
     EXPECT_NE(promise1.v8Value(), promise2.v8Value());
 
     ASSERT_TRUE(promise1.v8Value()->IsPromise());
     ASSERT_TRUE(promise2.v8Value()->IsPromise());
 
     EXPECT_TRUE(onFulfilled1.isEmpty());
     EXPECT_TRUE(onFulfilled2.isEmpty());
     EXPECT_TRUE(onRejected1.isEmpty());
     EXPECT_TRUE(onRejected2.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_EQ("hello", toString(onFulfilled1));
     EXPECT_EQ("hello", toString(onFulfilled2));
     EXPECT_TRUE(onRejected1.isEmpty());
     EXPECT_TRUE(onRejected2.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, reject)
 {
     ScriptValue onFulfilled, onRejected;
 
-    ScriptValue value = ScriptValue(scriptState(), v8String(isolate(), "hello"));
-    ScriptPromise promise = ScriptPromise::reject(scriptState(), ScriptValue(value));
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    ScriptValue value = ScriptValue(getScriptState(), v8String(isolate(), "hello"));
+    ScriptPromise promise = ScriptPromise::reject(getScriptState(), ScriptValue(value));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     ASSERT_TRUE(promise.v8Value()->IsPromise());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_EQ("hello", toString(onRejected));
 }
 
 TEST_F(ScriptPromiseTest, rejectWithExceptionState)
 {
     ScriptValue onFulfilled, onRejected;
-    ScriptPromise promise = ScriptPromise::rejectWithDOMException(scriptState(), DOMException::create(SyntaxError, "some syntax error"));
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    ScriptPromise promise = ScriptPromise::rejectWithDOMException(getScriptState(), DOMException::create(SyntaxError, "some syntax error"));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_EQ("SyntaxError: some syntax error", toString(onRejected));
 }
 
 TEST_F(ScriptPromiseTest, allWithEmptyPromises)
 {
     ScriptValue onFulfilled, onRejected;
 
-    ScriptPromise promise = ScriptPromise::all(scriptState(), Vector<ScriptPromise>());
+    ScriptPromise promise = ScriptPromise::all(getScriptState(), Vector<ScriptPromise>());
     ASSERT_FALSE(promise.isEmpty());
 
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_FALSE(onFulfilled.isEmpty());
     EXPECT_TRUE(toStringArray(onFulfilled).isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, allWithResolvedPromises)
 {
     ScriptValue onFulfilled, onRejected;
 
     Vector<ScriptPromise> promises;
-    promises.append(ScriptPromise::cast(scriptState(), v8String(isolate(), "hello")));
-    promises.append(ScriptPromise::cast(scriptState(), v8String(isolate(), "world")));
+    promises.append(ScriptPromise::cast(getScriptState(), v8String(isolate(), "hello")));
+    promises.append(ScriptPromise::cast(getScriptState(), v8String(isolate(), "world")));
 
-    ScriptPromise promise = ScriptPromise::all(scriptState(), promises);
+    ScriptPromise promise = ScriptPromise::all(getScriptState(), promises);
     ASSERT_FALSE(promise.isEmpty());
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_FALSE(onFulfilled.isEmpty());
     Vector<String> values = toStringArray(onFulfilled);
     EXPECT_EQ(2u, values.size());
     EXPECT_EQ("hello", values[0]);
     EXPECT_EQ("world", values[1]);
     EXPECT_TRUE(onRejected.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, allWithRejectedPromise)
 {
     ScriptValue onFulfilled, onRejected;
 
     Vector<ScriptPromise> promises;
-    promises.append(ScriptPromise::cast(scriptState(), v8String(isolate(), "hello")));
-    promises.append(ScriptPromise::reject(scriptState(), v8String(isolate(), "world")));
+    promises.append(ScriptPromise::cast(getScriptState(), v8String(isolate(), "hello")));
+    promises.append(ScriptPromise::reject(getScriptState(), v8String(isolate(), "world")));
 
-    ScriptPromise promise = ScriptPromise::all(scriptState(), promises);
+    ScriptPromise promise = ScriptPromise::all(getScriptState(), promises);
     ASSERT_FALSE(promise.isEmpty());
-    promise.then(Function::createFunction(scriptState(), &onFulfilled), Function::createFunction(scriptState(), &onRejected));
+    promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_FALSE(onRejected.isEmpty());
     EXPECT_EQ("world", toString(onRejected));
 }
 
 } // namespace
 
 } // namespace blink