OLD | NEW |
---|---|
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/media/midi_message_filter.h" | 5 #include "content/renderer/media/midi_message_filter.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/debug/trace_event.h" | 10 #include "base/debug/trace_event.h" |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
53 void MidiMessageFilter::RemoveClient(blink::WebMIDIAccessorClient* client) { | 53 void MidiMessageFilter::RemoveClient(blink::WebMIDIAccessorClient* client) { |
54 base::AutoLock auto_lock(lock_); | 54 base::AutoLock auto_lock(lock_); |
55 clients_.erase(client); | 55 clients_.erase(client); |
56 ClientsQueue::iterator it = std::find(clients_waiting_session_queue_.begin(), | 56 ClientsQueue::iterator it = std::find(clients_waiting_session_queue_.begin(), |
57 clients_waiting_session_queue_.end(), | 57 clients_waiting_session_queue_.end(), |
58 client); | 58 client); |
59 if (it != clients_waiting_session_queue_.end()) | 59 if (it != clients_waiting_session_queue_.end()) |
60 clients_waiting_session_queue_.erase(it); | 60 clients_waiting_session_queue_.erase(it); |
61 if (clients_.empty() && clients_waiting_session_queue_.empty()) { | 61 if (clients_.empty() && clients_waiting_session_queue_.empty()) { |
62 session_result_ = media::MIDI_NOT_INITIALIZED; | 62 session_result_ = media::MIDI_NOT_INITIALIZED; |
63 inputs_.clear(); | |
64 outputs_.clear(); | |
63 io_message_loop_->PostTask(FROM_HERE, | 65 io_message_loop_->PostTask(FROM_HERE, |
64 base::Bind(&MidiMessageFilter::EndSessionOnIOThread, this)); | 66 base::Bind(&MidiMessageFilter::EndSessionOnIOThread, this)); |
65 } | 67 } |
66 } | 68 } |
67 | 69 |
68 void MidiMessageFilter::SendMidiData(uint32 port, | 70 void MidiMessageFilter::SendMidiData(uint32 port, |
69 const uint8* data, | 71 const uint8* data, |
70 size_t length, | 72 size_t length, |
71 double timestamp) { | 73 double timestamp) { |
72 if (length > kMaxUnacknowledgedBytesSent) { | 74 if (length > kMaxUnacknowledgedBytesSent) { |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
118 } else { | 120 } else { |
119 sender_->Send(message); | 121 sender_->Send(message); |
120 } | 122 } |
121 } | 123 } |
122 | 124 |
123 bool MidiMessageFilter::OnMessageReceived(const IPC::Message& message) { | 125 bool MidiMessageFilter::OnMessageReceived(const IPC::Message& message) { |
124 DCHECK(io_message_loop_->BelongsToCurrentThread()); | 126 DCHECK(io_message_loop_->BelongsToCurrentThread()); |
125 bool handled = true; | 127 bool handled = true; |
126 IPC_BEGIN_MESSAGE_MAP(MidiMessageFilter, message) | 128 IPC_BEGIN_MESSAGE_MAP(MidiMessageFilter, message) |
127 IPC_MESSAGE_HANDLER(MidiMsg_SessionStarted, OnSessionStarted) | 129 IPC_MESSAGE_HANDLER(MidiMsg_SessionStarted, OnSessionStarted) |
130 IPC_MESSAGE_HANDLER(MidiMsg_AddInputPort, OnAddInputPort) | |
131 IPC_MESSAGE_HANDLER(MidiMsg_AddOutputPort, OnAddOutputPort) | |
128 IPC_MESSAGE_HANDLER(MidiMsg_DataReceived, OnDataReceived) | 132 IPC_MESSAGE_HANDLER(MidiMsg_DataReceived, OnDataReceived) |
129 IPC_MESSAGE_HANDLER(MidiMsg_AcknowledgeSentData, OnAcknowledgeSentData) | 133 IPC_MESSAGE_HANDLER(MidiMsg_AcknowledgeSentData, OnAcknowledgeSentData) |
130 IPC_MESSAGE_UNHANDLED(handled = false) | 134 IPC_MESSAGE_UNHANDLED(handled = false) |
131 IPC_END_MESSAGE_MAP() | 135 IPC_END_MESSAGE_MAP() |
132 return handled; | 136 return handled; |
133 } | 137 } |
134 | 138 |
135 void MidiMessageFilter::OnFilterAdded(IPC::Sender* sender) { | 139 void MidiMessageFilter::OnFilterAdded(IPC::Sender* sender) { |
136 DCHECK(io_message_loop_->BelongsToCurrentThread()); | 140 DCHECK(io_message_loop_->BelongsToCurrentThread()); |
137 sender_ = sender; | 141 sender_ = sender; |
138 } | 142 } |
139 | 143 |
140 void MidiMessageFilter::OnFilterRemoved() { | 144 void MidiMessageFilter::OnFilterRemoved() { |
141 DCHECK(io_message_loop_->BelongsToCurrentThread()); | 145 DCHECK(io_message_loop_->BelongsToCurrentThread()); |
142 // Once removed, a filter will not be used again. At this time all | 146 // Once removed, a filter will not be used again. At this time all |
143 // delegates must be notified so they release their reference. | 147 // delegates must be notified so they release their reference. |
144 OnChannelClosing(); | 148 OnChannelClosing(); |
145 } | 149 } |
146 | 150 |
147 void MidiMessageFilter::OnChannelClosing() { | 151 void MidiMessageFilter::OnChannelClosing() { |
148 DCHECK(io_message_loop_->BelongsToCurrentThread()); | 152 DCHECK(io_message_loop_->BelongsToCurrentThread()); |
149 sender_ = NULL; | 153 sender_ = NULL; |
150 } | 154 } |
151 | 155 |
152 void MidiMessageFilter::OnSessionStarted(media::MidiResult result, | 156 void MidiMessageFilter::OnSessionStarted(media::MidiResult result) { |
153 MidiPortInfoList inputs, | |
154 MidiPortInfoList outputs) { | |
155 TRACE_EVENT0("midi", "MidiMessageFilter::OnSessionStarted"); | 157 TRACE_EVENT0("midi", "MidiMessageFilter::OnSessionStarted"); |
156 DCHECK(io_message_loop_->BelongsToCurrentThread()); | 158 DCHECK(io_message_loop_->BelongsToCurrentThread()); |
157 base::AutoLock auto_lock(lock_); | 159 base::AutoLock auto_lock(lock_); |
158 session_result_ = result; | 160 session_result_ = result; |
159 inputs_ = inputs; | |
160 outputs_ = outputs; | |
161 // Handle on the main JS thread. | 161 // Handle on the main JS thread. |
162 for (blink::WebMIDIAccessorClient* client : clients_waiting_session_queue_) { | 162 for (blink::WebMIDIAccessorClient* client : clients_waiting_session_queue_) { |
163 main_message_loop_->PostTask(FROM_HERE, | 163 main_message_loop_->PostTask(FROM_HERE, |
164 base::Bind(&MidiMessageFilter::HandleClientAdded, this, client)); | 164 base::Bind(&MidiMessageFilter::HandleClientAdded, this, client)); |
165 } | 165 } |
166 clients_waiting_session_queue_.clear(); | 166 clients_waiting_session_queue_.clear(); |
167 } | 167 } |
168 | 168 |
169 void MidiMessageFilter::OnAddInputPort(media::MidiPortInfo info) { | |
170 DCHECK(io_message_loop_->BelongsToCurrentThread()); | |
171 base::AutoLock auto_lock(lock_); | |
172 inputs_.push_back(info); | |
173 // TODO(toyoshim): Notify to clients that were already added. | |
174 } | |
175 | |
176 void MidiMessageFilter::OnAddOutputPort(media::MidiPortInfo info) { | |
177 DCHECK(io_message_loop_->BelongsToCurrentThread()); | |
178 base::AutoLock auto_lock(lock_); | |
179 outputs_.push_back(info); | |
180 // TODO(toyoshim): Notify to clients that were already added. | |
181 } | |
182 | |
169 void MidiMessageFilter::OnDataReceived(uint32 port, | 183 void MidiMessageFilter::OnDataReceived(uint32 port, |
170 const std::vector<uint8>& data, | 184 const std::vector<uint8>& data, |
171 double timestamp) { | 185 double timestamp) { |
172 TRACE_EVENT0("midi", "MidiMessageFilter::OnDataReceived"); | 186 TRACE_EVENT0("midi", "MidiMessageFilter::OnDataReceived"); |
173 DCHECK(io_message_loop_->BelongsToCurrentThread()); | 187 DCHECK(io_message_loop_->BelongsToCurrentThread()); |
174 main_message_loop_->PostTask( | 188 main_message_loop_->PostTask( |
175 FROM_HERE, | 189 FROM_HERE, |
176 base::Bind(&MidiMessageFilter::HandleDataReceived, this, | 190 base::Bind(&MidiMessageFilter::HandleDataReceived, this, |
177 port, data, timestamp)); | 191 port, data, timestamp)); |
178 } | 192 } |
179 | 193 |
180 void MidiMessageFilter::OnAcknowledgeSentData(size_t bytes_sent) { | 194 void MidiMessageFilter::OnAcknowledgeSentData(size_t bytes_sent) { |
181 DCHECK(io_message_loop_->BelongsToCurrentThread()); | 195 DCHECK(io_message_loop_->BelongsToCurrentThread()); |
182 DCHECK_GE(unacknowledged_bytes_sent_, bytes_sent); | 196 DCHECK_GE(unacknowledged_bytes_sent_, bytes_sent); |
183 if (unacknowledged_bytes_sent_ >= bytes_sent) | 197 if (unacknowledged_bytes_sent_ >= bytes_sent) |
184 unacknowledged_bytes_sent_ -= bytes_sent; | 198 unacknowledged_bytes_sent_ -= bytes_sent; |
185 } | 199 } |
186 | 200 |
187 void MidiMessageFilter::HandleClientAdded( | 201 void MidiMessageFilter::HandleClientAdded( |
188 blink::WebMIDIAccessorClient* client) { | 202 blink::WebMIDIAccessorClient* client) { |
189 TRACE_EVENT0("midi", "MidiMessageFilter::HandleClientAdded"); | 203 TRACE_EVENT0("midi", "MidiMessageFilter::HandleClientAdded"); |
190 DCHECK(main_message_loop_->BelongsToCurrentThread()); | 204 DCHECK(main_message_loop_->BelongsToCurrentThread()); |
191 media::MidiResult result; | 205 media::MidiResult result; |
192 { | 206 { |
193 base::AutoLock auto_lock(lock_); | 207 base::AutoLock auto_lock(lock_); |
194 result = session_result_; | 208 result = session_result_; |
195 } | 209 } |
Takashi Toyoshima
2014/10/20 18:31:12
Originally, I protect line 210:230 with the lock_
| |
196 if (result == media::MIDI_OK) { | 210 if (result == media::MIDI_OK) { |
197 // Add the client's input and output ports. | 211 // Add the client's input and output ports. |
198 const bool active = true; | 212 const bool active = true; |
199 for (media::MidiPortInfo info : inputs_) { | 213 for (media::MidiPortInfo info : inputs_) { |
200 client->didAddInputPort( | 214 client->didAddInputPort( |
201 base::UTF8ToUTF16(info.id), | 215 base::UTF8ToUTF16(info.id), |
202 base::UTF8ToUTF16(info.manufacturer), | 216 base::UTF8ToUTF16(info.manufacturer), |
203 base::UTF8ToUTF16(info.name), | 217 base::UTF8ToUTF16(info.name), |
204 base::UTF8ToUTF16(info.version), | 218 base::UTF8ToUTF16(info.version), |
205 true); | 219 true); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
245 double timestamp) { | 259 double timestamp) { |
246 TRACE_EVENT0("midi", "MidiMessageFilter::HandleDataReceived"); | 260 TRACE_EVENT0("midi", "MidiMessageFilter::HandleDataReceived"); |
247 DCHECK(main_message_loop_->BelongsToCurrentThread()); | 261 DCHECK(main_message_loop_->BelongsToCurrentThread()); |
248 DCHECK(!data.empty()); | 262 DCHECK(!data.empty()); |
249 | 263 |
250 for (blink::WebMIDIAccessorClient* client : clients_) | 264 for (blink::WebMIDIAccessorClient* client : clients_) |
251 client->didReceiveMIDIData(port, &data[0], data.size(), timestamp); | 265 client->didReceiveMIDIData(port, &data[0], data.size(), timestamp); |
252 } | 266 } |
253 | 267 |
254 } // namespace content | 268 } // namespace content |
OLD | NEW |