blob: 31199858e51331e0ff5d2646514d12aa84fd1948 [file] [log] [blame]
// 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/buffered_write_stream_socket.h"
#include "base/bind.h"
#include "base/location.h"
#include "base/message_loop.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
namespace net {
namespace {
void AppendBuffer(GrowableIOBuffer* dst, IOBuffer* src, int src_len) {
int old_capacity = dst->capacity();
dst->SetCapacity(old_capacity + src_len);
memcpy(dst->StartOfBuffer() + old_capacity, src->data(), src_len);
}
} // anonymous namespace
BufferedWriteStreamSocket::BufferedWriteStreamSocket(
StreamSocket* socket_to_wrap)
: wrapped_socket_(socket_to_wrap),
io_buffer_(new GrowableIOBuffer()),
backup_buffer_(new GrowableIOBuffer()),
ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
callback_pending_(false),
wrapped_write_in_progress_(false),
error_(0) {
}
BufferedWriteStreamSocket::~BufferedWriteStreamSocket() {
}
int BufferedWriteStreamSocket::Read(IOBuffer* buf, int buf_len,
const CompletionCallback& callback) {
return wrapped_socket_->Read(buf, buf_len, callback);
}
int BufferedWriteStreamSocket::Write(IOBuffer* buf, int buf_len,
const CompletionCallback& callback) {
if (error_) {
return error_;
}
GrowableIOBuffer* idle_buffer =
wrapped_write_in_progress_ ? backup_buffer_.get() : io_buffer_.get();
AppendBuffer(idle_buffer, buf, buf_len);
if (!callback_pending_) {
MessageLoop::current()->PostTask(
FROM_HERE,
base::Bind(&BufferedWriteStreamSocket::DoDelayedWrite,
weak_factory_.GetWeakPtr()));
callback_pending_ = true;
}
return buf_len;
}
bool BufferedWriteStreamSocket::SetReceiveBufferSize(int32 size) {
return wrapped_socket_->SetReceiveBufferSize(size);
}
bool BufferedWriteStreamSocket::SetSendBufferSize(int32 size) {
return wrapped_socket_->SetSendBufferSize(size);
}
int BufferedWriteStreamSocket::Connect(const CompletionCallback& callback) {
return wrapped_socket_->Connect(callback);
}
void BufferedWriteStreamSocket::Disconnect() {
wrapped_socket_->Disconnect();
}
bool BufferedWriteStreamSocket::IsConnected() const {
return wrapped_socket_->IsConnected();
}
bool BufferedWriteStreamSocket::IsConnectedAndIdle() const {
return wrapped_socket_->IsConnectedAndIdle();
}
int BufferedWriteStreamSocket::GetPeerAddress(IPEndPoint* address) const {
return wrapped_socket_->GetPeerAddress(address);
}
int BufferedWriteStreamSocket::GetLocalAddress(IPEndPoint* address) const {
return wrapped_socket_->GetLocalAddress(address);
}
const BoundNetLog& BufferedWriteStreamSocket::NetLog() const {
return wrapped_socket_->NetLog();
}
void BufferedWriteStreamSocket::SetSubresourceSpeculation() {
wrapped_socket_->SetSubresourceSpeculation();
}
void BufferedWriteStreamSocket::SetOmniboxSpeculation() {
wrapped_socket_->SetOmniboxSpeculation();
}
bool BufferedWriteStreamSocket::WasEverUsed() const {
return wrapped_socket_->WasEverUsed();
}
bool BufferedWriteStreamSocket::UsingTCPFastOpen() const {
return wrapped_socket_->UsingTCPFastOpen();
}
int64 BufferedWriteStreamSocket::NumBytesRead() const {
return wrapped_socket_->NumBytesRead();
}
base::TimeDelta BufferedWriteStreamSocket::GetConnectTimeMicros() const {
return wrapped_socket_->GetConnectTimeMicros();
}
bool BufferedWriteStreamSocket::WasNpnNegotiated() const {
return wrapped_socket_->WasNpnNegotiated();
}
NextProto BufferedWriteStreamSocket::GetNegotiatedProtocol() const {
return wrapped_socket_->GetNegotiatedProtocol();
}
bool BufferedWriteStreamSocket::GetSSLInfo(SSLInfo* ssl_info) {
return wrapped_socket_->GetSSLInfo(ssl_info);
}
void BufferedWriteStreamSocket::DoDelayedWrite() {
int result = wrapped_socket_->Write(
io_buffer_, io_buffer_->RemainingCapacity(),
base::Bind(&BufferedWriteStreamSocket::OnIOComplete,
base::Unretained(this)));
if (result == ERR_IO_PENDING) {
callback_pending_ = true;
wrapped_write_in_progress_ = true;
} else {
OnIOComplete(result);
}
}
void BufferedWriteStreamSocket::OnIOComplete(int result) {
callback_pending_ = false;
wrapped_write_in_progress_ = false;
if (backup_buffer_->RemainingCapacity()) {
AppendBuffer(io_buffer_.get(), backup_buffer_.get(),
backup_buffer_->RemainingCapacity());
backup_buffer_->SetCapacity(0);
}
if (result < 0) {
error_ = result;
io_buffer_->SetCapacity(0);
} else {
io_buffer_->set_offset(io_buffer_->offset() + result);
if (io_buffer_->RemainingCapacity()) {
DoDelayedWrite();
} else {
io_buffer_->SetCapacity(0);
}
}
}
} // namespace net