Block internal PlatformEvents before they are dispatched in touchview.

ui/events/platform/platform_event_source_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/platform/platform_event_source.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
+#include "ui/events/platform/platform_event_filter.h"
 #include "ui/events/platform/platform_event_observer.h"
 #include "ui/events/platform/scoped_event_dispatcher.h"
 
 namespace ui {
 
 namespace {
 
 scoped_ptr<PlatformEvent> CreatePlatformEvent() {
   scoped_ptr<PlatformEvent> event(new PlatformEvent());
   memset(event.get(), 0, sizeof(PlatformEvent));
@@ skipping 105 matching lines @@
 
   virtual void DidProcessEvent(const PlatformEvent& event) OVERRIDE {}
 
  private:
   int id_;
   std::vector<int>* list_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformEventObserver);
 };
 
+class TestPlatformEventFilter : public PlatformEventFilter {
+ public:
+  TestPlatformEventFilter() {
+    PlatformEventSource::GetInstance()->AddPlatformEventFilter(this);
+  }
+
+  virtual ~TestPlatformEventFilter() {
+    PlatformEventSource::GetInstance()->RemovePlatformEventFilter(this);
+  }
+
+  virtual bool ShouldDispatchEvent(const PlatformEvent& event) OVERRIDE {
+    return false;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestPlatformEventFilter);
+};
+
 class PlatformEventTest : public testing::Test {
  public:
   PlatformEventTest() {}
   virtual ~PlatformEventTest() {}
 
   TestPlatformEventSource* source() { return source_.get(); }
 
  protected:
   // testing::Test:
   virtual void SetUp() OVERRIDE {
@@ skipping 78 matching lines @@
     ASSERT_EQ(1u, list_observer.size());
     EXPECT_EQ(31, list_observer[0]);
   }
 
   list_observer.clear();
   event = CreatePlatformEvent();
   source()->Dispatch(*event);
   EXPECT_EQ(0u, list_observer.size());
 }
 
+// Tests that filtered events are not observed or dispatched.
+TEST_F(PlatformEventTest, FilterBasic) {
+  std::vector<int> list;
+  scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
+  TestPlatformEventDispatcher dispatcher(1, &list);
+  TestPlatformEventObserver observer(2, &list);
+  source()->Dispatch(*event);
+  EXPECT_EQ(2u, list.size());
+  list.clear();
+  {
+    TestPlatformEventFilter filter;
+    scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
+    source()->Dispatch(*event);
+    ASSERT_EQ(0u, list.size());
+    list.clear();
+  }
+
+  list.clear();
+  event = CreatePlatformEvent();
+  source()->Dispatch(*event);
+  EXPECT_EQ(2u, list.size());
+}
+
 // Tests that observers receive events in the correct order.
 TEST_F(PlatformEventTest, ObserverOrder) {
   std::vector<int> list_observer;
   const int sequence[] = {21, 3, 6, 45};
   ScopedVector<TestPlatformEventObserver> observers;
   for (size_t i = 0; i < arraysize(sequence); ++i) {
     observers.push_back(
         new TestPlatformEventObserver(sequence[i], &list_observer));
   }
   scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
@@ skipping 531 matching lines @@
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(10, list[1]);
   }
 };
 
 RUN_TEST_IN_MESSAGE_LOOP(
     ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration)
 
 }  // namespace ui