1 // Copyright (c) 2012 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
5 #include "net/server/http_connection.h"
6
7 #include "base/logging.h"
8 #include "net/server/web_socket.h"
9 #include "net/socket/stream_socket.h"
10
11 namespace net {
12
ReadIOBuffer()13 HttpConnection::ReadIOBuffer::ReadIOBuffer()
14 : base_(new GrowableIOBuffer()),
15 max_buffer_size_(kDefaultMaxBufferSize) {
16 SetCapacity(kInitialBufSize);
17 }
18
~ReadIOBuffer()19 HttpConnection::ReadIOBuffer::~ReadIOBuffer() {
20 data_ = NULL; // base_ owns data_.
21 }
22
GetCapacity() const23 int HttpConnection::ReadIOBuffer::GetCapacity() const {
24 return base_->capacity();
25 }
26
SetCapacity(int capacity)27 void HttpConnection::ReadIOBuffer::SetCapacity(int capacity) {
28 DCHECK_LE(GetSize(), capacity);
29 base_->SetCapacity(capacity);
30 data_ = base_->data();
31 }
32
IncreaseCapacity()33 bool HttpConnection::ReadIOBuffer::IncreaseCapacity() {
34 if (GetCapacity() >= max_buffer_size_) {
35 LOG(ERROR) << "Too large read data is pending: capacity=" << GetCapacity()
36 << ", max_buffer_size=" << max_buffer_size_
37 << ", read=" << GetSize();
38 return false;
39 }
40
41 int new_capacity = GetCapacity() * kCapacityIncreaseFactor;
42 if (new_capacity > max_buffer_size_)
43 new_capacity = max_buffer_size_;
44 SetCapacity(new_capacity);
45 return true;
46 }
47
StartOfBuffer() const48 char* HttpConnection::ReadIOBuffer::StartOfBuffer() const {
49 return base_->StartOfBuffer();
50 }
51
GetSize() const52 int HttpConnection::ReadIOBuffer::GetSize() const {
53 return base_->offset();
54 }
55
DidRead(int bytes)56 void HttpConnection::ReadIOBuffer::DidRead(int bytes) {
57 DCHECK_GE(RemainingCapacity(), bytes);
58 base_->set_offset(base_->offset() + bytes);
59 data_ = base_->data();
60 }
61
RemainingCapacity() const62 int HttpConnection::ReadIOBuffer::RemainingCapacity() const {
63 return base_->RemainingCapacity();
64 }
65
DidConsume(int bytes)66 void HttpConnection::ReadIOBuffer::DidConsume(int bytes) {
67 int previous_size = GetSize();
68 int unconsumed_size = previous_size - bytes;
69 DCHECK_LE(0, unconsumed_size);
70 if (unconsumed_size > 0) {
71 // Move unconsumed data to the start of buffer.
72 memmove(StartOfBuffer(), StartOfBuffer() + bytes, unconsumed_size);
73 }
74 base_->set_offset(unconsumed_size);
75 data_ = base_->data();
76
77 // If capacity is too big, reduce it.
78 if (GetCapacity() > kMinimumBufSize &&
79 GetCapacity() > previous_size * kCapacityIncreaseFactor) {
80 int new_capacity = GetCapacity() / kCapacityIncreaseFactor;
81 if (new_capacity < kMinimumBufSize)
82 new_capacity = kMinimumBufSize;
83 // realloc() within GrowableIOBuffer::SetCapacity() could move data even
84 // when size is reduced. If unconsumed_size == 0, i.e. no data exists in
85 // the buffer, free internal buffer first to guarantee no data move.
86 if (!unconsumed_size)
87 base_->SetCapacity(0);
88 SetCapacity(new_capacity);
89 }
90 }
91
QueuedWriteIOBuffer()92 HttpConnection::QueuedWriteIOBuffer::QueuedWriteIOBuffer()
93 : total_size_(0),
94 max_buffer_size_(kDefaultMaxBufferSize) {
95 }
96
~QueuedWriteIOBuffer()97 HttpConnection::QueuedWriteIOBuffer::~QueuedWriteIOBuffer() {
98 data_ = NULL; // pending_data_ owns data_.
99 }
100
IsEmpty() const101 bool HttpConnection::QueuedWriteIOBuffer::IsEmpty() const {
102 return pending_data_.empty();
103 }
104
Append(const std::string & data)105 bool HttpConnection::QueuedWriteIOBuffer::Append(const std::string& data) {
106 if (data.empty())
107 return true;
108
109 if (total_size_ + static_cast<int>(data.size()) > max_buffer_size_) {
110 LOG(ERROR) << "Too large write data is pending: size="
111 << total_size_ + data.size()
112 << ", max_buffer_size=" << max_buffer_size_;
113 return false;
114 }
115
116 pending_data_.push(data);
117 total_size_ += data.size();
118
119 // If new data is the first pending data, updates data_.
120 if (pending_data_.size() == 1)
121 data_ = const_cast<char*>(pending_data_.front().data());
122 return true;
123 }
124
DidConsume(int size)125 void HttpConnection::QueuedWriteIOBuffer::DidConsume(int size) {
126 DCHECK_GE(total_size_, size);
127 DCHECK_GE(GetSizeToWrite(), size);
128 if (size == 0)
129 return;
130
131 if (size < GetSizeToWrite()) {
132 data_ += size;
133 } else { // size == GetSizeToWrite(). Updates data_ to next pending data.
134 pending_data_.pop();
135 data_ = IsEmpty() ? NULL : const_cast<char*>(pending_data_.front().data());
136 }
137 total_size_ -= size;
138 }
139
GetSizeToWrite() const140 int HttpConnection::QueuedWriteIOBuffer::GetSizeToWrite() const {
141 if (IsEmpty()) {
142 DCHECK_EQ(0, total_size_);
143 return 0;
144 }
145 DCHECK_GE(data_, pending_data_.front().data());
146 int consumed = static_cast<int>(data_ - pending_data_.front().data());
147 DCHECK_GT(static_cast<int>(pending_data_.front().size()), consumed);
148 return pending_data_.front().size() - consumed;
149 }
150
HttpConnection(int id,scoped_ptr<StreamSocket> socket)151 HttpConnection::HttpConnection(int id, scoped_ptr<StreamSocket> socket)
152 : id_(id),
153 socket_(socket.Pass()),
154 read_buf_(new ReadIOBuffer()),
155 write_buf_(new QueuedWriteIOBuffer()) {
156 }
157
~HttpConnection()158 HttpConnection::~HttpConnection() {
159 }
160
SetWebSocket(scoped_ptr<WebSocket> web_socket)161 void HttpConnection::SetWebSocket(scoped_ptr<WebSocket> web_socket) {
162 DCHECK(!web_socket_);
163 web_socket_ = web_socket.Pass();
164 }
165
166 } // namespace net
167