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

#include "blimp/net/thread_pipe_manager.h"

#include "base/location.h"
#include "base/sequenced_task_runner.h"
#include "blimp/net/blimp_message_processor.h"
#include "blimp/net/blimp_message_thread_pipe.h"
#include "blimp/net/browser_connection_handler.h"

namespace blimp {

// IoThreadPipeManager is created on the UI thread, and then used and destroyed
// on the IO thread.
// It works with |connection_handler| to register features on the IO thread,
// and manages IO-thread-side BlimpMessageThreadPipes.
class IoThreadPipeManager {
 public:
  explicit IoThreadPipeManager(BrowserConnectionHandler* connection_handler);
  virtual ~IoThreadPipeManager();

  // Connects message pipes between the specified feature and the network layer,
  // using |incoming_proxy| as the incoming message processor, and connecting
  // |outgoing_pipe| to the actual message sender.
  void RegisterFeature(BlimpMessage::Type type,
                       std::unique_ptr<BlimpMessageThreadPipe> outgoing_pipe,
                       std::unique_ptr<BlimpMessageProcessor> incoming_proxy);

 private:
  BrowserConnectionHandler* connection_handler_;

  // Container for the feature-specific MessageProcessors.
  // IO-side proxy for sending messages to UI thread.
  std::vector<std::unique_ptr<BlimpMessageProcessor>> incoming_proxies_;

  // Containers for the MessageProcessors used to write feature-specific
  // messages to the network, and the thread-pipe endpoints through which
  // they are used from the UI thread.
  std::vector<std::unique_ptr<BlimpMessageProcessor>>
      outgoing_message_processors_;
  std::vector<std::unique_ptr<BlimpMessageThreadPipe>> outgoing_pipes_;

  DISALLOW_COPY_AND_ASSIGN(IoThreadPipeManager);
};

IoThreadPipeManager::IoThreadPipeManager(
    BrowserConnectionHandler* connection_handler)
    : connection_handler_(connection_handler) {
  DCHECK(connection_handler_);
}

IoThreadPipeManager::~IoThreadPipeManager() {}

void IoThreadPipeManager::RegisterFeature(
    BlimpMessage::Type type,
    std::unique_ptr<BlimpMessageThreadPipe> outgoing_pipe,
    std::unique_ptr<BlimpMessageProcessor> incoming_proxy) {
  // Registers |incoming_proxy| as the message processor for incoming
  // messages with |type|. Sets the returned outgoing message processor as the
  // target of the |outgoing_pipe|.
  std::unique_ptr<BlimpMessageProcessor> outgoing_message_processor =
      connection_handler_->RegisterFeature(type, incoming_proxy.get());
  outgoing_pipe->set_target_processor(outgoing_message_processor.get());

  // This object manages the lifetimes of the pipe, proxy and target processor.
  incoming_proxies_.push_back(std::move(incoming_proxy));
  outgoing_pipes_.push_back(std::move(outgoing_pipe));
  outgoing_message_processors_.push_back(std::move(outgoing_message_processor));
}

ThreadPipeManager::ThreadPipeManager(
    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
    const scoped_refptr<base::SequencedTaskRunner>& ui_task_runner,
    BrowserConnectionHandler* connection_handler)
    : io_task_runner_(io_task_runner),
      ui_task_runner_(ui_task_runner),
      io_pipe_manager_(new IoThreadPipeManager(connection_handler)) {}

ThreadPipeManager::~ThreadPipeManager() {
  io_task_runner_->DeleteSoon(FROM_HERE, io_pipe_manager_.release());
}

std::unique_ptr<BlimpMessageProcessor> ThreadPipeManager::RegisterFeature(
    BlimpMessage::Type type,
    BlimpMessageProcessor* incoming_processor) {
  // Creates an outgoing pipe and a proxy for forwarding messages
  // from features on the UI thread to network components on the IO thread.
  std::unique_ptr<BlimpMessageThreadPipe> outgoing_pipe(
      new BlimpMessageThreadPipe(io_task_runner_));
  std::unique_ptr<BlimpMessageProcessor> outgoing_proxy =
      outgoing_pipe->CreateProxy();

  // Creates an incoming pipe and a proxy for receiving messages
  // from network components on the IO thread.
  std::unique_ptr<BlimpMessageThreadPipe> incoming_pipe(
      new BlimpMessageThreadPipe(ui_task_runner_));
  incoming_pipe->set_target_processor(incoming_processor);
  std::unique_ptr<BlimpMessageProcessor> incoming_proxy =
      incoming_pipe->CreateProxy();

  // Finishes registration on IO thread.
  io_task_runner_->PostTask(
      FROM_HERE, base::Bind(&IoThreadPipeManager::RegisterFeature,
                            base::Unretained(io_pipe_manager_.get()), type,
                            base::Passed(std::move(outgoing_pipe)),
                            base::Passed(std::move(incoming_proxy))));

  incoming_pipes_.push_back(std::move(incoming_pipe));
  return outgoing_proxy;
}

}  // namespace blimp