naiveproxy/net/tools/quic/quic_http_proxy_backend.h

// Copyright 2018 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.
//
// The proxy functionality is implemented as a separate thread namely
// “quic proxy thread”, managed by an instance of the QuicHttpProxyBackend
// class. The QuicHttpProxyBackend instance also manages an instance of the
// class net::URLRequestContext, that manages a single context for all the
// HTTP calls made to the backend server. Finally, the QuicHttpProxyBackend
// instance owns (creates/ destroys) the instances of QuicHttpProxyBackendStream
// to avoid orphan pointers of QuicHttpProxyBackendStream when the corresponding
// QUIC connection is destroyed on the main thread due to several reasons. The
// QUIC connection management and protocol parsing is performed by the main/quic
// thread, in the same way as the toy QUIC server.
//
// quic_http_proxy_backend_stream.h has a description of threads, the flow
// of packets in QUIC proxy in the forward and reverse directions.

#ifndef NET_TOOLS_QUIC_QUIC_HTTP_PROXY_BACKEND_H_
#define NET_TOOLS_QUIC_QUIC_HTTP_PROXY_BACKEND_H_

#include <stdint.h>

#include <memory>
#include <queue>

#include "base/base64.h"
#include "base/callback.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/values.h"
#include "net/third_party/quic/tools/quic_simple_server_backend.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_builder.h"
#include "url/gurl.h"

namespace base {
class SingleThreadTaskRunner;
}  // namespace base

namespace quic {
class QuicSimpleServerBackend;
}  // namespace quic

namespace net {
class QuicHttpProxyBackendStream;

// Manages the context to proxy HTTP requests to the backend server
// Owns instance of net::URLRequestContext.
class QuicHttpProxyBackend : public quic::QuicSimpleServerBackend {
 public:
  explicit QuicHttpProxyBackend();
  ~QuicHttpProxyBackend() override;

  // Must be called from the backend thread of the quic proxy
  net::URLRequestContext* GetURLRequestContext();
  scoped_refptr<base::SingleThreadTaskRunner> GetProxyTaskRunner() const;

  using ProxyBackendStreamMap =
      std::unordered_map<quic::QuicSimpleServerBackend::RequestHandler*,
                         std::unique_ptr<QuicHttpProxyBackendStream>>;
  const ProxyBackendStreamMap* proxy_backend_streams_map() const {
    return &backend_stream_map_;
  }

  GURL backend_url() const { return backend_url_; }

  // Implements the functions for interface quic::QuicSimpleServerBackend
  bool InitializeBackend(const std::string& backend_url) override;
  bool IsBackendInitialized() const override;
  void FetchResponseFromBackend(
      const spdy::SpdyHeaderBlock& request_headers,
      const std::string& incoming_body,
      quic::QuicSimpleServerBackend::RequestHandler* quic_stream) override;
  void CloseBackendResponseStream(
      quic::QuicSimpleServerBackend::RequestHandler* quic_stream) override;

 private:
  // Maps quic streams in the frontend to the corresponding http streams
  // managed by |this|
  ProxyBackendStreamMap backend_stream_map_;

  bool ValidateBackendUrl(const std::string& backend_url);
  void InitializeURLRequestContext();
  QuicHttpProxyBackendStream* InitializeQuicProxyBackendStream(
      quic::QuicSimpleServerBackend::RequestHandler* quic_server_stream);

  // URLRequestContext to make URL requests to the backend
  std::unique_ptr<net::URLRequestContext> context_;  // owned by this

  bool thread_initialized_;
  // <scheme://hostname:port/ for the backend HTTP server
  GURL backend_url_;

  // Backend thread is owned by |this|
  std::unique_ptr<base::Thread> proxy_thread_;
  scoped_refptr<base::SingleThreadTaskRunner> proxy_task_runner_;

  // Protects against concurrent access from quic (main) and proxy
  // threads for adding and clearing a backend request handler
  base::Lock backend_stream_mutex_;

  DISALLOW_COPY_AND_ASSIGN(QuicHttpProxyBackend);
};
}  // namespace net

#endif  // NET_TOOLS_QUIC_QUIC_HTTP_PROXY_BACKEND_H_