| // Copyright 2013 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/browser/renderer_host/input/input_queue.h" |
| |
| #include "base/bind.h" |
| #include "base/debug/trace_event.h" |
| #include "content/browser/renderer_host/input/browser_input_event.h" |
| #include "content/browser/renderer_host/input/input_queue_client.h" |
| #include "content/common/input/event_packet.h" |
| #include "content/common/input/input_event.h" |
| |
| namespace content { |
| |
| // A specialized EventPacket with utility methods for dispatched event handling. |
| class InputQueue::BrowserEventPacket : public EventPacket { |
| public: |
| typedef ScopedVector<BrowserInputEvent> BrowserInputEvents; |
| |
| BrowserEventPacket() : weak_factory_(this) {} |
| virtual ~BrowserEventPacket() {} |
| |
| // Validate the response and signal dispatch to the processed events. |
| // Undelivered events will be re-enqueued, and any generated followup events |
| // will be inserted at the same relative order as their generating event. |
| AckResult ValidateAndDispatchAck(int64 packet_id, |
| const InputEventDispositions& dispositions) { |
| if (!Validate(packet_id, dispositions)) |
| return ACK_INVALID; |
| |
| // Empty the packet; events will be re-enqueued as necessary. |
| InputEvents dispatched_events; |
| events_.swap(dispatched_events); |
| |
| // The packet could be deleted as a result of event dispatch; use a local |
| // weak ref to ensure proper shutdown. |
| base::WeakPtr<EventPacket> weak_ref_this = weak_factory_.GetWeakPtr(); |
| |
| BrowserInputEvents followup_events; |
| for (size_t i = 0; i < dispatched_events.size(); ++i) { |
| // Take ownership of the event. |
| scoped_ptr<BrowserInputEvent> event( |
| static_cast<BrowserInputEvent*>(dispatched_events[i])); |
| dispatched_events[i] = NULL; |
| |
| // Re-enqueue undelivered events. |
| InputEventDisposition disposition = dispositions[i]; |
| if (disposition == INPUT_EVENT_COULD_NOT_DELIVER) { |
| Add(event.PassAs<InputEvent>()); |
| continue; |
| } |
| |
| event->OnDispatched(disposition, &followup_events); |
| |
| // TODO(jdduke): http://crbug.com/274029 |
| if (!weak_ref_this.get()) |
| return ACK_SHUTDOWN; |
| |
| AddAll(&followup_events); |
| } |
| return ACK_OK; |
| } |
| |
| protected: |
| // Add and take ownership of events in |followup_events|. |
| void AddAll(BrowserInputEvents* followup_events) { |
| for (BrowserInputEvents::iterator iter = followup_events->begin(); |
| iter != followup_events->end(); |
| ++iter) { |
| Add(scoped_ptr<InputEvent>(*iter)); |
| } |
| followup_events->weak_clear(); |
| } |
| |
| // Perform a sanity check of the ack against the current packet. |
| // |packet_id| should match that of this packet, and |dispositions| should |
| // be of size equal to the number of events in this packet. |
| bool Validate(int64 packet_id, |
| const InputEventDispositions& dispositions) const { |
| if (packet_id != id()) |
| return false; |
| |
| if (dispositions.size() != size()) |
| return false; |
| |
| return true; |
| } |
| |
| private: |
| base::WeakPtrFactory<EventPacket> weak_factory_; |
| }; |
| |
| InputQueue::InputQueue(InputQueueClient* client) |
| : client_(client), |
| next_packet_id_(1), |
| flush_requested_(false), |
| in_flush_packet_(new BrowserEventPacket()), |
| pending_flush_packet_(new BrowserEventPacket()) { |
| DCHECK(client_); |
| } |
| |
| InputQueue::~InputQueue() {} |
| |
| void InputQueue::QueueEvent(scoped_ptr<BrowserInputEvent> event) { |
| DCHECK(event); |
| DCHECK(event->valid()); |
| pending_flush_packet_->Add(event.PassAs<InputEvent>()); |
| RequestFlushIfNecessary(); |
| } |
| |
| void InputQueue::BeginFlush() { |
| // Ignore repeated flush attempts. |
| if (!flush_requested_) |
| return; |
| |
| DCHECK(!FlushInProgress()); |
| DCHECK(!pending_flush_packet_->empty()); |
| |
| flush_requested_ = false; |
| in_flush_packet_.swap(pending_flush_packet_); |
| DeliverInFlushPacket(); |
| } |
| |
| InputQueue::AckResult InputQueue::OnEventPacketAck( |
| int64 packet_id, |
| const InputEventDispositions& dispositions) { |
| if (!FlushInProgress()) |
| return ACK_UNEXPECTED; |
| |
| TRACE_EVENT_ASYNC_STEP1("input", "InputQueueFlush", this, "AckPacket", |
| "id", packet_id); |
| |
| AckResult ack_result = |
| in_flush_packet_->ValidateAndDispatchAck(packet_id, dispositions); |
| |
| if (ack_result != ACK_OK) |
| return ack_result; |
| |
| if (FlushInProgress()) { |
| DeliverInFlushPacket(); |
| } else { |
| TRACE_EVENT_ASYNC_END0("input", "InputQueueFlush", this); |
| client_->DidFinishFlush(); |
| RequestFlushIfNecessary(); |
| } |
| |
| return ACK_OK; |
| } |
| |
| size_t InputQueue::QueuedEventCount() const { |
| return in_flush_packet_->size() + pending_flush_packet_->size(); |
| } |
| |
| void InputQueue::DeliverInFlushPacket() { |
| DCHECK(FlushInProgress()); |
| TRACE_EVENT_ASYNC_STEP1("input", "InputQueueFlush", this, "DeliverPacket", |
| "id", next_packet_id_); |
| in_flush_packet_->set_id(next_packet_id_++); |
| client_->Deliver(*in_flush_packet_); |
| } |
| |
| void InputQueue::RequestFlushIfNecessary() { |
| if (flush_requested_) |
| return; |
| |
| // Defer flush requests until the current flush has finished. |
| if (FlushInProgress()) |
| return; |
| |
| // No additional events to flush. |
| if (pending_flush_packet_->empty()) |
| return; |
| |
| TRACE_EVENT_ASYNC_BEGIN0("input", "InputQueueFlush", this); |
| TRACE_EVENT_ASYNC_STEP0("input", "InputQueueFlush", this, "Request"); |
| flush_requested_ = true; |
| client_->SetNeedsFlush(); |
| } |
| |
| bool InputQueue::FlushInProgress() const { return !in_flush_packet_->empty(); } |
| |
| } // namespace content |