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
|
// 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 BASE_MEMORY_REF_COUNTED_MEMORY_H_
#define BASE_MEMORY_REF_COUNTED_MEMORY_H_
#include <string>
#include <vector>
#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
namespace base {
// A generic interface to memory. This object is reference counted because one
// of its two subclasses own the data they carry, and we need to have
// heterogeneous containers of these two types of memory.
class BASE_EXPORT RefCountedMemory
: public base::RefCountedThreadSafe<RefCountedMemory> {
public:
// Retrieves a pointer to the beginning of the data we point to. If the data
// is empty, this will return NULL.
virtual const unsigned char* front() const = 0;
// Size of the memory pointed to.
virtual size_t size() const = 0;
// Returns true if |other| is byte for byte equal.
bool Equals(const scoped_refptr<RefCountedMemory>& other) const;
protected:
friend class base::RefCountedThreadSafe<RefCountedMemory>;
RefCountedMemory();
virtual ~RefCountedMemory();
};
// An implementation of RefCountedMemory, where the ref counting does not
// matter.
class BASE_EXPORT RefCountedStaticMemory : public RefCountedMemory {
public:
RefCountedStaticMemory()
: data_(NULL), length_(0) {}
RefCountedStaticMemory(const unsigned char* data, size_t length)
: data_(length ? data : NULL), length_(length) {}
// Overridden from RefCountedMemory:
virtual const unsigned char* front() const OVERRIDE;
virtual size_t size() const OVERRIDE;
private:
virtual ~RefCountedStaticMemory();
const unsigned char* data_;
size_t length_;
DISALLOW_COPY_AND_ASSIGN(RefCountedStaticMemory);
};
// An implementation of RefCountedMemory, where we own our the data in a
// vector.
class BASE_EXPORT RefCountedBytes : public RefCountedMemory {
public:
RefCountedBytes();
// Constructs a RefCountedBytes object by _copying_ from |initializer|.
explicit RefCountedBytes(const std::vector<unsigned char>& initializer);
// Constructs a RefCountedBytes object by performing a swap. (To non
// destructively build a RefCountedBytes, use the constructor that takes a
// vector.)
static RefCountedBytes* TakeVector(std::vector<unsigned char>* to_destroy);
// Overridden from RefCountedMemory:
virtual const unsigned char* front() const OVERRIDE;
virtual size_t size() const OVERRIDE;
const std::vector<unsigned char>& data() const { return data_; }
std::vector<unsigned char>& data() { return data_; }
private:
virtual ~RefCountedBytes();
std::vector<unsigned char> data_;
DISALLOW_COPY_AND_ASSIGN(RefCountedBytes);
};
// An implementation of RefCountedMemory, where the bytes are stored in an STL
// string. Use this if your data naturally arrives in that format.
class BASE_EXPORT RefCountedString : public RefCountedMemory {
public:
RefCountedString();
// Constructs a RefCountedString object by performing a swap. (To non
// destructively build a RefCountedString, use the default constructor and
// copy into object->data()).
static RefCountedString* TakeString(std::string* to_destroy);
// Overridden from RefCountedMemory:
virtual const unsigned char* front() const OVERRIDE;
virtual size_t size() const OVERRIDE;
const std::string& data() const { return data_; }
std::string& data() { return data_; }
private:
virtual ~RefCountedString();
std::string data_;
DISALLOW_COPY_AND_ASSIGN(RefCountedString);
};
// An implementation of RefCountedMemory that holds a chunk of memory
// previously allocated with malloc or calloc, and that therefore must be freed
// using free().
class BASE_EXPORT RefCountedMallocedMemory : public base::RefCountedMemory {
public:
RefCountedMallocedMemory(void* data, size_t length);
// Overridden from RefCountedMemory:
virtual const unsigned char* front() const OVERRIDE;
virtual size_t size() const OVERRIDE;
private:
virtual ~RefCountedMallocedMemory();
unsigned char* data_;
size_t length_;
DISALLOW_COPY_AND_ASSIGN(RefCountedMallocedMemory);
};
} // namespace base
#endif // BASE_MEMORY_REF_COUNTED_MEMORY_H_
|
