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

third_party/WebKit/Source/core/streams/ReadableStreamTest.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 "core/streams/ReadableStream.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 33 matching lines @@
 private:
     StringCapturingFunction(ScriptState* scriptState, String* value)
         : ScriptFunction(scriptState)
         , m_value(value)
     {
     }
 
     ScriptValue call(ScriptValue value) override
     {
         ASSERT(!value.isEmpty());
-        *m_value = toCoreString(value.v8Value()->ToString(scriptState()->context()).ToLocalChecked());
+        *m_value = toCoreString(value.v8Value()->ToString(getScriptState()->context()).ToLocalChecked());
         return value;
     }
 
     String* m_value;
 };
 
 class MockUnderlyingSource : public GarbageCollectedFinalized<MockUnderlyingSource>, public UnderlyingSource {
     USING_GARBAGE_COLLECTED_MIXIN(MockUnderlyingSource);
 public:
     ~MockUnderlyingSource() override { }
@@ skipping 42 matching lines @@
     ReadableStreamTest()
         : m_page(DummyPageHolder::create(IntSize(1, 1)))
         , m_underlyingSource(new ::testing::StrictMock<MockUnderlyingSource>)
     {
     }
 
     ~ReadableStreamTest() override
     {
     }
 
-    ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
-    v8::Isolate* isolate() { return scriptState()->isolate(); }
+    ScriptState* getScriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
+    v8::Isolate* isolate() { return getScriptState()->isolate(); }
 
     v8::Local<v8::Function> createCaptor(String* value)
     {
-        return StringCapturingFunction::createFunction(scriptState(), value);
+        return StringCapturingFunction::createFunction(getScriptState(), value);
     }
 
     StringStream* construct(MockStrategy* strategy)
     {
         Checkpoint checkpoint;
         {
             InSequence s;
             EXPECT_CALL(checkpoint, Call(0));
             EXPECT_CALL(*strategy, shouldApplyBackpressure(0, _)).WillOnce(Return(true));
             EXPECT_CALL(checkpoint, Call(1));
@@ skipping 19 matching lines @@
         checkpoint.Call(1);
         return stream;
     }
 
     OwnPtr<DummyPageHolder> m_page;
     Persistent<MockUnderlyingSource> m_underlyingSource;
 };
 
 TEST_F(ReadableStreamTest, Start)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     Checkpoint checkpoint;
     {
         InSequence s;
         EXPECT_CALL(checkpoint, Call(0));
         EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
         EXPECT_CALL(checkpoint, Call(1));
     }
 
     StringStream* stream = new StringStream(m_underlyingSource);
     EXPECT_FALSE(exceptionState.hadException());
@@ skipping 12 matching lines @@
     EXPECT_TRUE(stream->isPulling());
     EXPECT_EQ(stream->stateInternal(), ReadableStream::Readable);
 
     // We need to call |error| in order to make
     // ActiveDOMObject::hasPendingActivity return false.
     stream->error(DOMException::create(AbortError, "done"));
 }
 
 TEST_F(ReadableStreamTest, StartFail)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = new StringStream(m_underlyingSource);
     EXPECT_FALSE(exceptionState.hadException());
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_EQ(stream->stateInternal(), ReadableStream::Readable);
 
     stream->error(DOMException::create(NotFoundError));
 
     EXPECT_FALSE(stream->isStarted());
     EXPECT_FALSE(stream->isDraining());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_EQ(stream->stateInternal(), ReadableStream::Errored);
 }
 
 TEST_F(ReadableStreamTest, ErrorAndEnqueue)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
 
     stream->error(DOMException::create(NotFoundError, "error"));
     EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 
     bool result = stream->enqueue("hello");
     EXPECT_FALSE(result);
     EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 }
 
 TEST_F(ReadableStreamTest, CloseAndEnqueue)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
 
     stream->close();
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     bool result = stream->enqueue("hello");
     EXPECT_FALSE(result);
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 }
 
 TEST_F(ReadableStreamTest, CloseWhenErrored)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     stream->error(DOMException::create(NotFoundError, "error"));
     stream->close();
 
     EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 }
 
 TEST_F(ReadableStreamTest, ReadQueue)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
     Checkpoint checkpoint;
 
     {
         InSequence s;
         EXPECT_CALL(checkpoint, Call(0));
         EXPECT_CALL(*m_underlyingSource, pullSource()).Times(1);
         EXPECT_CALL(checkpoint, Call(1));
     }
 
@@ skipping 14 matching lines @@
     EXPECT_EQ(std::make_pair(String("hello"), static_cast<size_t>(5)), queue[0]);
     EXPECT_EQ(std::make_pair(String("bye"), static_cast<size_t>(3)), queue[1]);
 
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_TRUE(stream->isPulling());
     EXPECT_FALSE(stream->isDraining());
 }
 
 TEST_F(ReadableStreamTest, CloseWhenReadable)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
 
     EXPECT_TRUE(stream->enqueue("hello"));
     EXPECT_TRUE(stream->enqueue("bye"));
     stream->close();
     EXPECT_FALSE(stream->enqueue("should be ignored"));
 
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
-    stream->read(scriptState());
+    stream->read(getScriptState());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 
-    stream->read(scriptState());
+    stream->read(getScriptState());
 
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
     EXPECT_FALSE(stream->isPulling());
     EXPECT_TRUE(stream->isDraining());
 }
 
 TEST_F(ReadableStreamTest, CancelWhenClosed)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     stream->close();
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     EXPECT_FALSE(stream->isDisturbed());
-    ScriptPromise promise = stream->cancel(scriptState(), ScriptValue());
+    ScriptPromise promise = stream->cancel(getScriptState(), ScriptValue());
     EXPECT_TRUE(stream->isDisturbed());
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ("undefined", onFulfilled);
     EXPECT_TRUE(onRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, CancelWhenErrored)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     stream->error(DOMException::create(NotFoundError, "error"));
     EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 
     EXPECT_FALSE(stream->isDisturbed());
-    ScriptPromise promise = stream->cancel(scriptState(), ScriptValue());
+    ScriptPromise promise = stream->cancel(getScriptState(), ScriptValue());
     EXPECT_TRUE(stream->isDisturbed());
     EXPECT_EQ(ReadableStream::Errored, stream->stateInternal());
 
     promise.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_EQ("NotFoundError: error", onRejected);
 }
 
 TEST_F(ReadableStreamTest, CancelWhenReadable)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
     String onFulfilled, onRejected;
     String onCancelFulfilled, onCancelRejected;
-    ScriptValue reason(scriptState(), v8String(scriptState()->isolate(), "reason"));
-    ScriptPromise promise = ScriptPromise::cast(scriptState(), v8String(scriptState()->isolate(), "hello"));
+    ScriptValue reason(getScriptState(), v8String(getScriptState()->isolate(), "reason"));
+    ScriptPromise promise = ScriptPromise::cast(getScriptState(), v8String(getScriptState()->isolate(), "hello"));
 
     {
         InSequence s;
-        EXPECT_CALL(*m_underlyingSource, cancelSource(scriptState(), reason)).WillOnce(ReturnPointee(&promise));
+        EXPECT_CALL(*m_underlyingSource, cancelSource(getScriptState(), reason)).WillOnce(ReturnPointee(&promise));
     }
 
     stream->enqueue("hello");
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     EXPECT_FALSE(stream->isDisturbed());
-    ScriptPromise cancelResult = stream->cancel(scriptState(), reason);
+    ScriptPromise cancelResult = stream->cancel(getScriptState(), reason);
     EXPECT_TRUE(stream->isDisturbed());
     cancelResult.then(createCaptor(&onCancelFulfilled), createCaptor(&onCancelRejected));
 
     EXPECT_NE(promise, cancelResult);
     EXPECT_EQ(ReadableStream::Closed, stream->stateInternal());
 
     EXPECT_TRUE(onCancelFulfilled.isNull());
     EXPECT_TRUE(onCancelRejected.isNull());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ("undefined", onCancelFulfilled);
     EXPECT_TRUE(onCancelRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, CancelWhenLocked)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     String onFulfilled, onRejected;
     StringStream* stream = construct();
-    ReadableStreamReader* reader = stream->getReader(scriptState()->executionContext(), exceptionState);
+    ReadableStreamReader* reader = stream->getReader(getScriptState()->getExecutionContext(), exceptionState);
 
     EXPECT_TRUE(reader->isActive());
     EXPECT_FALSE(exceptionState.hadException());
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     EXPECT_FALSE(stream->isDisturbed());
-    stream->cancel(scriptState(), ScriptValue(scriptState(), v8::Undefined(isolate()))).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+    stream->cancel(getScriptState(), ScriptValue(getScriptState(), v8::Undefined(isolate()))).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
     EXPECT_FALSE(stream->isDisturbed());
 
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_EQ("TypeError: this stream is locked to a ReadableStreamReader", onRejected);
     EXPECT_TRUE(reader->isActive());
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 }
 
 TEST_F(ReadableStreamTest, ReadableArrayBufferStreamCompileTest)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     // This test tests if ReadableStreamImpl<DOMArrayBuffer> can be
     // instantiated.
     new ReadableStreamImpl<ReadableStreamChunkTypeTraits<DOMArrayBuffer>>(m_underlyingSource);
 }
 
 TEST_F(ReadableStreamTest, ReadableArrayBufferViewStreamCompileTest)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     // This test tests if ReadableStreamImpl<DOMArrayBufferVIew> can be
     // instantiated.
     new ReadableStreamImpl<ReadableStreamChunkTypeTraits<DOMArrayBufferView>>(m_underlyingSource);
 }
 
 TEST_F(ReadableStreamTest, BackpressureOnEnqueueing)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     auto strategy = MockStrategy::create();
     Checkpoint checkpoint;
 
     StringStream* stream = construct(strategy);
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     {
         InSequence s;
         EXPECT_CALL(checkpoint, Call(0));
         EXPECT_CALL(*strategy, size(String("hello"), stream)).WillOnce(Return(1));
@@ skipping 12 matching lines @@
     checkpoint.Call(2);
     result = stream->enqueue("world");
     checkpoint.Call(3);
     EXPECT_FALSE(result);
 
     stream->error(DOMException::create(AbortError, "done"));
 }
 
 TEST_F(ReadableStreamTest, BackpressureOnReading)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     auto strategy = MockStrategy::create();
     Checkpoint checkpoint;
 
     StringStream* stream = construct(strategy);
     EXPECT_EQ(ReadableStream::Readable, stream->stateInternal());
 
     {
         InSequence s;
         EXPECT_CALL(*strategy, size(String("hello"), stream)).WillOnce(Return(2));
         EXPECT_CALL(*strategy, shouldApplyBackpressure(2, stream)).WillOnce(Return(false));
@@ skipping 12 matching lines @@
         EXPECT_CALL(*strategy, size(String("bar"), stream)).WillOnce(Return(5));
         EXPECT_CALL(*strategy, shouldApplyBackpressure(9, stream)).WillOnce(Return(true));
         EXPECT_CALL(checkpoint, Call(3));
         EXPECT_CALL(*strategy, shouldApplyBackpressure(5, stream)).WillOnce(Return(true));
         EXPECT_CALL(checkpoint, Call(4));
     }
     stream->enqueue("hello");
     stream->enqueue("world");
 
     checkpoint.Call(0);
-    stream->read(scriptState());
+    stream->read(getScriptState());
     checkpoint.Call(1);
-    stream->read(scriptState());
+    stream->read(getScriptState());
     checkpoint.Call(2);
     stream->enqueue("foo");
     stream->enqueue("bar");
     checkpoint.Call(3);
-    stream->read(scriptState());
+    stream->read(getScriptState());
     checkpoint.Call(4);
 
     stream->error(DOMException::create(AbortError, "done"));
 }
 
 // Note: Detailed tests are on ReadableStreamReaderTest.
 TEST_F(ReadableStreamTest, ReadableStreamReader)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
-    ReadableStreamReader* reader = stream->getReader(scriptState()->executionContext(), exceptionState);
+    ReadableStreamReader* reader = stream->getReader(getScriptState()->getExecutionContext(), exceptionState);
 
     ASSERT_TRUE(reader);
     EXPECT_FALSE(exceptionState.hadException());
     EXPECT_TRUE(reader->isActive());
     EXPECT_TRUE(stream->isLockedTo(reader));
 
-    ReadableStreamReader* another = stream->getReader(scriptState()->executionContext(), exceptionState);
+    ReadableStreamReader* another = stream->getReader(getScriptState()->getExecutionContext(), exceptionState);
     ASSERT_EQ(nullptr, another);
     EXPECT_TRUE(exceptionState.hadException());
     EXPECT_TRUE(reader->isActive());
     EXPECT_TRUE(stream->isLockedTo(reader));
 }
 
 TEST_F(ReadableStreamTest, GetClosedReader)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
     stream->close();
-    ReadableStreamReader* reader = stream->getReader(scriptState()->executionContext(), exceptionState);
+    ReadableStreamReader* reader = stream->getReader(getScriptState()->getExecutionContext(), exceptionState);
 
     ASSERT_TRUE(reader);
     EXPECT_FALSE(exceptionState.hadException());
 
     String onFulfilled, onRejected;
-    reader->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+    reader->closed(getScriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
 
     EXPECT_TRUE(reader->isActive());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ("undefined", onFulfilled);
     EXPECT_TRUE(onRejected.isNull());
 }
 
 TEST_F(ReadableStreamTest, GetErroredReader)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     StringStream* stream = construct();
     stream->error(DOMException::create(SyntaxError, "some error"));
-    ReadableStreamReader* reader = stream->getReader(scriptState()->executionContext(), exceptionState);
+    ReadableStreamReader* reader = stream->getReader(getScriptState()->getExecutionContext(), exceptionState);
 
     ASSERT_TRUE(reader);
     EXPECT_FALSE(exceptionState.hadException());
 
     String onFulfilled, onRejected;
-    reader->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+    reader->closed(getScriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
 
     EXPECT_TRUE(reader->isActive());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_TRUE(onRejected.isNull());
 
     v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_TRUE(onFulfilled.isNull());
     EXPECT_EQ("SyntaxError: some error", onRejected);
 }
 
 TEST_F(ReadableStreamTest, StrictStrategy)
 {
-    ScriptState::Scope scope(scriptState());
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", scriptState()->context()->Global(), isolate());
+    ScriptState::Scope scope(getScriptState());
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "property", "interface", getScriptState()->context()->Global(), isolate());
     Checkpoint checkpoint;
     {
         InSequence s;
         EXPECT_CALL(checkpoint, Call(0));
         EXPECT_CALL(checkpoint, Call(1));
         EXPECT_CALL(*m_underlyingSource, pullSource());
         EXPECT_CALL(checkpoint, Call(2));
         EXPECT_CALL(checkpoint, Call(3));
         EXPECT_CALL(*m_underlyingSource, pullSource());
         EXPECT_CALL(checkpoint, Call(4));
         EXPECT_CALL(checkpoint, Call(5));
         EXPECT_CALL(checkpoint, Call(6));
         EXPECT_CALL(checkpoint, Call(7));
         EXPECT_CALL(checkpoint, Call(8));
         EXPECT_CALL(checkpoint, Call(9));
         EXPECT_CALL(*m_underlyingSource, pullSource());
     }
     StringStream* stream = new StringStream(m_underlyingSource, new StringStream::StrictStrategy);
-    ReadableStreamReader* reader = stream->getReader(scriptState()->executionContext(), exceptionState);
+    ReadableStreamReader* reader = stream->getReader(getScriptState()->getExecutionContext(), exceptionState);
 
     checkpoint.Call(0);
     stream->didSourceStart();
 
     checkpoint.Call(1);
     EXPECT_FALSE(stream->isPulling());
-    reader->read(scriptState());
+    reader->read(getScriptState());
     EXPECT_TRUE(stream->isPulling());
     checkpoint.Call(2);
     stream->enqueue("hello");
     EXPECT_FALSE(stream->isPulling());
     checkpoint.Call(3);
-    reader->read(scriptState());
+    reader->read(getScriptState());
     EXPECT_TRUE(stream->isPulling());
     checkpoint.Call(4);
-    reader->read(scriptState());
+    reader->read(getScriptState());
     EXPECT_TRUE(stream->isPulling());
     checkpoint.Call(5);
     stream->enqueue("hello");
     EXPECT_FALSE(stream->isPulling());
     checkpoint.Call(6);
     stream->enqueue("hello");
     EXPECT_FALSE(stream->isPulling());
     checkpoint.Call(7);
     stream->enqueue("hello");
     EXPECT_FALSE(stream->isPulling());
     checkpoint.Call(8);
-    reader->read(scriptState());
+    reader->read(getScriptState());
     EXPECT_FALSE(stream->isPulling());
     checkpoint.Call(9);
-    reader->read(scriptState());
+    reader->read(getScriptState());
     EXPECT_TRUE(stream->isPulling());
 
     stream->error(DOMException::create(AbortError, "done"));
 }
 
 } // namespace blink