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
|
// Copyright 2015 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.
#include "content/child/shared_memory_received_data_factory.h"
#include <algorithm>
#include "base/macros.h"
#include "content/common/resource_messages.h"
#include "ipc/ipc_sender.h"
namespace content {
class SharedMemoryReceivedDataFactory::SharedMemoryReceivedData final
: public RequestPeer::ReceivedData {
public:
SharedMemoryReceivedData(
const char* payload,
int length,
int encoded_length,
scoped_refptr<SharedMemoryReceivedDataFactory> factory,
SharedMemoryReceivedDataFactory::TicketId id)
: payload_(payload),
length_(length),
encoded_length_(encoded_length),
factory_(factory),
id_(id) {}
~SharedMemoryReceivedData() override { factory_->Reclaim(id_); }
const char* payload() const override { return payload_; }
int length() const override { return length_; }
int encoded_length() const override { return encoded_length_; }
private:
const char* const payload_;
const int length_;
const int encoded_length_;
scoped_refptr<SharedMemoryReceivedDataFactory> factory_;
SharedMemoryReceivedDataFactory::TicketId id_;
DISALLOW_COPY_AND_ASSIGN(SharedMemoryReceivedData);
};
SharedMemoryReceivedDataFactory::SharedMemoryReceivedDataFactory(
IPC::Sender* message_sender,
int request_id,
linked_ptr<base::SharedMemory> memory)
: id_(0),
oldest_(0),
message_sender_(message_sender),
request_id_(request_id),
is_stopped_(false),
memory_(memory) {
}
SharedMemoryReceivedDataFactory::~SharedMemoryReceivedDataFactory() {
if (!is_stopped_)
SendAck(released_tickets_.size());
}
scoped_ptr<RequestPeer::ReceivedData> SharedMemoryReceivedDataFactory::Create(
int offset,
int length,
int encoded_length) {
const char* start = static_cast<char*>(memory_->memory());
const char* payload = start + offset;
TicketId id = id_++;
return make_scoped_ptr(
new SharedMemoryReceivedData(payload, length, encoded_length, this, id));
}
void SharedMemoryReceivedDataFactory::Stop() {
is_stopped_ = true;
released_tickets_.clear();
message_sender_ = nullptr;
}
class SharedMemoryReceivedDataFactory::TicketComparator final {
public:
explicit TicketComparator(TicketId oldest) : oldest_(oldest) {}
bool operator()(TicketId x, TicketId y) const {
if ((oldest_ <= x) == (oldest_ <= y))
return x <= y;
return (oldest_ <= x);
}
private:
TicketId oldest_;
};
void SharedMemoryReceivedDataFactory::Reclaim(TicketId id) {
if (is_stopped_)
return;
if (oldest_ != id) {
released_tickets_.push_back(id);
return;
}
++oldest_;
SendAck(1);
if (released_tickets_.empty()) {
// Fast path: (hopefully) the most typical case.
return;
}
std::sort(released_tickets_.begin(), released_tickets_.end(),
TicketComparator(oldest_));
size_t count = 0;
for (size_t i = 0;; ++i) {
if (i == released_tickets_.size() ||
released_tickets_[i] != static_cast<TicketId>(id + i + 1)) {
count = i;
break;
}
}
released_tickets_.erase(released_tickets_.begin(),
released_tickets_.begin() + count);
oldest_ += count;
SendAck(count);
}
void SharedMemoryReceivedDataFactory::SendAck(size_t count) {
for (size_t i = 0; i < count; ++i) {
message_sender_->Send(new ResourceHostMsg_DataReceived_ACK(request_id_));
}
}
} // namespace content
|
