Convert chromeos::EventRewriter to a ui::EventRewriter

ui/events/event_rewriter_unittest.cc

 // Copyright 2014 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_rewriter.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 65 matching lines @@
 // same event type; it is used to test simple rewriting, and rewriter addition,
 // removal, and sequencing. Consequently EVENT_REWRITE_DISPATCH_ANOTHER is not
 // supported here (calls to NextDispatchEvent() would continue indefinitely).
 class TestConstantEventRewriter : public EventRewriter {
  public:
   TestConstantEventRewriter(EventRewriteStatus status, EventType type)
       : status_(status), type_(type) {
     CHECK_NE(EVENT_REWRITE_DISPATCH_ANOTHER, status);
   }
 
-  virtual EventRewriteStatus RewriteEvent(const Event& event,
+  virtual EventRewriteStatus RewriteEvent(Event* event,
                                           scoped_ptr<Event>* rewritten_event)
       OVERRIDE {
     if (status_ == EVENT_REWRITE_REWRITTEN)
       rewritten_event->reset(new TestEvent(type_));
     return status_;
   }
   virtual EventRewriteStatus NextDispatchEvent(const Event& last_event,
                                                scoped_ptr<Event>* new_event)
       OVERRIDE {
     NOTREACHED();
     return status_;
   }
 
  private:
   EventRewriteStatus status_;
   EventType type_;
 };
 
 // This EventRewriter runs a simple state machine; it is used to test
 // EVENT_REWRITE_DISPATCH_ANOTHER.
 class TestStateMachineEventRewriter : public EventRewriter {
  public:
   TestStateMachineEventRewriter() : last_rewritten_event_(0), state_(0) {}
   void AddRule(int from_state, EventType from_type,
                int to_state, EventType to_type, EventRewriteStatus to_status) {
     RewriteResult r = {to_state, to_type, to_status};
     rules_.insert(std::pair<RewriteCase, RewriteResult>(
         RewriteCase(from_state, from_type), r));
   }
-  virtual EventRewriteStatus RewriteEvent(const Event& event,
+  virtual EventRewriteStatus RewriteEvent(Event* event,
                                           scoped_ptr<Event>* rewritten_event)
+    OVERRIDE {
+      return Rewrite(*event, rewritten_event);
+    }
+  virtual EventRewriteStatus NextDispatchEvent(const Event& last_event,
+                                               scoped_ptr<Event>* new_event)
       OVERRIDE {
+    EXPECT_TRUE(last_rewritten_event_);
+    const TestEvent* arg_last = static_cast<const TestEvent*>(&last_event);
+    EXPECT_EQ(last_rewritten_event_->unique_id(), arg_last->unique_id());
+    const TestEvent* arg_new = static_cast<const TestEvent*>(new_event->get());
+    EXPECT_FALSE(arg_new && arg_last->unique_id() == arg_new->unique_id());
+    return Rewrite(last_event, new_event);
+  }
+
+ private:
+  EventRewriteStatus Rewrite(const Event& event,
+                             scoped_ptr<Event>* rewritten_event) {
     RewriteRules::iterator find =
         rules_.find(RewriteCase(state_, event.type()));
     if (find == rules_.end())
       return EVENT_REWRITE_CONTINUE;
     if ((find->second.status == EVENT_REWRITE_REWRITTEN) ||
         (find->second.status == EVENT_REWRITE_DISPATCH_ANOTHER)) {
       last_rewritten_event_ = new TestEvent(find->second.type);
       rewritten_event->reset(last_rewritten_event_);
     } else {
       last_rewritten_event_ = 0;
     }
     state_ = find->second.state;
     return find->second.status;
   }
-  virtual EventRewriteStatus NextDispatchEvent(const Event& last_event,
-                                               scoped_ptr<Event>* new_event)
-      OVERRIDE {
-    EXPECT_TRUE(last_rewritten_event_);
-    const TestEvent* arg_last = static_cast<const TestEvent*>(&last_event);
-    EXPECT_EQ(last_rewritten_event_->unique_id(), arg_last->unique_id());
-    const TestEvent* arg_new = static_cast<const TestEvent*>(new_event->get());
-    EXPECT_FALSE(arg_new && arg_last->unique_id() == arg_new->unique_id());
-    return RewriteEvent(last_event, new_event);
-  }
-
- private:
   typedef std::pair<int, EventType> RewriteCase;
   struct RewriteResult {
     int state;
     EventType type;
     EventRewriteStatus status;
   };
   typedef std::map<RewriteCase, RewriteResult> RewriteRules;
   RewriteRules rules_;
   TestEvent* last_rewritten_event_;
   int state_;
@@ skipping 67 matching lines @@
   s.RemoveEventRewriter(&r3);
 
   // Continue with the state-based rewriting.
   p.AddExpectedEvent(ET_MOUSE_RELEASED);
   p.AddExpectedEvent(ET_KEY_RELEASED);
   s.Send(ET_MOUSE_RELEASED);
   p.CheckAllReceived();
 }
 
 }  // namespace ui