[Cast Channel] Add real SSL tests to CastSocketTest

net/socket/socket_test_util.cc

 // 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.
 
 #include "net/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 674 matching lines @@
 
   NET_TRACE(1, " *** ") << " Completing socket write for: "
                         << data.sequence_number;
   socket()->OnWriteComplete(rv);
   NET_TRACE(1, " *** ") << "Done";
 }
 
 SequencedSocketData::~SequencedSocketData() {
 }
 
+FakeDataChannel::FakeDataChannel()
+    : read_buf_len_(0),
+      closed_(false),
+      write_called_after_close_(false),
+      weak_factory_(this) {}
+
+FakeDataChannel::~FakeDataChannel() = default;
+
+int FakeDataChannel::Read(IOBuffer* buf,
+                          int buf_len,
+                          const CompletionCallback& callback) {
+  DCHECK(read_callback_.is_null());
+  DCHECK(!read_buf_.get());
+  if (closed_)
+    return 0;
+  if (data_.empty()) {
+    read_callback_ = callback;
+    read_buf_ = buf;
+    read_buf_len_ = buf_len;
+    return ERR_IO_PENDING;
+  }
+  return PropagateData(buf, buf_len);
+}
+
+int FakeDataChannel::Write(IOBuffer* buf,
+                           int buf_len,
+                           const CompletionCallback& callback) {
+  DCHECK(write_callback_.is_null());
+  if (closed_) {
+    if (write_called_after_close_)
+      return ERR_CONNECTION_RESET;
+    write_called_after_close_ = true;
+    write_callback_ = callback;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&FakeDataChannel::DoWriteCallback,
+                              weak_factory_.GetWeakPtr()));
+    return ERR_IO_PENDING;
+  }
+  // This function returns synchronously, so make a copy of the buffer.
+  data_.push(new DrainableIOBuffer(
+      new StringIOBuffer(std::string(buf->data(), buf_len)), buf_len));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&FakeDataChannel::DoReadCallback, weak_factory_.GetWeakPtr()));
+  return buf_len;
+}
+
+void FakeDataChannel::Close() {
+  closed_ = true;
+  if (!read_callback_.is_null()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&FakeDataChannel::DoReadCallback,
+                              weak_factory_.GetWeakPtr()));
+  }
+}
+
+void FakeDataChannel::DoReadCallback() {
+  if (read_callback_.is_null())
+    return;
+
+  if (closed_) {
+    base::ResetAndReturn(&read_callback_).Run(ERR_CONNECTION_CLOSED);
+    return;
+  }
+
+  if (data_.empty())
+    return;
+
+  int copied = PropagateData(read_buf_, read_buf_len_);
+  CompletionCallback callback = read_callback_;
+  read_callback_.Reset();
+  read_buf_ = NULL;
+  read_buf_len_ = 0;
+  callback.Run(copied);
+}
+
+void FakeDataChannel::DoWriteCallback() {
+  if (write_callback_.is_null())
+    return;
+
+  CompletionCallback callback = write_callback_;
+  write_callback_.Reset();
+  callback.Run(ERR_CONNECTION_RESET);
+}
+
+int FakeDataChannel::PropagateData(scoped_refptr<IOBuffer> read_buf,
+                                   int read_buf_len) {
+  scoped_refptr<DrainableIOBuffer> buf = data_.front();
+  int copied = std::min(buf->BytesRemaining(), read_buf_len);
+  memcpy(read_buf->data(), buf->data(), copied);
+  buf->DidConsume(copied);
+
+  if (!buf->BytesRemaining())
+    data_.pop();
+  return copied;
+}
+
+FakeSocket::~FakeSocket() {}
+
+int FakeSocket::Read(IOBuffer* buf,
+                     int buf_len,
+                     const CompletionCallback& callback) {
+  // Read random number of bytes.
+  buf_len = rand() % buf_len + 1;
+  return incoming_->Read(buf, buf_len, callback);
+}
+
+int FakeSocket::Write(IOBuffer* buf,
+                      int buf_len,
+                      const CompletionCallback& callback) {
+  // Write random number of bytes.
+  buf_len = rand() % buf_len + 1;
+  return outgoing_->Write(buf, buf_len, callback);
+}
+
+int FakeSocket::SetReceiveBufferSize(int32_t size) {
+  return OK;
+}
+
+int FakeSocket::SetSendBufferSize(int32_t size) {
+  return OK;
+}
+
+int FakeSocket::Connect(const CompletionCallback& callback) {
+  return OK;
+}
+
+void FakeSocket::Disconnect() {
+  incoming_->Close();
+  outgoing_->Close();
+}
+
+bool FakeSocket::IsConnected() const {
+  return true;
+}
+
+bool FakeSocket::IsConnectedAndIdle() const {
+  return true;
+}
+
+int FakeSocket::GetPeerAddress(IPEndPoint* address) const {
+  *address = IPEndPoint(IPAddress::IPv4AllZeros(), 0 /*port*/);
+  return OK;
+}
+
+int FakeSocket::GetLocalAddress(IPEndPoint* address) const {
+  *address = IPEndPoint(IPAddress::IPv4AllZeros(), 0 /*port*/);
+  return OK;
+}
+
+const BoundNetLog& FakeSocket::NetLog() const {
+  return net_log_;
+}
+
+void FakeSocket::SetSubresourceSpeculation() {}
+void FakeSocket::SetOmniboxSpeculation() {}
+
+bool FakeSocket::WasEverUsed() const {
+  return true;
+}
+
+bool FakeSocket::WasNpnNegotiated() const {
+  return false;
+}
+
+NextProto FakeSocket::GetNegotiatedProtocol() const {
+  return kProtoUnknown;
+}
+
+bool FakeSocket::GetSSLInfo(SSLInfo* ssl_info) {
+  return false;
+}
+
+void FakeSocket::GetConnectionAttempts(ConnectionAttempts* out) const {
+  out->clear();
+}
+
+void FakeSocket::ClearConnectionAttempts() {}
+
+void FakeSocket::AddConnectionAttempts(const ConnectionAttempts& attempts) {}
+
+int64_t FakeSocket::GetTotalReceivedBytes() const {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
 MockClientSocketFactory::MockClientSocketFactory() {}
 
 MockClientSocketFactory::~MockClientSocketFactory() {}
 
 void MockClientSocketFactory::AddSocketDataProvider(
     SocketDataProvider* data) {
   mock_data_.Add(data);
 }
 
 void MockClientSocketFactory::AddSSLSocketDataProvider(
@@ skipping 1030 matching lines @@
 }
 
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size) {
   int64_t total = 0;
   for (const MockWrite* write = writes; write != writes + writes_size; ++write)
     total += write->data_len;
   return total;
 }
 
 }  // namespace net