Return unique_ptr<WebDataConsumerHandle::Reader> directly from obtainReader

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/ScriptState.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "core/dom/Document.h"
@@ skipping 94 matching lines @@
     std::unique_ptr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
     Persistent<MockClient> client = MockClient::create();
     Checkpoint checkpoint;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(2));
 
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
 }
 
 TEST_F(ReadableStreamDataConsumerHandleTest, EmptyStream)
 {
     ScriptState::Scope scope(getScriptState());
     ScriptValue stream(getScriptState(), evalWithPrintingError(
         "new ReadableStream({start: c => c.close()})"));
     ASSERT_FALSE(stream.isEmpty());
     std::unique_ptr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
     ASSERT_TRUE(handle);
     Persistent<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;
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(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));
 }
 
@@ skipping 10 matching lines @@
 
     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;
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(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));
 }
 
@@ skipping 22 matching lines @@
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(4));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(5));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(6));
 
     char buffer[3];
     size_t readBytes;
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     EXPECT_EQ(kShouldWait, reader->read(buffer, 3, kNone, &readBytes));
     testing::runPendingTasks();
     checkpoint.Call(3);
     EXPECT_EQ(kShouldWait, reader->read(buffer, 3, kNone, &readBytes));
     testing::runPendingTasks();
     checkpoint.Call(4);
@@ skipping 47 matching lines @@
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(4));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(5));
     EXPECT_CALL(*client, didGetReadable());
     EXPECT_CALL(checkpoint, Call(6));
 
     const void* buffer;
     size_t available;
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     testing::runPendingTasks();
     checkpoint.Call(3);
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     testing::runPendingTasks();
     checkpoint.Call(4);
@@ skipping 50 matching lines @@
 
     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));
 
     const void* buffer;
     size_t available;
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     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));
 }
 
@@ skipping 14 matching lines @@
 
     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));
 
     const void* buffer;
     size_t available;
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     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));
 }
 
@@ skipping 14 matching lines @@
 
     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));
 
     const void* buffer;
     size_t available;
-    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(client);
+    std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(client);
     ASSERT_TRUE(reader);
     checkpoint.Call(1);
     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));
 }
 
@@ skipping 13 matching lines @@
     EXPECT_CALL(checkpoint, Call(4));
 
     {
         // We need this scope to collect local handles.
         ScriptState::Scope scope(getScriptState());
         stream = ScriptValue(getScriptState(), evalWithPrintingError("new ReadableStream()"));
         ASSERT_FALSE(stream.isEmpty());
         std::unique_ptr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
         ASSERT_TRUE(handle);
 
-        reader = handle->obtainReader(client);
+        reader = handle->obtainFetchDataReader(client);
         ASSERT_TRUE(reader);
     }
 
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     stream.clear();
     gc();
     checkpoint.Call(3);
     testing::runPendingTasks();
@@ skipping 21 matching lines @@
     EXPECT_CALL(checkpoint, Call(5));
 
     {
         // We need this scope to collect local handles.
         ScriptState::Scope scope(getScriptState());
         stream = ScriptValue(getScriptState(), evalWithPrintingError("new ReadableStream()"));
         ASSERT_FALSE(stream.isEmpty());
         std::unique_ptr<ReadableStreamDataConsumerHandle> handle = createHandle(stream);
         ASSERT_TRUE(handle);
 
-        reader = handle->obtainReader(client);
+        reader = handle->obtainFetchDataReader(client);
         ASSERT_TRUE(reader);
     }
 
     const void* buffer;
     size_t available;
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
 
     testing::runPendingTasks();
     checkpoint.Call(3);
     stream.clear();
     gc();
     checkpoint.Call(4);
     testing::runPendingTasks();
 
     checkpoint.Call(5);
     EXPECT_EQ(kUnexpectedError, reader->beginRead(&buffer, kNone, &available));
 }
 
 } // namespace
 
 } // namespace blink
-