Revert of Added touch event permutations test to touch_exploration_controller.

ui/chromeos/touch_exploration_controller_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/chromeos/touch_exploration_controller.h"
 
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
-#include "ui/events/test/events_test_utils.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 namespace ui {
 
 namespace {
 // Records all mouse and touch events.
 class EventCapturer : public ui::EventHandler {
  public:
@@ skipping 24 matching lines @@
   const ScopedVector<ui::LocatedEvent>& captured_events() const {
     return events_;
   }
 
  private:
   ScopedVector<ui::LocatedEvent> events_;
 
   DISALLOW_COPY_AND_ASSIGN(EventCapturer);
 };
 
-int Factorial(int n) {
-  if (n <= 0)
-    return 0;
-  if (n == 1)
-    return 1;
-  return n * Factorial(n - 1);
-}
-
 }  // namespace
 
 class TouchExplorationTest : public aura::test::AuraTestBase {
  public:
   TouchExplorationTest()
       : simulated_clock_(new base::SimpleTestTickClock()) {}
   virtual ~TouchExplorationTest() {}
 
   virtual void SetUp() OVERRIDE {
     if (gfx::GetGLImplementation() == gfx::kGLImplementationNone)
@@ skipping 34 matching lines @@
 
   void ClearCapturedEvents() {
     event_capturer_.Reset();
   }
 
   void AdvanceSimulatedTimePastTapDelay() {
     simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
     touch_exploration_controller_->CallTapTimerNowForTesting();
   }
 
-  void AdvanceSimulatedTimePastPotentialTapDelay() {
-    simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
-    touch_exploration_controller_->CallTapTimerNowIfRunningForTesting();
-  }
-
-  void SuppressVLOGs(bool suppress) {
-    touch_exploration_controller_->SuppressVLOGsForTesting(suppress);
-  }
-
   void SwitchTouchExplorationMode(bool on) {
     if (!on && touch_exploration_controller_.get()) {
       touch_exploration_controller_.reset();
     } else if (on && !touch_exploration_controller_.get()) {
       touch_exploration_controller_.reset(
           new ui::TouchExplorationController(root_window()));
       touch_exploration_controller_->SetEventHandlerForTesting(
           &event_capturer_);
       cursor_client()->ShowCursor();
       cursor_client()->DisableMouseEvents();
@@ skipping 710 matching lines @@
 // in TwoToOneFinger.
 TEST_F(TouchExplorationTest, TwoToOneFingerRelaseFirst) {
   gfx::Point first_touch_location = gfx::Point(11,12);
   gfx::Point second_touch_location = gfx::Point(21, 22);
   EnterTwoToOne(first_touch_location, second_touch_location);
   const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
   ASSERT_EQ(captured_events.size(), 1u);
   ClearCapturedEvents();
 
   // Actions before release have already been tested in the previous test.
+
   // A release of the first finger should send an event, as the state
   // changes to the wait state.
   ui::TouchEvent first_touch_release(
       ui::ET_TOUCH_RELEASED, first_touch_location, 0, Now());
   generator_->Dispatch(&first_touch_release);
   ASSERT_EQ(captured_events.size(), 1u);
   ClearCapturedEvents();
 
   // No events should be sent after the second finger is lifted.
 
@@ skipping 86 matching lines @@
   EXPECT_EQ(first_touch_location, captured_events[0]->location());
   ClearCapturedEvents();
 
   ui::TouchEvent first_touch_release(
       ui::ET_TOUCH_RELEASED, first_touch_location, 0, Now());
   generator_->Dispatch(&first_touch_release);
   ASSERT_EQ(captured_events.size(), 1u);
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
-TEST_F(TouchExplorationTest, AllFingerPermutations) {
-  SwitchTouchExplorationMode(true);
-  SuppressVLOGs(true);
-  // We will test all permutations of events from three different fingers
-  // to ensure that we return to NO_FINGERS_DOWN when fingers have been
-  // released.
-  ScopedVector<ui::TouchEvent> all_events;
-  for (int touch_id = 0; touch_id < 3; touch_id++){
-    int x = 10*touch_id + 1;
-    int y = 10*touch_id + 2;
-    all_events.push_back(new TouchEvent(
-        ui::ET_TOUCH_PRESSED, gfx::Point(x++, y++), touch_id, Now()));
-    all_events.push_back(new TouchEvent(
-        ui::ET_TOUCH_MOVED, gfx::Point(x++, y++), touch_id, Now()));
-    all_events.push_back(new TouchEvent(
-        ui::ET_TOUCH_RELEASED, gfx::Point(x, y), touch_id, Now()));
-  }
-
-  // I'm going to explain this algorithm, and use an example in parentheses.
-  // The example will be all permutations of a b c d.
-  // There are four letters and 4! = 24 permutations.
-  const int num_events = all_events.size();
-  const int num_permutations = Factorial(num_events);
-
-  for (int p = 0; p < num_permutations; p++) {
-    std::vector<ui::TouchEvent*> queued_events = all_events.get();
-    std::vector<bool> fingers_pressed(3, false);
-
-    int current_num_permutations = num_permutations;
-    for (int events_left = num_events; events_left > 0; events_left--) {
-      // |p| indexes to each permutation when there are num_permutations
-      // permutations. (e.g. 0 is abcd, 1 is abdc, 2 is acbd, 3 is acdb...)
-      // But how do we find the index for the current number of permutations?
-      // To find the permutation within the part of the sequence we're
-      // currently looking at, we need a number between 0 and
-      // |current_num_permutations| - 1.
-      // (e.g. if we already chose the first letter, there are 3! = 6
-      // options left, so we do p % 6. So |current_permutation| would go
-      // from 0 to 5 and then reset to 0 again, for all combinations of
-      // whichever three letters are remaining, as we loop through the
-      // permutations)
-      int current_permutation = p % current_num_permutations;
-
-      // Since this is is the total number of permutations starting with
-      // this event and including future events, there could be multiple
-      // values of current_permutation that will generate the same event
-      // in this iteration.
-      // (e.g. If we chose 'a' but have b c d to choose from, we choose b when
-      // |current_permutation| = 0, 1 and c when |current_permutation| = 2, 3.
-      // Note that each letter gets two numbers, which is the next
-      // current_num_permutations, 2! for the two letters left.)
-
-      // Branching out from the first event, there are num_permutations
-      // permutations, and each value of |p| is associated with one of these
-      // permutations. However, once the first event is chosen, there
-      // are now |num_events| - 1 events left, so the number of permutations
-      // for the rest of the events changes, and will always be equal to
-      // the factorial of the events_left.
-      // (e.g. There are 3! = 6 permutations that start with 'a', so if we
-      // start with 'a' there will be 6 ways to then choose from b c d.)
-      // So we now set-up for the next iteration by setting
-      // current_num_permutations to the factorial of the next number of
-      // events left.
-      current_num_permutations /= events_left;
-
-      // To figure out what current event we want to choose, we integer
-      // divide the current permutation by the next current_num_permutations.
-      // (e.g. If there are 4 letters a b c d and 24 permutations, we divide
-      // by 24/4 = 6. Values 0 to 5 when divided by 6 equals 0, so the first
-      // 6 permutations start with 'a', and the last 6 will start with 'd'.
-      // Note that there are 6 that start with 'a' because there are 6
-      // permutations for the next three letters that follow 'a'.)
-      int index = current_permutation / current_num_permutations;
-
-      ui::TouchEvent* next_dispatch = queued_events[index];
-      ASSERT_TRUE(next_dispatch != NULL);
-
-      // |next_dispatch| has to be put in this container so that its time
-      // stamp can be changed to this point in the test, when it is being
-      // dispatched..
-      EventTestApi test_dispatch(next_dispatch);
-      test_dispatch.set_time_stamp(Now());
-      generator_->Dispatch(next_dispatch);
-      queued_events.erase(queued_events.begin() + index);
-
-      // Keep track of what fingers have been pressed, to release
-      // only those fingers at the end, so the check for being in
-      // no fingers down can be accurate.
-      if (next_dispatch->type() == ET_TOUCH_PRESSED) {
-        fingers_pressed[next_dispatch->touch_id()] = true;
-      } else if (next_dispatch->type() == ET_TOUCH_RELEASED) {
-        fingers_pressed[next_dispatch->touch_id()] = false;
-      }
-    }
-    ASSERT_EQ(queued_events.size(), 0u);
-
-    // Release fingers recorded as pressed.
-    for(int j = 0; j < int(fingers_pressed.size()); j++){
-      if (fingers_pressed[j] == true) {
-        generator_->ReleaseTouchId(j);
-        fingers_pressed[j] = false;
-      }
-    }
-    AdvanceSimulatedTimePastPotentialTapDelay();
-    EXPECT_TRUE(IsInNoFingersDownState());
-    ClearCapturedEvents();
-  }
-}
-
 }  // namespace ui