Remove unused DataConsumerHandleTestUtil classes

Change-Id: Icb8f3be6610108b08ea111f60f59e7f914dfc1fe
Reviewed-on: https://chromium-review.googlesource.com/599142Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#491965}

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

@@ -264,83 +264,6 @@ void DataConsumerHandleTestUtil::ReplayingHandle::Add(const Command& command) {
   context_->Add(command);
 }
 
-DataConsumerHandleTestUtil::HandleReader::HandleReader(
-    std::unique_ptr<WebDataConsumerHandle> handle,
-    std::unique_ptr<OnFinishedReading> on_finished_reading)
-    : reader_(handle->ObtainReader(this)),
-      on_finished_reading_(std::move(on_finished_reading)) {}
-
-void DataConsumerHandleTestUtil::HandleReader::DidGetReadable() {
-  WebDataConsumerHandle::Result r = WebDataConsumerHandle::kUnexpectedError;
-  char buffer[3];
-  while (true) {
-    size_t size;
-    r = reader_->Read(buffer, sizeof(buffer), WebDataConsumerHandle::kFlagNone,
-                      &size);
-    if (r == WebDataConsumerHandle::kShouldWait)
-      return;
-    if (r != WebDataConsumerHandle::kOk)
-      break;
-    data_.Append(buffer, size);
-  }
-  std::unique_ptr<HandleReadResult> result =
-      WTF::MakeUnique<HandleReadResult>(r, data_);
-  data_.clear();
-  Platform::Current()->CurrentThread()->GetWebTaskRunner()->PostTask(
-      BLINK_FROM_HERE,
-      WTF::Bind(&HandleReader::RunOnFinishedReading, WTF::Unretained(this),
-                WTF::Passed(std::move(result))));
-  reader_ = nullptr;
-}
-
-void DataConsumerHandleTestUtil::HandleReader::RunOnFinishedReading(
-    std::unique_ptr<HandleReadResult> result) {
-  DCHECK(on_finished_reading_);
-  std::unique_ptr<OnFinishedReading> on_finished_reading(
-      std::move(on_finished_reading_));
-  (*on_finished_reading)(std::move(result));
-}
-
-DataConsumerHandleTestUtil::HandleTwoPhaseReader::HandleTwoPhaseReader(
-    std::unique_ptr<WebDataConsumerHandle> handle,
-    std::unique_ptr<OnFinishedReading> on_finished_reading)
-    : reader_(handle->ObtainReader(this)),
-      on_finished_reading_(std::move(on_finished_reading)) {}
-
-void DataConsumerHandleTestUtil::HandleTwoPhaseReader::DidGetReadable() {
-  WebDataConsumerHandle::Result r = WebDataConsumerHandle::kUnexpectedError;
-  while (true) {
-    const void* buffer = nullptr;
-    size_t size;
-    r = reader_->BeginRead(&buffer, WebDataConsumerHandle::kFlagNone, &size);
-    if (r == WebDataConsumerHandle::kShouldWait)
-      return;
-    if (r != WebDataConsumerHandle::kOk)
-      break;
-    // Read smaller than available in order to test |endRead|.
-    size_t read_size =
-        std::min(size, std::max(size * 2 / 3, static_cast<size_t>(1)));
-    data_.Append(static_cast<const char*>(buffer), read_size);
-    reader_->EndRead(read_size);
-  }
-  std::unique_ptr<HandleReadResult> result =
-      WTF::MakeUnique<HandleReadResult>(r, data_);
-  data_.clear();
-  Platform::Current()->CurrentThread()->GetWebTaskRunner()->PostTask(
-      BLINK_FROM_HERE,
-      WTF::Bind(&HandleTwoPhaseReader::RunOnFinishedReading,
-                WTF::Unretained(this), WTF::Passed(std::move(result))));
-  reader_ = nullptr;
-}
-
-void DataConsumerHandleTestUtil::HandleTwoPhaseReader::RunOnFinishedReading(
-    std::unique_ptr<HandleReadResult> result) {
-  DCHECK(on_finished_reading_);
-  std::unique_ptr<OnFinishedReading> on_finished_reading(
-      std::move(on_finished_reading_));
-  (*on_finished_reading)(std::move(result));
-}
-
 std::unique_ptr<WebDataConsumerHandle>
 DataConsumerHandleTestUtil::CreateWaitingDataConsumerHandle() {
   return WTF::WrapUnique(new WaitingHandle);

third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h

@@ -9,7 +9,6 @@
 
 #include "core/testing/NullExecutionContext.h"
 #include "gin/public/isolate_holder.h"
-#include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "platform/bindings/ScriptState.h"
@@ -409,111 +408,6 @@ class DataConsumerHandleTestUtil {
     RefPtr<Context> context_;
   };
 
-  class HandleReadResult final {
-    USING_FAST_MALLOC(HandleReadResult);
-
-   public:
-    HandleReadResult(WebDataConsumerHandle::Result result,
-                     const Vector<char>& data)
-        : result_(result), data_(data) {}
-    WebDataConsumerHandle::Result GetResult() const { return result_; }
-    const Vector<char>& Data() const { return data_; }
-
-   private:
-    const WebDataConsumerHandle::Result result_;
-    const Vector<char> data_;
-  };
-
-  // HandleReader reads all data from the given WebDataConsumerHandle using
-  // Reader::read on the thread on which it is created. When reading is done
-  // or failed, it calls the given callback with the result.
-  class HandleReader final : public WebDataConsumerHandle::Client {
-    USING_FAST_MALLOC(HandleReader);
-
-   public:
-    using OnFinishedReading =
-        WTF::Function<void(std::unique_ptr<HandleReadResult>)>;
-
-    HandleReader(std::unique_ptr<WebDataConsumerHandle>,
-                 std::unique_ptr<OnFinishedReading>);
-    void DidGetReadable() override;
-
-   private:
-    void RunOnFinishedReading(std::unique_ptr<HandleReadResult>);
-
-    std::unique_ptr<WebDataConsumerHandle::Reader> reader_;
-    std::unique_ptr<OnFinishedReading> on_finished_reading_;
-    Vector<char> data_;
-  };
-
-  // HandleTwoPhaseReader does the same as HandleReader, but it uses
-  // |beginRead| / |endRead| instead of |read|.
-  class HandleTwoPhaseReader final : public WebDataConsumerHandle::Client {
-    USING_FAST_MALLOC(HandleTwoPhaseReader);
-
-   public:
-    using OnFinishedReading =
-        WTF::Function<void(std::unique_ptr<HandleReadResult>)>;
-
-    HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle>,
-                         std::unique_ptr<OnFinishedReading>);
-    void DidGetReadable() override;
-
-   private:
-    void RunOnFinishedReading(std::unique_ptr<HandleReadResult>);
-
-    std::unique_ptr<WebDataConsumerHandle::Reader> reader_;
-    std::unique_ptr<OnFinishedReading> on_finished_reading_;
-    Vector<char> data_;
-  };
-
-  // HandleReaderRunner<T> creates a dedicated thread and run T on the thread
-  // where T is one of HandleReader and HandleTwophaseReader.
-  template <typename T>
-  class HandleReaderRunner final {
-    STACK_ALLOCATED();
-
-   public:
-    explicit HandleReaderRunner(std::unique_ptr<WebDataConsumerHandle> handle)
-        : thread_(WTF::WrapUnique(new Thread("reading thread"))),
-          event_(WTF::MakeUnique<WaitableEvent>()),
-          is_done_(false) {
-      thread_->GetThread()->PostTask(
-          BLINK_FROM_HERE, CrossThreadBind(&HandleReaderRunner::Start,
-                                           crossThreadUnretained(this),
-                                           WTF::Passed(std::move(handle))));
-    }
-    ~HandleReaderRunner() { Wait(); }
-
-    std::unique_ptr<HandleReadResult> Wait() {
-      if (is_done_)
-        return nullptr;
-      event_->Wait();
-      is_done_ = true;
-      return std::move(result_);
-    }
-
-   private:
-    void Start(std::unique_ptr<WebDataConsumerHandle> handle) {
-      handle_reader_ = WTF::WrapUnique(new T(
-          std::move(handle),
-          WTF::Bind(&HandleReaderRunner::OnFinished, WTF::Unretained(this))));
-    }
-
-    void OnFinished(std::unique_ptr<HandleReadResult> result) {
-      handle_reader_ = nullptr;
-      result_ = std::move(result);
-      event_->Signal();
-    }
-
-    std::unique_ptr<Thread> thread_;
-    std::unique_ptr<WaitableEvent> event_;
-    std::unique_ptr<HandleReadResult> result_;
-    bool is_done_;
-
-    std::unique_ptr<T> handle_reader_;
-  };
-
   static std::unique_ptr<WebDataConsumerHandle>
   CreateWaitingDataConsumerHandle();
 };