// Copyright 2016 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.

#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_FETCH_BYTES_CONSUMER_TEST_UTIL_H_
#define THIRD_PARTY_BLINK_RENDERER_CORE_FETCH_BYTES_CONSUMER_TEST_UTIL_H_

#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/renderer/core/fetch/bytes_consumer.h"
#include "third_party/blink/renderer/core/fetch/fetch_data_loader.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/wtf/deque.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"

namespace blink {

class ExecutionContext;

class BytesConsumerTestUtil {
  STATIC_ONLY(BytesConsumerTestUtil);

 public:
  class MockBytesConsumer : public BytesConsumer {
   public:
    static MockBytesConsumer* Create() {
      return new testing::StrictMock<MockBytesConsumer>();
    }

    MOCK_METHOD2(BeginRead, Result(const char**, size_t*));
    MOCK_METHOD1(EndRead, Result(size_t));
    MOCK_METHOD1(DrainAsBlobDataHandle,
                 scoped_refptr<BlobDataHandle>(BlobSizePolicy));
    MOCK_METHOD0(DrainAsFormData, scoped_refptr<EncodedFormData>());
    MOCK_METHOD1(SetClient, void(Client*));
    MOCK_METHOD0(ClearClient, void());
    MOCK_METHOD0(Cancel, void());
    MOCK_CONST_METHOD0(GetPublicState, PublicState());
    MOCK_CONST_METHOD0(GetError, Error());

    String DebugName() const override { return "MockBytesConsumer"; }

   protected:
    MockBytesConsumer();
  };

  class MockFetchDataLoaderClient
      : public GarbageCollectedFinalized<MockFetchDataLoaderClient>,
        public FetchDataLoader::Client {
    USING_GARBAGE_COLLECTED_MIXIN(MockFetchDataLoaderClient);

   public:
    static testing::StrictMock<MockFetchDataLoaderClient>* Create() {
      return new testing::StrictMock<MockFetchDataLoaderClient>;
    }

    void Trace(blink::Visitor* visitor) override {
      FetchDataLoader::Client::Trace(visitor);
    }

    MOCK_METHOD1(DidFetchDataLoadedBlobHandleMock,
                 void(scoped_refptr<BlobDataHandle>));
    MOCK_METHOD1(DidFetchDataLoadedArrayBufferMock, void(DOMArrayBuffer*));
    MOCK_METHOD1(DidFetchDataLoadedFormDataMock, void(FormData*));
    MOCK_METHOD1(DidFetchDataLoadedString, void(const String&));
    MOCK_METHOD0(DidFetchDataLoadStream, void());
    MOCK_METHOD0(DidFetchDataLoadFailed, void());
    MOCK_METHOD0(Abort, void());

    void DidFetchDataLoadedArrayBuffer(DOMArrayBuffer* array_buffer) override {
      DidFetchDataLoadedArrayBufferMock(array_buffer);
    }
    // TODO(yhirano): Remove DidFetchDataLoadedBlobHandleMock.
    void DidFetchDataLoadedBlobHandle(
        scoped_refptr<BlobDataHandle> blob_data_handle) override {
      DidFetchDataLoadedBlobHandleMock(std::move(blob_data_handle));
    }
    void DidFetchDataLoadedFormData(FormData* FormData) override {
      DidFetchDataLoadedFormDataMock(FormData);
    }
  };

  class Command final {
    DISALLOW_NEW();

   public:
    enum Name {
      kData,
      kDone,
      kError,
      kWait,
    };

    explicit Command(Name name) : name_(name) {}
    Command(Name name, const Vector<char>& body) : name_(name), body_(body) {}
    Command(Name name, const char* body, wtf_size_t size) : name_(name) {
      body_.Append(body, size);
    }
    Command(Name name, const char* body)
        : Command(name, body, static_cast<wtf_size_t>(strlen(body))) {}
    Name GetName() const { return name_; }
    const Vector<char>& Body() const { return body_; }

   private:
    const Name name_;
    Vector<char> body_;
  };

  // ReplayingBytesConsumer stores commands via |add| and replays the stored
  // commends when read.
  class ReplayingBytesConsumer final : public BytesConsumer {
   public:
    // The ExecutionContext is needed to get a base::SingleThreadTaskRunner.
    explicit ReplayingBytesConsumer(ExecutionContext*);
    ~ReplayingBytesConsumer() override;

    // Add a command to this handle. This function must be called BEFORE
    // any BytesConsumer methods are called.
    void Add(const Command& command) { commands_.push_back(command); }

    Result BeginRead(const char** buffer, size_t* available) override;
    Result EndRead(size_t read_size) override;

    void SetClient(Client*) override;
    void ClearClient() override;
    void Cancel() override;
    PublicState GetPublicState() const override;
    Error GetError() const override;
    String DebugName() const override { return "ReplayingBytesConsumer"; }

    bool IsCancelled() const { return is_cancelled_; }

    void Trace(blink::Visitor*) override;

   private:
    void NotifyAsReadable(int notification_token);
    void Close();
    void MakeErrored(const Error&);

    Member<ExecutionContext> execution_context_;
    Member<BytesConsumer::Client> client_;
    InternalState state_ = InternalState::kWaiting;
    Deque<Command> commands_;
    size_t offset_ = 0;
    BytesConsumer::Error error_;
    int notification_token_ = 0;
    bool is_cancelled_ = false;
  };

  class TwoPhaseReader final : public GarbageCollectedFinalized<TwoPhaseReader>,
                               public BytesConsumer::Client {
    USING_GARBAGE_COLLECTED_MIXIN(TwoPhaseReader);

   public:
    // |consumer| must not have a client when called.
    explicit TwoPhaseReader(BytesConsumer* /* consumer */);

    void OnStateChange() override;
    String DebugName() const override { return "TwoPhaseReader"; }
    std::pair<BytesConsumer::Result, Vector<char>> Run();

    void Trace(blink::Visitor* visitor) override {
      visitor->Trace(consumer_);
      BytesConsumer::Client::Trace(visitor);
    }

   private:
    Member<BytesConsumer> consumer_;
    BytesConsumer::Result result_ = BytesConsumer::Result::kShouldWait;
    Vector<char> data_;
  };

  static String CharVectorToString(const Vector<char>&);
};

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_FETCH_BYTES_CONSUMER_TEST_UTIL_H_