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
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_IMAGE_DECODERS_RW_BUFFER_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_IMAGE_DECODERS_RW_BUFFER_H_
#include "base/functional/callback.h"
#include "base/memory/raw_ptr.h"
#include "third_party/blink/renderer/platform/platform_export.h"
#include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
namespace blink {
class ROBuffer;
/**
* Accumulates bytes of memory that are "appended" to it, growing internal
* storage as needed. The growth is done such that at any time in the writer's
* thread, an ROBuffer or StreamAsset can be snapped off (and safely passed to
* another thread). The ROBuffer/StreamAsset snapshot can see the previously
* stored bytes, but will be unaware of any future writes.
*/
class PLATFORM_EXPORT RWBuffer {
public:
struct BufferHead;
struct BufferBlock;
class PLATFORM_EXPORT ROIter {
public:
explicit ROIter(RWBuffer*, size_t);
// Returns a span of the current continuous block of memory. The span will
// be empty if the iterator is exhausted.
base::span<const uint8_t> operator*() const;
// Checks whether there is another block available and advances the iterator
// if there is.
bool Next();
// Checks whether there is another block available. Does not advance the
// iterator.
bool HasNext() const;
private:
raw_ptr<const RWBuffer> rw_buffer_;
raw_ptr<const RWBuffer::BufferBlock> block_;
size_t remaining_;
};
explicit RWBuffer(size_t initialCapacity = 0);
// |writer| is a function used to initialize the RWBuffer.
// |writer| is responsible for not writing off the edge of the buffer.
// |writer| should return the amount of memory written to the buffer.
RWBuffer(base::OnceCallback<size_t(base::span<uint8_t>)> writer,
size_t initial_capacity);
~RWBuffer();
RWBuffer& operator=(const RWBuffer&) = delete;
RWBuffer(const RWBuffer&) = delete;
size_t size() const { return total_used_; }
/**
* Append bytes from |buffer|.
*
* If the caller knows in advance how much more data they are going to
* append, they can pass a |reserve| hint (representing the number of upcoming
* bytes *in addition* to the current append), to minimize the number of
* internal allocations.
*/
void Append(base::span<const uint8_t> buffer, size_t reserve = 0);
scoped_refptr<ROBuffer> MakeROBufferSnapshot() const;
// This should only be called from the same thread that we are creating the
// RWBuffer and the snapshots on.
// If true is returned, it is guaranteed that |this| has unique ownership of
// its underlying buffer.
bool HasNoSnapshots() const;
void Validate() const;
private:
raw_ptr<BufferHead> head_ = nullptr;
raw_ptr<BufferBlock> tail_ = nullptr;
size_t total_used_ = 0;
};
/**
* Contains a read-only, thread-sharable block of memory. To access the memory,
* the caller must instantiate a local iterator, as the memory is stored in 1 or
* more contiguous blocks.
*/
class PLATFORM_EXPORT ROBuffer : public WTF::ThreadSafeRefCounted<ROBuffer> {
public:
/**
* Return the logical length of the data owned/shared by this buffer. It may
* be stored in multiple contiguous blocks, accessible via the iterator.
*/
size_t size() const { return available_; }
class PLATFORM_EXPORT Iter {
public:
explicit Iter(const ROBuffer*);
explicit Iter(const scoped_refptr<ROBuffer>&);
void Reset(const ROBuffer*);
/**
* Returns a span of the current continuous block of memory. The span will
* be empty if the iterator is exhausted.
*/
base::span<const uint8_t> operator*() const;
/**
* Advance to the next contiguous block of memory, returning true if there
* is another block, or false if the iterator is exhausted.
*/
bool Next();
private:
raw_ptr<const RWBuffer::BufferBlock> block_;
size_t remaining_;
raw_ptr<const ROBuffer> buffer_;
};
private:
friend class WTF::ThreadSafeRefCounted<ROBuffer>;
ROBuffer(const RWBuffer::BufferHead* head,
size_t available,
const RWBuffer::BufferBlock* tail);
~ROBuffer();
raw_ptr<const RWBuffer::BufferHead> head_;
const size_t available_;
raw_ptr<const RWBuffer::BufferBlock> tail_;
friend class RWBuffer;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_IMAGE_DECODERS_RW_BUFFER_H_
|
