Added wrapper test class for 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/gestures/gesture_provider_aura.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, touch, gesture, and key events.
 class EventCapturer : public ui::EventHandler {
  public:
   EventCapturer() {}
   virtual ~EventCapturer() {}
 
   void Reset() {
     events_.clear();
   }
 
@@ skipping 31 matching lines @@
 int Factorial(int n) {
   if (n <= 0)
     return 0;
   if (n == 1)
     return 1;
   return n * Factorial(n - 1);
 }
 
 }  // namespace
 
+class TouchExplorationControllerTestApi {
+ public:
+  TouchExplorationControllerTestApi(
+      TouchExplorationController* touch_exploration_controller)
+      : touch_exploration_controller_(touch_exploration_controller) {}
+
+  void CallTapTimerNowForTesting() {
+    DCHECK(touch_exploration_controller_->tap_timer_.IsRunning());
+    touch_exploration_controller_->tap_timer_.Stop();
+    touch_exploration_controller_->OnTapTimerFired();
+  }
+
+  void CallTapTimerNowIfRunningForTesting() {
+    if (touch_exploration_controller_->tap_timer_.IsRunning()) {
+      touch_exploration_controller_->tap_timer_.Stop();
+      touch_exploration_controller_->OnTapTimerFired();
+    }
+  }
+
+  void SetEventHandlerForTesting(
+      ui::EventHandler* event_handler_for_testing) {
+    touch_exploration_controller_->event_handler_for_testing_ =
+        event_handler_for_testing;
+  }
+
+  bool IsInNoFingersDownStateForTesting() const {
+    return touch_exploration_controller_->state_ ==
+           touch_exploration_controller_->NO_FINGERS_DOWN;
+  }
+
+  bool IsInGestureInProgressStateForTesting() const {
+    return touch_exploration_controller_->state_ ==
+           touch_exploration_controller_->GESTURE_IN_PROGRESS;
+  }
+
+  // VLOGs should be suppressed in tests that generate a lot of logs,
+  // for example permutations of nine touch events.
+  void SuppressVLOGsForTesting(bool suppress) {
+    touch_exploration_controller_->VLOG_on_ = !suppress;
+  }
+
+ private:
+  TouchExplorationController* touch_exploration_controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(TouchExplorationControllerTestApi);
+};
+
 class TouchExplorationTest : public aura::test::AuraTestBase {
  public:
   TouchExplorationTest() : simulated_clock_(new base::SimpleTestTickClock()) {
     // Tests fail if time is ever 0.
     simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
   }
   virtual ~TouchExplorationTest() {}
 
   virtual void SetUp() OVERRIDE {
     if (gfx::GetGLImplementation() == gfx::kGLImplementationNone)
@@ skipping 70 matching lines @@
   }
 
   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_.reset(new TouchExplorationControllerTestApi(
+          new ui::TouchExplorationController(root_window())));

[gab, 2014/07/17 17:46:09]

The ui::TouchExplorationController passed into the
TouchExplorationControllerTestApi is not owned by that class and thus leaks.

[evy, 2014/07/17 21:06:46]

Thank you for pointing to the problematic line of code!

@Dominic, Alice: 
I changed the code so the TestApi class stores the TouchExplorationController in
a scoped pointer, which I think fixes the problem.
Can you let me know if that's indeed the fix I needed, and also how to test for
indirect leaks? Alice sent me a thing before about the address sanitizer, but it
doesn't catch anything in this code.
Thanks :)

[gab, 2014/07/17 21:17:42]

NP :)
First you'll want to trigger the ASAN try bots on this CL (via the "Try more
bots" button).

       touch_exploration_controller_->SetEventHandlerForTesting(
           &event_capturer_);
       cursor_client()->ShowCursor();
       cursor_client()->DisableMouseEvents();
     }
   }
 
   void EnterTouchExplorationModeAtLocation(gfx::Point tap_location) {
     ui::TouchEvent touch_press(ui::ET_TOUCH_PRESSED, tap_location, 0, Now());
     generator_->Dispatch(&touch_press);
@@ skipping 36 matching lines @@
         simulated_clock_->NowTicks().ToInternalValue());
   }
 
   scoped_ptr<aura::test::EventGenerator> generator_;
   ui::GestureDetector::Config gesture_detector_config_;
   // Owned by |generator_|.
   base::SimpleTestTickClock* simulated_clock_;
 
  private:
   EventCapturer event_capturer_;
-  scoped_ptr<ui::TouchExplorationController> touch_exploration_controller_;
+  scoped_ptr<TouchExplorationControllerTestApi>
+      touch_exploration_controller_;
   scoped_ptr<aura::test::TestCursorClient> cursor_client_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationTest);
 };
 
 // Executes a number of assertions to confirm that |e1| and |e2| are touch
 // events and are equal to each other.
 void ConfirmEventsAreTouchAndEqual(ui::Event* e1, ui::Event* e2) {
   ASSERT_TRUE(e1->IsTouchEvent());
   ASSERT_TRUE(e2->IsTouchEvent());
@@ skipping 1097 matching lines @@
   // The rest of the events should occur in passthrough.
   generator_->ReleaseTouchId(0);
   ASSERT_EQ(1U, captured_events.size());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, captured_events[0]->type());
   ClearCapturedEvents();
   generator_->ReleaseTouchId(1);
   ASSERT_EQ(0U, captured_events.size());
 }
 
 }  // namespace ui