[Cast Channel] Add real SSL tests to CastSocketTest

net/socket/socket_test_util.h

 // Copyright (c) 2012 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 NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstring>
 #include <deque>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
+#include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
+#include "net/base/ip_address.h"
+#include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_auth_controller.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/log/net_log.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/connection_attempts.h"
 #include "net/socket/socket_performance_watcher.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/ssl_client_socket_pool.h"
+#include "net/socket/stream_socket.h"
 #include "net/socket/transport_client_socket_pool.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/udp/datagram_client_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 class RunLoop;
 }
 
 namespace net {
 
 const NetworkChangeNotifier::NetworkHandle kDefaultNetworkForTests = 1;
 const NetworkChangeNotifier::NetworkHandle kNewNetworkForTests = 2;
 
 enum {
   // A private network error code used by the socket test utility classes.
   // If the |result| member of a MockRead is
   // ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ, that MockRead is just a
   // marker that indicates the peer will close the connection after the next
   // MockRead.  The other members of that MockRead are ignored.
   ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ = -10000,
 };
 
 class AsyncSocket;
 class ChannelIDService;
 class MockClientSocket;
 class SSLClientSocket;
-class StreamSocket;
 
 enum IoMode {
   ASYNC,
   SYNCHRONOUS
 };
 
 struct MockConnect {
   // Asynchronous connection success.
   // Creates a MockConnect with |mode| ASYC, |result| OK, and
   // |peer_addr| 192.0.2.33.
@@ skipping 408 matching lines @@
 
  private:
   // Index of the next |data_providers_| element to use. Not an iterator
   // because those are invalidated on vector reallocation.
   size_t next_index_;
 
   // SocketDataProviders to be returned.
   std::vector<T*> data_providers_;
 };
 
+class FakeDataChannel {
+ public:
+  FakeDataChannel();
+  ~FakeDataChannel();
+
+  int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
+  int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
+
+  // Closes the FakeDataChannel. After Close() is called, Read() returns 0,
+  // indicating EOF, and Write() fails with ERR_CONNECTION_RESET. Note that
+  // after the FakeDataChannel is closed, the first Write() call completes
+  // asynchronously, which is necessary to reproduce bug 127822.
+  void Close();
+
+ private:
+  void DoReadCallback();
+  void DoWriteCallback();
+
+  int PropagateData(scoped_refptr<IOBuffer> read_buf, int read_buf_len);
+
+  CompletionCallback read_callback_;
+  scoped_refptr<IOBuffer> read_buf_;
+  int read_buf_len_;
+
+  CompletionCallback write_callback_;
+
+  std::queue<scoped_refptr<DrainableIOBuffer>> data_;
+
+  // True if Close() has been called.
+  bool closed_;
+
+  // Controls the completion of Write() after the FakeDataChannel is closed.
+  // After the FakeDataChannel is closed, the first Write() call completes
+  // asynchronously.
+  bool write_called_after_close_;
+
+  base::WeakPtrFactory<FakeDataChannel> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeDataChannel);
+};
+
+class FakeSocket : public StreamSocket {
+ public:
+  FakeSocket(FakeDataChannel* incoming_channel,
+             FakeDataChannel* outgoing_channel)
+      : incoming_(incoming_channel), outgoing_(outgoing_channel) {}
+
+  ~FakeSocket() override;
+
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override;
+
+  int Write(IOBuffer* buf,
+            int buf_len,
+            const CompletionCallback& callback) override;
+
+  int SetReceiveBufferSize(int32_t size) override;
+
+  int SetSendBufferSize(int32_t size) override;
+
+  int Connect(const CompletionCallback& callback) override;
+
+  void Disconnect() override;
+
+  bool IsConnected() const override;
+
+  bool IsConnectedAndIdle() const override;
+
+  int GetPeerAddress(IPEndPoint* address) const override;
+
+  int GetLocalAddress(IPEndPoint* address) const override;
+
+  const BoundNetLog& NetLog() const override;
+
+  void SetSubresourceSpeculation() override;
+  void SetOmniboxSpeculation() override;
+
+  bool WasEverUsed() const override;
+
+  bool WasNpnNegotiated() const override;
+
+  NextProto GetNegotiatedProtocol() const override;
+
+  bool GetSSLInfo(SSLInfo* ssl_info) override;
+
+  void GetConnectionAttempts(ConnectionAttempts* out) const override;
+
+  void ClearConnectionAttempts() override;
+
+  void AddConnectionAttempts(const ConnectionAttempts& attempts) override;
+
+  int64_t GetTotalReceivedBytes() const override;
+
+ private:
+  BoundNetLog net_log_;
+  FakeDataChannel* incoming_;
+  FakeDataChannel* outgoing_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeSocket);
+};
+
 class MockUDPClientSocket;
 class MockTCPClientSocket;
 class MockSSLClientSocket;
 
 // ClientSocketFactory which contains arrays of sockets of each type.
 // You should first fill the arrays using AddMock{SSL,}Socket. When the factory
 // is asked to create a socket, it takes next entry from appropriate array.
 // You can use ResetNextMockIndexes to reset that next entry index for all mock
 // socket types.
 class MockClientSocketFactory : public ClientSocketFactory {
@@ skipping 502 matching lines @@
 
 // Helper function to get the total data size of the MockReads in |reads|.
 int64_t CountReadBytes(const MockRead reads[], size_t reads_size);
 
 // Helper function to get the total data size of the MockWrites in |writes|.
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size);
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_