blob: a747eadb62e67c8b2e3ec22a125ee9a2d17113e3 (
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
// Copyright (c) 2011 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_BASE_IO_BUFFER_H_
#define NET_BASE_IO_BUFFER_H_
#pragma once
#include <string>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/pickle.h"
namespace net {
// This is a simple wrapper around a buffer that provides ref counting for
// easier asynchronous IO handling.
class IOBuffer : public base::RefCountedThreadSafe<IOBuffer> {
public:
IOBuffer();
explicit IOBuffer(int buffer_size);
char* data() { return data_; }
protected:
friend class base::RefCountedThreadSafe<IOBuffer>;
// Only allow derived classes to specify data_.
// In all other cases, we own data_, and must delete it at destruction time.
explicit IOBuffer(char* data);
virtual ~IOBuffer();
char* data_;
};
// This version stores the size of the buffer so that the creator of the object
// doesn't have to keep track of that value.
// NOTE: This doesn't mean that we want to stop sending the size as an explicit
// argument to IO functions. Please keep using IOBuffer* for API declarations.
class IOBufferWithSize : public IOBuffer {
public:
explicit IOBufferWithSize(int size);
int size() const { return size_; }
private:
virtual ~IOBufferWithSize();
int size_;
};
// This is a read only IOBuffer. The data is stored in a string and
// the IOBuffer interface does not provide a proper way to modify it.
class StringIOBuffer : public IOBuffer {
public:
explicit StringIOBuffer(const std::string& s);
int size() const { return string_data_.size(); }
private:
virtual ~StringIOBuffer();
std::string string_data_;
};
// This version wraps an existing IOBuffer and provides convenient functions
// to progressively read all the data.
class DrainableIOBuffer : public IOBuffer {
public:
DrainableIOBuffer(IOBuffer* base, int size);
// DidConsume() changes the |data_| pointer so that |data_| always points
// to the first unconsumed byte.
void DidConsume(int bytes);
// Returns the number of unconsumed bytes.
int BytesRemaining() const;
// Returns the number of consumed bytes.
int BytesConsumed() const;
// Seeks to an arbitrary point in the buffer. The notion of bytes consumed
// and remaining are updated appropriately.
void SetOffset(int bytes);
int size() const { return size_; }
private:
virtual ~DrainableIOBuffer();
scoped_refptr<IOBuffer> base_;
int size_;
int used_;
};
// This version provides a resizable buffer and a changeable offset.
class GrowableIOBuffer : public IOBuffer {
public:
GrowableIOBuffer();
// realloc memory to the specified capacity.
void SetCapacity(int capacity);
int capacity() { return capacity_; }
// |offset| moves the |data_| pointer, allowing "seeking" in the data.
void set_offset(int offset);
int offset() { return offset_; }
int RemainingCapacity();
char* StartOfBuffer();
private:
virtual ~GrowableIOBuffer();
scoped_ptr_malloc<char> real_data_;
int capacity_;
int offset_;
};
// This versions allows a pickle to be used as the storage for a write-style
// operation, avoiding an extra data copy.
class PickledIOBuffer : public IOBuffer {
public:
PickledIOBuffer();
Pickle* pickle() { return &pickle_; }
// Signals that we are done writing to the picke and we can use it for a
// write-style IO operation.
void Done();
private:
virtual ~PickledIOBuffer();
Pickle pickle_;
};
// This class allows the creation of a temporary IOBuffer that doesn't really
// own the underlying buffer. Please use this class only as a last resort.
// A good example is the buffer for a synchronous operation, where we can be
// sure that nobody is keeping an extra reference to this object so the lifetime
// of the buffer can be completely managed by its intended owner.
class WrappedIOBuffer : public IOBuffer {
public:
explicit WrappedIOBuffer(const char* data);
protected:
virtual ~WrappedIOBuffer();
};
} // namespace net
#endif // NET_BASE_IO_BUFFER_H_
|
