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

third_party/WebKit/Source/modules/fetch/ReadableStreamDataConsumerHandleTest.cpp

 // Copyright 2015 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 "modules/fetch/ReadableStreamDataConsumerHandle.h"
 
 #include "bindings/core/v8/ReadableStreamOperations.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8GCController.h"
@@ skipping 35 matching lines @@
     MockClient() = default;
 };
 
 class ReadableStreamDataConsumerHandleTest : public ::testing::Test {
 public:
     ReadableStreamDataConsumerHandleTest()
         : m_page(DummyPageHolder::create())
     {
     }
 
-    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::MaybeLocal<v8::Value> eval(const char* s)
     {
         v8::Local<v8::String> source;
         v8::Local<v8::Script> script;
         V8RecursionScope::MicrotaskSuppression microtasks(isolate());
         if (!v8Call(v8::String::NewFromUtf8(isolate(), s, v8::NewStringType::kNormal), source)) {
             ADD_FAILURE();
             return v8::MaybeLocal<v8::Value>();
         }
-        if (!v8Call(v8::Script::Compile(scriptState()->context(), source), script)) {
+        if (!v8Call(v8::Script::Compile(getScriptState()->context(), source), script)) {
             ADD_FAILURE() << "Compilation fails";
             return v8::MaybeLocal<v8::Value>();
         }
-        return script->Run(scriptState()->context());
+        return script->Run(getScriptState()->context());
     }
     v8::MaybeLocal<v8::Value> evalWithPrintingError(const char* s)
     {
         v8::TryCatch block(isolate());
         v8::MaybeLocal<v8::Value> r = eval(s);
         if (block.HasCaught()) {
             ADD_FAILURE() << toCoreString(block.Exception()->ToString(isolate())).utf8().data();
             block.ReThrow();
         }
         return r;
     }
 
     PassOwnPtr<ReadableStreamDataConsumerHandle> createHandle(ScriptValue stream)
     {
         NonThrowableExceptionState es;
-        ScriptValue reader = ReadableStreamOperations::getReader(scriptState(), stream, es);
+        ScriptValue reader = ReadableStreamOperations::getReader(getScriptState(), stream, es);
         ASSERT(!reader.isEmpty());
         ASSERT(reader.v8Value()->IsObject());
-        return ReadableStreamDataConsumerHandle::create(scriptState(), reader);
+        return ReadableStreamDataConsumerHandle::create(getScriptState(), reader);
     }
 
     void gc() { V8GCController::collectAllGarbageForTesting(isolate()); }
 
 private:
     OwnPtr<DummyPageHolder> m_page;
 };
 
 TEST_F(ReadableStreamDataConsumerHandleTest, Create)
 {
-    ScriptState::Scope scope(scriptState());
-    ScriptValue stream(scriptState(), evalWithPrintingError("new ReadableStream"));
+    ScriptState::Scope scope(getScriptState());
+    ScriptValue stream(getScriptState(), evalWithPrintingError("new ReadableStream"));
     ASSERT_FALSE(stream.isEmpty());
     OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
     MockClient* client = MockClient::create();
     Checkpoint checkpoint;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(2));
 
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
 }
 
 TEST_F(ReadableStreamDataConsumerHandleTest, EmptyStream)
 {
-    ScriptState::Scope scope(scriptState());
-    ScriptValue stream(scriptState(), evalWithPrintingError(
+    ScriptState::Scope scope(getScriptState());
+    ScriptValue stream(getScriptState(), evalWithPrintingError(
         "new ReadableStream({start: c => c.close()})"));
     ASSERT_FALSE(stream.isEmpty());
     OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
     MockClient* client = MockClient::create();
     Checkpoint checkpoint;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(3));
 
     char c;
     size_t readBytes;
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     EXPECT_EQ(kShouldWait, reader->read(&c, 1, kNone, &readBytes));
     testing::runPendingTasks();
     checkpoint.Call(3);
     EXPECT_EQ(kDone, reader->read(&c, 1, kNone, &readBytes));
 }
 
 TEST_F(ReadableStreamDataConsumerHandleTest, ErroredStream)
 {
-    ScriptState::Scope scope(scriptState());
-    ScriptValue stream(scriptState(), evalWithPrintingError(
+    ScriptState::Scope scope(getScriptState());
+    ScriptValue stream(getScriptState(), evalWithPrintingError(
         "new ReadableStream({start: c => c.error()})"));
     ASSERT_FALSE(stream.isEmpty());
     OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
     MockClient* client = MockClient::create();
     Checkpoint checkpoint;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(3));
 
     char c;
     size_t readBytes;
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     EXPECT_EQ(kShouldWait, reader->read(&c, 1, kNone, &readBytes));
     testing::runPendingTasks();
     checkpoint.Call(3);
     EXPECT_EQ(kUnexpectedError, reader->read(&c, 1, kNone, &readBytes));
 }
 
 TEST_F(ReadableStreamDataConsumerHandleTest, Read)
 {
-    ScriptState::Scope scope(scriptState());
-    ScriptValue stream(scriptState(), evalWithPrintingError(
+    ScriptState::Scope scope(getScriptState());
+    ScriptValue stream(getScriptState(), evalWithPrintingError(
         "var controller;"
         "var stream = new ReadableStream({start: c => controller = c});"
         "controller.enqueue(new Uint8Array());"
         "controller.enqueue(new Uint8Array([0x43, 0x44, 0x45, 0x46]));"
         "controller.enqueue(new Uint8Array([0x47, 0x48, 0x49, 0x4a]));"
         "controller.close();"
         "stream"));
     ASSERT_FALSE(stream.isEmpty());
     OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
@@ skipping 46 matching lines @@
     EXPECT_EQ(1u, readBytes);
     EXPECT_EQ(0x4a, buffer[0]);
     EXPECT_EQ(kShouldWait, reader->read(buffer, 3, kNone, &readBytes));
     testing::runPendingTasks();
     checkpoint.Call(6);
     EXPECT_EQ(kDone, reader->read(buffer, 3, kNone, &readBytes));
 }
 
 TEST_F(ReadableStreamDataConsumerHandleTest, TwoPhaseRead)
 {
-    ScriptState::Scope scope(scriptState());
-    ScriptValue stream(scriptState(), evalWithPrintingError(
+    ScriptState::Scope scope(getScriptState());
+    ScriptValue stream(getScriptState(), evalWithPrintingError(
         "var controller;"
         "var stream = new ReadableStream({start: c => controller = c});"
         "controller.enqueue(new Uint8Array());"
         "controller.enqueue(new Uint8Array([0x43, 0x44, 0x45, 0x46]));"
         "controller.enqueue(new Uint8Array([0x47, 0x48, 0x49, 0x4a]));"
         "controller.close();"
         "stream"));
     ASSERT_FALSE(stream.isEmpty());
     OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
@@ skipping 57 matching lines @@
     EXPECT_EQ(0x4a, static_cast<const char*>(buffer)[3]);
     EXPECT_EQ(kOk, reader->endRead(4));
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     testing::runPendingTasks();
     checkpoint.Call(6);
     EXPECT_EQ(kDone, reader->beginRead(&buffer, kNone, &available));
 }
 
 TEST_F(ReadableStreamDataConsumerHandleTest, EnqueueUndefined)
 {
-    ScriptState::Scope scope(scriptState());
-    ScriptValue stream(scriptState(), evalWithPrintingError(
+    ScriptState::Scope scope(getScriptState());
+    ScriptValue stream(getScriptState(), evalWithPrintingError(
         "var controller;"
         "var stream = new ReadableStream({start: c => controller = c});"
         "controller.enqueue(undefined);"
         "controller.close();"
         "stream"));
     ASSERT_FALSE(stream.isEmpty());
     OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
     MockClient* client = MockClient::create();
     Checkpoint checkpoint;
@@ skipping 13 matching lines @@
     testing::runPendingTasks();
     checkpoint.Call(2);
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     testing::runPendingTasks();
     checkpoint.Call(3);
     EXPECT_EQ(kUnexpectedError, reader->beginRead(&buffer, kNone, &available));
 }
 
 TEST_F(ReadableStreamDataConsumerHandleTest, EnqueueNull)
 {
-    ScriptState::Scope scope(scriptState());
-    ScriptValue stream(scriptState(), evalWithPrintingError(
+    ScriptState::Scope scope(getScriptState());
+    ScriptValue stream(getScriptState(), evalWithPrintingError(
         "var controller;"
         "var stream = new ReadableStream({start: c => controller = c});"
         "controller.enqueue(null);"
         "controller.close();"
         "stream"));
     ASSERT_FALSE(stream.isEmpty());
     OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
     MockClient* client = MockClient::create();
     Checkpoint checkpoint;
@@ skipping 13 matching lines @@
     testing::runPendingTasks();
     checkpoint.Call(2);
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     testing::runPendingTasks();
     checkpoint.Call(3);
     EXPECT_EQ(kUnexpectedError, reader->beginRead(&buffer, kNone, &available));
 }
 
 TEST_F(ReadableStreamDataConsumerHandleTest, EnqueueString)
 {
-    ScriptState::Scope scope(scriptState());
-    ScriptValue stream(scriptState(), evalWithPrintingError(
+    ScriptState::Scope scope(getScriptState());
+    ScriptValue stream(getScriptState(), evalWithPrintingError(
         "var controller;"
         "var stream = new ReadableStream({start: c => controller = c});"
         "controller.enqueue('hello');"
         "controller.close();"
         "stream"));
     ASSERT_FALSE(stream.isEmpty());
     OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
     MockClient* client = MockClient::create();
     Checkpoint checkpoint;
@@ skipping 28 matching lines @@
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(4));
 
     {
         // We need this scope to collect local handles.
-        ScriptState::Scope scope(scriptState());
-        stream = ScriptValue(scriptState(), evalWithPrintingError("new ReadableStream()"));
+        ScriptState::Scope scope(getScriptState());
+        stream = ScriptValue(getScriptState(), evalWithPrintingError("new ReadableStream()"));
         ASSERT_FALSE(stream.isEmpty());
         OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
         ASSERT_TRUE(handle);
 
         reader = handle->obtainReader(client);
         ASSERT_TRUE(reader);
     }
 
     checkpoint.Call(1);
     testing::runPendingTasks();
@@ skipping 20 matching lines @@
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(checkpoint, Call(4));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(5));
 
     {
         // We need this scope to collect local handles.
-        ScriptState::Scope scope(scriptState());
-        stream = ScriptValue(scriptState(), evalWithPrintingError("new ReadableStream()"));
+        ScriptState::Scope scope(getScriptState());
+        stream = ScriptValue(getScriptState(), evalWithPrintingError("new ReadableStream()"));
         ASSERT_FALSE(stream.isEmpty());
         OwnPtr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
         ASSERT_TRUE(handle);
 
         reader = handle->obtainReader(client);
         ASSERT_TRUE(reader);
     }
 
     const void* buffer;
     size_t available;
@@ skipping 10 matching lines @@
     testing::runPendingTasks();
 
     checkpoint.Call(5);
     EXPECT_EQ(kUnexpectedError, reader->beginRead(&buffer, kNone, &available));
 }
 
 } // namespace
 
 } // namespace blink