Make more things possible with mock sockets:...

net/socket/socket_test_util.cc

 // Copyright (c) 2009 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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "net/base/io_buffer.h"
@@ skipping 48 matching lines @@
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback);
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::CompletionCallback* callback);
 
  private:
   net::MockSocket* data_;
   int read_offset_;
-  net::MockRead* read_data_;
+  net::MockRead read_data_;
   bool need_read_data_;
 };
 
 class MockSSLClientSocket : public MockClientSocket {
  public:
   MockSSLClientSocket(
       net::ClientSocket* transport_socket,
       const std::string& hostname,
       const net::SSLConfig& ssl_config,
       net::MockSSLSocket* socket);
@@ skipping 64 matching lines @@
   net::CompletionCallback* c = callback_;
   callback_ = NULL;
   if (c)
     c->Run(result);
 }
 
 MockTCPClientSocket::MockTCPClientSocket(const net::AddressList& addresses,
                                          net::MockSocket* socket)
     : data_(socket),
       read_offset_(0),
-      read_data_(NULL),
+      read_data_(true, net::ERR_UNEXPECTED),
       need_read_data_(true) {
   DCHECK(data_);
   data_->Reset();
 }
 
 int MockTCPClientSocket::Connect(net::CompletionCallback* callback) {
   DCHECK(!callback_);
   if (connected_)
     return net::OK;
   connected_ = true;
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return net::ERR_IO_PENDING;
   }
   return data_->connect_data().result;
 }
 
 int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* callback) {
   DCHECK(!callback_);
+
+  if (!IsConnected())
+    return net::ERR_UNEXPECTED;
+
   if (need_read_data_) {
     read_data_ = data_->GetNextRead();
     need_read_data_ = false;
   }
-  int result = read_data_->result;
-  if (read_data_->data) {
-    if (read_data_->data_len - read_offset_ > 0) {
-      result = std::min(buf_len, read_data_->data_len - read_offset_);
-      memcpy(buf->data(), read_data_->data + read_offset_, result);
+  int result = read_data_.result;
+  if (read_data_.data) {
+    if (read_data_.data_len - read_offset_ > 0) {
+      result = std::min(buf_len, read_data_.data_len - read_offset_);
+      memcpy(buf->data(), read_data_.data + read_offset_, result);
       read_offset_ += result;
-      if (read_offset_ == read_data_->data_len) {
+      if (read_offset_ == read_data_.data_len) {
         need_read_data_ = true;
         read_offset_ = 0;
       }
     } else {
       result = 0;  // EOF
     }
   }
-  if (read_data_->async) {
+  if (read_data_.async) {
     RunCallbackAsync(callback, result);
     return net::ERR_IO_PENDING;
   }
   return result;
 }
 
 int MockTCPClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::CompletionCallback* callback) {
   DCHECK(buf);
   DCHECK(buf_len > 0);
   DCHECK(!callback_);
 
+  if (!IsConnected())
+    return net::ERR_UNEXPECTED;
+
   std::string data(buf->data(), buf_len);
   net::MockWriteResult write_result = data_->OnWrite(data);
 
   if (write_result.async) {
     RunCallbackAsync(callback, write_result.result);
     return net::ERR_IO_PENDING;
   }
   return write_result.result;
 }
 
@@ skipping 75 matching lines @@
 int MockSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::CompletionCallback* callback) {
   DCHECK(!callback_);
   return transport_->Write(buf, buf_len, callback);
 }
 
 }  // namespace
 
 namespace net {
 
-MockRead* StaticMockSocket::GetNextRead() {
-  return &reads_[read_index_++];
+MockRead StaticMockSocket::GetNextRead() {
+  return reads_[read_index_++];
 }
 
 MockWriteResult StaticMockSocket::OnWrite(const std::string& data) {
   if (!writes_) {
     // Not using mock writes; succeed synchronously.
     return MockWriteResult(false, data.length());
   }
 
   // Check that what we are writing matches the expectation.
   // Then give the mocked return value.
@@ skipping 10 matching lines @@
   return MockWriteResult(w->async, result);
 }
 
 void StaticMockSocket::Reset() {
   read_index_ = 0;
   write_index_ = 0;
 }
 
 DynamicMockSocket::DynamicMockSocket()
     : read_(false, ERR_UNEXPECTED),
-      has_read_(false) {
+      has_read_(false),
+      short_read_limit_(0) {
 }
 
-MockRead* DynamicMockSocket::GetNextRead() {
+MockRead DynamicMockSocket::GetNextRead() {
   if (!has_read_)
-    return unexpected_read();
-  has_read_ = false;
-  return &read_;
+    return MockRead(true, ERR_UNEXPECTED);
+  MockRead result = read_;
+  if (short_read_limit_ == 0 || result.data_len <= short_read_limit_) {
+    has_read_ = false;
+  } else {
+    result.data_len = short_read_limit_;
+    read_.data += result.data_len;
+    read_.data_len -= result.data_len;
+  }
+  return result;
 }
 
 void DynamicMockSocket::Reset() {
   has_read_ = false;
 }
 
 void DynamicMockSocket::SimulateRead(const char* data) {
   EXPECT_FALSE(has_read_) << "Unconsumed read: " << read_.data;
   read_ = MockRead(data);
   has_read_ = true;
@@ skipping 19 matching lines @@
 
 SSLClientSocket* MockClientSocketFactory::CreateSSLClientSocket(
     ClientSocket* transport_socket,
     const std::string& hostname,
     const SSLConfig& ssl_config) {
   return new MockSSLClientSocket(transport_socket, hostname, ssl_config,
                                  mock_ssl_sockets_.GetNext());
 }
 
 }  // namespace net