events: Introduce EventRewriter.

ui/events/event_source.cc

 // 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 "ui/events/event_source.h"
 
+#include <algorithm>
+
 #include "ui/events/event_processor.h"
+#include "ui/events/event_rewriter.h"
 
 namespace ui {
 
+void EventSource::AddEventRewriter(EventRewriter* rewriter) {
+  DCHECK(rewriter);
+  rewriter_list_.push_back(rewriter);
+}
+
+void EventSource::RemoveEventRewriter(EventRewriter* rewriter) {
+  EventRewriterList::iterator find =
+      std::find(rewriter_list_.begin(), rewriter_list_.end(), rewriter);
+  if (find != rewriter_list_.end())
+    rewriter_list_.erase(find);
+}
+
 EventDispatchDetails EventSource::SendEventToProcessor(Event* event) {
+  Event* rewritten_event = 0;

[sadrul, 2014/03/24 21:15:38]

We should use a scoped_ptr<> to avoid accidentally leaking a rewritten event
(e.g. I think we leak it if we return from line 38-39 in this patch).

+  EventRewriteStatus status = EVENT_REWRITE_CONTINUE;
+  for (EventRewriterList::const_iterator it = rewriter_list_.begin(),
+                                         end = rewriter_list_.end();
+       (it != end) && (status == EVENT_REWRITE_CONTINUE);
+       ++it) {
+    DCHECK(*it);
+    status = (*it)->RewriteEvent(*event, &rewritten_event);
+    while (status == EVENT_REWRITE_DISPATCH_ANOTHER) {

[sadrul, 2014/03/24 21:15:38]

Can we do this more like:

for (....) {
  status = (*it)->RewriteEvent(*event, &rewritten_event);
  if (status == DISCARD) {
    CHECK(!rewritten_event);
    return EventDispatchDetails();
  }

  if (status == CONTINUE) {
    CHECK(!rewritten_event);
    continue;
  }

  break;
}

CHECK((it == end() && !rewritten_event) || rewritten_event);
details = DeliverEventToProcessor(rewritten_event ? rewritten_event : event);
if (details.dispatcher_destroyed)
  return details;
while (status == ANOTHER) {
  status = *ite->NextDispatchEvent(....);
  if (status == DISCARD)
    return ...;
  CHECK_EQ(ANOTHER, status);
  .... deliver ...
}

+      DCHECK(rewritten_event);
+      EventDispatchDetails details = DeliverEventToProcessor(rewritten_event);
+      if (details.dispatcher_destroyed || details.target_destroyed)
+        return details;
+      Event* last_event = rewritten_event;
+      status = (*it)->NextDispatchEvent(*last_event, &rewritten_event);
+      delete last_event;
+    }
+  }
+  if (status == EVENT_REWRITE_REWRITTEN) {
+    DCHECK(rewritten_event);
+    EventDispatchDetails details = DeliverEventToProcessor(rewritten_event);
+    delete rewritten_event;
+    return details;
+  }
+  DCHECK(!rewritten_event);
+  if (status == EVENT_REWRITE_CONTINUE) {
+    return DeliverEventToProcessor(event);
+  }
+  return EventDispatchDetails();
+}
+
+EventDispatchDetails EventSource::DeliverEventToProcessor(Event* event) {
   EventProcessor* processor = GetEventProcessor();
   CHECK(processor);
   return processor->OnEventFromSource(event);
 }
 
 }  // namespace ui