blob: 8163ced68845ad2475394ba1b12dd93ef1df7462 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
// 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_SERVER_HTTP_CONNECTION_H_
#define NET_SERVER_HTTP_CONNECTION_H_
#include <queue>
#include <string>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "net/base/io_buffer.h"
namespace net {
class StreamSocket;
class WebSocket;
// A container which has all information of an http connection. It includes
// id, underlying socket, and pending read/write data.
class HttpConnection {
public:
// IOBuffer for data read. It's a wrapper around GrowableIOBuffer, with more
// functions for buffer management. It moves unconsumed data to the start of
// buffer.
class ReadIOBuffer : public IOBuffer {
public:
static const int kInitialBufSize = 1024;
static const int kMinimumBufSize = 128;
static const int kCapacityIncreaseFactor = 2;
static const int kDefaultMaxBufferSize = 1 * 1024 * 1024; // 1 Mbytes.
ReadIOBuffer();
// Capacity.
int GetCapacity() const;
void SetCapacity(int capacity);
// Increases capacity and returns true if capacity is not beyond the limit.
bool IncreaseCapacity();
// Start of read data.
char* StartOfBuffer() const;
// Returns the bytes of read data.
int GetSize() const;
// More read data was appended.
void DidRead(int bytes);
// Capacity for which more read data can be appended.
int RemainingCapacity() const;
// Removes consumed data and moves unconsumed data to the start of buffer.
void DidConsume(int bytes);
// Limit of how much internal capacity can increase.
int max_buffer_size() const { return max_buffer_size_; }
void set_max_buffer_size(int max_buffer_size) {
max_buffer_size_ = max_buffer_size;
}
private:
~ReadIOBuffer() override;
scoped_refptr<GrowableIOBuffer> base_;
int max_buffer_size_;
DISALLOW_COPY_AND_ASSIGN(ReadIOBuffer);
};
// IOBuffer of pending data to write which has a queue of pending data. Each
// pending data is stored in std::string. data() is the data of first
// std::string stored.
class QueuedWriteIOBuffer : public IOBuffer {
public:
static const int kDefaultMaxBufferSize = 1 * 1024 * 1024; // 1 Mbytes.
QueuedWriteIOBuffer();
// Whether or not pending data exists.
bool IsEmpty() const;
// Appends new pending data and returns true if total size doesn't exceed
// the limit, |total_size_limit_|. It would change data() if new data is
// the first pending data.
bool Append(const std::string& data);
// Consumes data and changes data() accordingly. It cannot be more than
// GetSizeToWrite().
void DidConsume(int size);
// Gets size of data to write this time. It is NOT total data size.
int GetSizeToWrite() const;
// Total size of all pending data.
int total_size() const { return total_size_; }
// Limit of how much data can be pending.
int max_buffer_size() const { return max_buffer_size_; }
void set_max_buffer_size(int max_buffer_size) {
max_buffer_size_ = max_buffer_size;
}
private:
~QueuedWriteIOBuffer() override;
std::queue<std::string> pending_data_;
int total_size_;
int max_buffer_size_;
DISALLOW_COPY_AND_ASSIGN(QueuedWriteIOBuffer);
};
HttpConnection(int id, scoped_ptr<StreamSocket> socket);
~HttpConnection();
int id() const { return id_; }
StreamSocket* socket() const { return socket_.get(); }
ReadIOBuffer* read_buf() const { return read_buf_.get(); }
QueuedWriteIOBuffer* write_buf() const { return write_buf_.get(); }
WebSocket* web_socket() const { return web_socket_.get(); }
void SetWebSocket(scoped_ptr<WebSocket> web_socket);
private:
const int id_;
const scoped_ptr<StreamSocket> socket_;
const scoped_refptr<ReadIOBuffer> read_buf_;
const scoped_refptr<QueuedWriteIOBuffer> write_buf_;
scoped_ptr<WebSocket> web_socket_;
DISALLOW_COPY_AND_ASSIGN(HttpConnection);
};
} // namespace net
#endif // NET_SERVER_HTTP_CONNECTION_H_
|
