websocket_basic_stream_adapters.h 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155
  1. // Copyright 2018 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef NET_WEBSOCKETS_WEBSOCKET_BASIC_STREAM_ADAPTERS_H_
  5. #define NET_WEBSOCKETS_WEBSOCKET_BASIC_STREAM_ADAPTERS_H_
  6. #include <memory>
  7. #include "base/memory/raw_ptr.h"
  8. #include "base/memory/weak_ptr.h"
  9. #include "net/base/completion_once_callback.h"
  10. #include "net/base/net_export.h"
  11. #include "net/spdy/spdy_read_queue.h"
  12. #include "net/spdy/spdy_stream.h"
  13. #include "net/traffic_annotation/network_traffic_annotation.h"
  14. #include "net/websockets/websocket_basic_stream.h"
  15. namespace net {
  16. class ClientSocketHandle;
  17. class IOBuffer;
  18. class SpdyBuffer;
  19. // Trivial adapter to make WebSocketBasicStream use a TCP/IP or TLS socket.
  20. class NET_EXPORT_PRIVATE WebSocketClientSocketHandleAdapter
  21. : public WebSocketBasicStream::Adapter {
  22. public:
  23. WebSocketClientSocketHandleAdapter() = delete;
  24. explicit WebSocketClientSocketHandleAdapter(
  25. std::unique_ptr<ClientSocketHandle> connection);
  26. ~WebSocketClientSocketHandleAdapter() override;
  27. int Read(IOBuffer* buf,
  28. int buf_len,
  29. CompletionOnceCallback callback) override;
  30. int Write(IOBuffer* buf,
  31. int buf_len,
  32. CompletionOnceCallback callback,
  33. const NetworkTrafficAnnotationTag& traffic_annotation) override;
  34. void Disconnect() override;
  35. bool is_initialized() const override;
  36. private:
  37. std::unique_ptr<ClientSocketHandle> connection_;
  38. };
  39. // Adapter to make WebSocketBasicStream use an HTTP/2 stream.
  40. // Sets itself as a delegate of the SpdyStream, and forwards headers-related
  41. // methods to WebSocketHttp2HandshakeStream, which implements
  42. // WebSocketSpdyStreamAdapter::Delegate. After the handshake, ownership of this
  43. // object can be passed to WebSocketBasicStream, which can read and write using
  44. // a ClientSocketHandle-like interface.
  45. class NET_EXPORT_PRIVATE WebSocketSpdyStreamAdapter
  46. : public WebSocketBasicStream::Adapter,
  47. public SpdyStream::Delegate {
  48. public:
  49. // Interface for forwarding SpdyStream::Delegate methods necessary for the
  50. // handshake.
  51. class Delegate {
  52. public:
  53. virtual ~Delegate() = default;
  54. virtual void OnHeadersSent() = 0;
  55. virtual void OnHeadersReceived(
  56. const spdy::Http2HeaderBlock& response_headers) = 0;
  57. // Might destroy |this|.
  58. virtual void OnClose(int status) = 0;
  59. };
  60. // |delegate| must be valid until DetachDelegate() is called.
  61. WebSocketSpdyStreamAdapter(base::WeakPtr<SpdyStream> stream,
  62. Delegate* delegate,
  63. NetLogWithSource net_log);
  64. ~WebSocketSpdyStreamAdapter() override;
  65. // Called by WebSocketSpdyStreamAdapter::Delegate before it is destroyed.
  66. void DetachDelegate();
  67. // WebSocketBasicStream::Adapter methods.
  68. int Read(IOBuffer* buf,
  69. int buf_len,
  70. CompletionOnceCallback callback) override;
  71. // Write() must not be called before Delegate::OnHeadersSent() is called.
  72. // Write() always returns asynchronously.
  73. int Write(IOBuffer* buf,
  74. int buf_len,
  75. CompletionOnceCallback callback,
  76. const NetworkTrafficAnnotationTag& traffic_annotation) override;
  77. void Disconnect() override;
  78. bool is_initialized() const override;
  79. // SpdyStream::Delegate methods.
  80. void OnHeadersSent() override;
  81. void OnEarlyHintsReceived(const spdy::Http2HeaderBlock& headers) override;
  82. void OnHeadersReceived(
  83. const spdy::Http2HeaderBlock& response_headers,
  84. const spdy::Http2HeaderBlock* pushed_request_headers) override;
  85. void OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) override;
  86. void OnDataSent() override;
  87. void OnTrailers(const spdy::Http2HeaderBlock& trailers) override;
  88. void OnClose(int status) override;
  89. bool CanGreaseFrameType() const override;
  90. NetLogSource source_dependency() const override;
  91. private:
  92. // Copy data from read_data_ to read_buffer_.
  93. int CopySavedReadDataIntoBuffer();
  94. // Call WebSocketSpdyStreamAdapter::Delegate::OnClose().
  95. void CallDelegateOnClose();
  96. // True if SpdyStream::Delegate::OnHeadersSent() has been called.
  97. // SpdyStream::SendData() must not be called before that.
  98. bool headers_sent_ = false;
  99. // The underlying SpdyStream.
  100. base::WeakPtr<SpdyStream> stream_;
  101. // The error code with which SpdyStream was closed.
  102. int stream_error_ = ERR_CONNECTION_CLOSED;
  103. raw_ptr<Delegate> delegate_;
  104. // Buffer data pushed by SpdyStream until read through Read().
  105. SpdyReadQueue read_data_;
  106. // Read buffer and length used for both synchronous and asynchronous
  107. // read operations.
  108. raw_ptr<IOBuffer> read_buffer_;
  109. size_t read_length_;
  110. // Read callback saved for asynchronous reads.
  111. // Whenever |read_data_| is not empty, |read_callback_| must be null.
  112. CompletionOnceCallback read_callback_;
  113. // Write length saved to be passed to |write_callback_|. This is necessary
  114. // because SpdyStream::Delegate::OnDataSent() does not pass number of bytes
  115. // written.
  116. int write_length_ = 0;
  117. // Write callback saved for asynchronous writes (all writes are asynchronous).
  118. CompletionOnceCallback write_callback_;
  119. NetLogWithSource net_log_;
  120. base::WeakPtrFactory<WebSocketSpdyStreamAdapter> weak_factory_{this};
  121. };
  122. } // namespace net
  123. #endif // NET_WEBSOCKETS_WEBSOCKET_BASIC_STREAM_ADAPTERS_H_