// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/fast_ink/laser/laser_pointer_controller.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/constants/ash_switches.h"
#include "ash/fast_ink/laser/laser_pointer_controller_test_api.h"
#include "ash/fast_ink/laser/laser_pointer_view.h"
#include "ash/public/cpp/stylus_utils.h"
#include "ash/shell.h"
#include "ash/test/ash_test_base.h"
#include "base/command_line.h"
#include "ui/events/test/event_generator.h"
namespace ash {
namespace {
class TestLaserPointerObserver : public LaserPointerObserver {
public:
TestLaserPointerObserver() = default;
~TestLaserPointerObserver() override = default;
// LaserPointerObserver:
void OnLaserPointerStateChanged(bool enabled) override {
laser_pointer_enabled_ = enabled;
}
bool laser_pointer_enabled() { return laser_pointer_enabled_; }
private:
bool laser_pointer_enabled_ = false;
};
class LaserPointerControllerTest : public AshTestBase {
public:
LaserPointerControllerTest() = default;
LaserPointerControllerTest(const LaserPointerControllerTest&) = delete;
LaserPointerControllerTest& operator=(const LaserPointerControllerTest&) =
delete;
~LaserPointerControllerTest() override = default;
void SetUp() override {
AshTestBase::SetUp();
observer_ = std::make_unique<TestLaserPointerObserver>();
controller_ = std::make_unique<LaserPointerController>();
controller_test_api_ =
std::make_unique<LaserPointerControllerTestApi>(controller_.get());
}
void TearDown() override {
controller_test_api_.reset();
// This needs to be called first to remove the event handler before the
// shell instance gets torn down.
controller_.reset();
AshTestBase::TearDown();
}
protected:
void VerifyLaserPointerRendererTouchEvent() {
ui::test::EventGenerator* event_generator = GetEventGenerator();
// When disabled the laser pointer should not be showing.
event_generator->MoveTouch(gfx::Point(1, 1));
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
// Verify that by enabling the mode, the laser pointer should still not be
// showing.
controller_test_api_->SetEnabled(true);
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
// Verify moving the finger 4 times will not display the laser pointer.
event_generator->MoveTouch(gfx::Point(2, 2));
event_generator->MoveTouch(gfx::Point(3, 3));
event_generator->MoveTouch(gfx::Point(4, 4));
event_generator->MoveTouch(gfx::Point(5, 5));
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
// Verify pressing the finger will show the laser pointer and add a point
// but will not activate fading out.
event_generator->PressTouch();
EXPECT_TRUE(controller_test_api_->IsShowingLaserPointer());
EXPECT_FALSE(controller_test_api_->IsFadingAway());
EXPECT_EQ(1, controller_test_api_->laser_points().GetNumberOfPoints());
// Verify dragging the finger 2 times will add 2 more points.
event_generator->MoveTouch(gfx::Point(6, 6));
event_generator->MoveTouch(gfx::Point(7, 7));
EXPECT_EQ(3, controller_test_api_->laser_points().GetNumberOfPoints());
// Verify releasing the finger still shows the laser pointer, which is
// fading away.
event_generator->ReleaseTouch();
EXPECT_TRUE(controller_test_api_->IsShowingLaserPointer());
EXPECT_TRUE(controller_test_api_->IsFadingAway());
// Verify that disabling the mode does not display the laser pointer.
controller_test_api_->SetEnabled(false);
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
EXPECT_FALSE(controller_test_api_->IsFadingAway());
// Verify that disabling the mode while laser pointer is displayed does not
// display the laser pointer.
controller_test_api_->SetEnabled(true);
event_generator->PressTouch();
event_generator->MoveTouch(gfx::Point(6, 6));
EXPECT_TRUE(controller_test_api_->IsShowingLaserPointer());
controller_test_api_->SetEnabled(false);
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
// Verify that the laser pointer does not add points while disabled.
event_generator->PressTouch();
event_generator->MoveTouch(gfx::Point(8, 8));
event_generator->ReleaseTouch();
event_generator->MoveTouch(gfx::Point(9, 9));
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
}
void VerifyLaserPointerRendererMouseEvent() {
ui::test::EventGenerator* event_generator = GetEventGenerator();
// When disabled the laser pointer should not be showing.
event_generator->MoveMouseTo(gfx::Point(1, 1));
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
// Verify that by enabling the mode, the laser pointer should still not be
// showing.
controller_test_api_->SetEnabled(true);
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
// Verify moving the cursor 4 times will display the laser pointer.
event_generator->MoveMouseTo(gfx::Point(2, 2));
event_generator->MoveMouseTo(gfx::Point(3, 3));
event_generator->MoveMouseTo(gfx::Point(4, 4));
event_generator->MoveMouseTo(gfx::Point(5, 5));
EXPECT_TRUE(controller_test_api_->IsShowingLaserPointer());
EXPECT_FALSE(controller_test_api_->IsFadingAway());
EXPECT_EQ(4, controller_test_api_->laser_points().GetNumberOfPoints());
// Verify moving the cursor 2 times will add 2 more points.
event_generator->MoveMouseTo(gfx::Point(6, 6));
event_generator->MoveMouseTo(gfx::Point(7, 7));
EXPECT_EQ(6, controller_test_api_->laser_points().GetNumberOfPoints());
// Verify that disabling the mode does not display the laser pointer.
controller_test_api_->SetEnabled(false);
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
EXPECT_FALSE(controller_test_api_->IsFadingAway());
// Verify that disabling the mode while laser pointer is displayed does not
// display the laser pointer.
controller_test_api_->SetEnabled(true);
event_generator->MoveMouseTo(gfx::Point(6, 6));
EXPECT_TRUE(controller_test_api_->IsShowingLaserPointer());
controller_test_api_->SetEnabled(false);
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
// Verify that the laser pointer does not add points while disabled.
event_generator->MoveMouseTo(gfx::Point(8, 8));
event_generator->MoveMouseTo(gfx::Point(9, 9));
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
}
TestLaserPointerObserver* observer() { return observer_.get(); }
std::unique_ptr<LaserPointerController> controller_;
std::unique_ptr<LaserPointerControllerTestApi> controller_test_api_;
std::unique_ptr<TestLaserPointerObserver> observer_;
};
} // namespace
// Test to ensure the class responsible for drawing the laser pointer receives
// points from stylus movements as expected.
TEST_F(LaserPointerControllerTest, LaserPointerRenderer) {
stylus_utils::SetHasStylusInputForTesting();
ui::test::EventGenerator* event_generator = GetEventGenerator();
event_generator->EnterPenPointerMode();
VerifyLaserPointerRendererTouchEvent();
// Verify that the laser pointer does not get shown if points are not coming
// from the stylus, even when enabled.
event_generator->ExitPenPointerMode();
controller_test_api_->SetEnabled(true);
event_generator->PressTouch();
event_generator->MoveTouch(gfx::Point(10, 10));
event_generator->MoveTouch(gfx::Point(11, 11));
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
event_generator->ReleaseTouch();
// Make sure that event can be sent after the pointer widget is destroyed
// by release. This can happen if the pen event causes the deletion of
// the pointer event in an earlier event handler.
ui::PointerDetails pointer_details;
pointer_details.pointer_type = ui::EventPointerType::kPen;
ui::TouchEvent touch(ui::EventType::kTouchMoved, gfx::PointF(), gfx::PointF(),
base::TimeTicks(), pointer_details, 0);
ui::Event::DispatcherApi api(&touch);
api.set_target(Shell::GetPrimaryRootWindow());
static_cast<ui::EventHandler*>(controller_.get())->OnTouchEvent(&touch);
}
// Test to ensure the class responsible for drawing the laser pointer receives
// points from mouse movements as expected.
TEST_F(LaserPointerControllerTest, LaserPointerRendererTouchEvent) {
stylus_utils::SetNoStylusInputForTesting();
VerifyLaserPointerRendererTouchEvent();
// Make sure that event can be sent after the pointer widget is destroyed
// by release. This can happen if the touch event causes the deletion of
// the pointer event in an earlier event handler.
ui::PointerDetails pointer_details;
ui::TouchEvent touch(ui::EventType::kTouchMoved, gfx::PointF(), gfx::PointF(),
base::TimeTicks(), pointer_details, 0);
ui::Event::DispatcherApi api(&touch);
api.set_target(Shell::GetPrimaryRootWindow());
static_cast<ui::EventHandler*>(controller_.get())->OnTouchEvent(&touch);
}
// Test to ensure the class responsible for drawing the laser pointer receives
// points from mouse movements as expected when stylus input is not available.
TEST_F(LaserPointerControllerTest, LaserPointerRendererMouseEventNoStylus) {
stylus_utils::SetNoStylusInputForTesting();
VerifyLaserPointerRendererMouseEvent();
}
// Test to ensure the class responsible for drawing the laser pointer receives
// points from mouse movements as expected when stylus input is available but
// hasn't been seen before.
TEST_F(LaserPointerControllerTest, LaserPointerRendererMouseEventHasStylus) {
stylus_utils::SetHasStylusInputForTesting();
VerifyLaserPointerRendererMouseEvent();
// Verify that the laser pointer does not get shown if points are coming from
// mouse event if a stylus interaction has been seen.
ui::test::EventGenerator* event_generator = GetEventGenerator();
event_generator->EnterPenPointerMode();
event_generator->PressTouch();
event_generator->MoveMouseTo(gfx::Point(2, 2));
event_generator->MoveMouseTo(gfx::Point(3, 3));
event_generator->MoveMouseTo(gfx::Point(4, 4));
event_generator->MoveMouseTo(gfx::Point(5, 5));
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
}
// Test to ensure the class responsible for drawing the laser pointer handles
// prediction as expected when it receives points from stylus movements.
TEST_F(LaserPointerControllerTest, LaserPointerPrediction) {
controller_test_api_->SetEnabled(true);
// The laser pointer mode only works with stylus.
ui::test::EventGenerator* event_generator = GetEventGenerator();
event_generator->EnterPenPointerMode();
event_generator->PressTouch();
EXPECT_TRUE(controller_test_api_->IsShowingLaserPointer());
EXPECT_EQ(1, controller_test_api_->laser_points().GetNumberOfPoints());
// Initial press event shouldn't generate any predicted points as there's no
// history to use for prediction.
EXPECT_EQ(0,
controller_test_api_->predicted_laser_points().GetNumberOfPoints());
// Verify dragging the stylus 3 times will add some predicted points.
event_generator->MoveTouch(gfx::Point(10, 10));
event_generator->MoveTouch(gfx::Point(20, 20));
event_generator->MoveTouch(gfx::Point(30, 30));
EXPECT_NE(0,
controller_test_api_->predicted_laser_points().GetNumberOfPoints());
// Verify predicted points are in the right direction.
for (const auto& point :
controller_test_api_->predicted_laser_points().points()) {
EXPECT_LT(30, point.location.x());
EXPECT_LT(30, point.location.y());
}
// Verify releasing the stylus removes predicted points.
event_generator->ReleaseTouch();
EXPECT_TRUE(controller_test_api_->IsShowingLaserPointer());
EXPECT_TRUE(controller_test_api_->IsFadingAway());
EXPECT_EQ(0,
controller_test_api_->predicted_laser_points().GetNumberOfPoints());
}
TEST_F(LaserPointerControllerTest, NotifyLaserPointerStateChanged) {
controller_->AddObserver(observer());
controller_test_api_->SetEnabled(true);
EXPECT_TRUE(observer()->laser_pointer_enabled());
controller_test_api_->SetEnabled(false);
EXPECT_FALSE(observer()->laser_pointer_enabled());
controller_->RemoveObserver(observer());
}
// Test to ensure the class responsible for update cursor visibility state when
// it handles mouse and touch events.
TEST_F(LaserPointerControllerTest, MouseCursorState) {
ash::stylus_utils::SetNoStylusInputForTesting();
ui::test::EventGenerator* event_generator = GetEventGenerator();
auto* cursor_manager = Shell::Get()->cursor_manager();
// Verify that when disabled the cursor should be visible.
event_generator->MoveMouseTo(gfx::Point(1, 1));
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
EXPECT_TRUE(cursor_manager->IsCursorVisible());
// Verify that by enabling the mode, mouse cursor should be hidden.
controller_test_api_->SetEnabled(true);
event_generator->MoveMouseTo(gfx::Point(2, 2));
EXPECT_FALSE(cursor_manager->IsCursorVisible());
EXPECT_TRUE(cursor_manager->IsCursorLocked());
// Verify that after moving with touch, mouse cursor should be still hidden
// but unlocked.
event_generator->PressTouch();
event_generator->MoveTouch(gfx::Point(2, 2));
EXPECT_FALSE(cursor_manager->IsCursorVisible());
EXPECT_FALSE(cursor_manager->IsCursorLocked());
EXPECT_EQ(1, controller_test_api_->laser_points().GetNumberOfPoints());
// Verify that moving the mouse cursor shows the cursor.
event_generator->MoveMouseTo(gfx::Point(6, 6));
EXPECT_FALSE(cursor_manager->IsCursorVisible());
EXPECT_TRUE(cursor_manager->IsCursorLocked());
EXPECT_EQ(2, controller_test_api_->laser_points().GetNumberOfPoints());
// Verify that by disabling the mode, mouse cursor should be visible.
controller_test_api_->SetEnabled(false);
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer());
event_generator->MoveMouseTo(gfx::Point(7, 7));
EXPECT_TRUE(cursor_manager->IsCursorVisible());
EXPECT_FALSE(cursor_manager->IsCursorLocked());
}
// Base class for tests that rely on palette.
class LaserPointerControllerTestWithPalette
: public LaserPointerControllerTest {
public:
LaserPointerControllerTestWithPalette() {
base::CommandLine::ForCurrentProcess()->AppendSwitch(
switches::kAshEnablePaletteOnAllDisplays);
stylus_utils::SetHasStylusInputForTesting();
}
LaserPointerControllerTestWithPalette(
const LaserPointerControllerTestWithPalette&) = delete;
LaserPointerControllerTestWithPalette& operator=(
const LaserPointerControllerTestWithPalette&) = delete;
~LaserPointerControllerTestWithPalette() override = default;
};
// Verify that clicking a palette with the laser pointer does not
// cause the laser to show.
TEST_F(LaserPointerControllerTestWithPalette, LaserPointerPaletteDisable) {
// Make the two displays different size to catch root coordinates
// being used as screen coordinates.
UpdateDisplay("800x600,1024x768");
std::vector<display::Display> testcases{
GetPrimaryDisplay(),
GetSecondaryDisplay(),
};
for (std::size_t i = 0; i < testcases.size(); i++) {
display::Display display = testcases[i];
PaletteTray* palette =
controller_test_api_->GetPaletteTrayOnDisplay(display.id());
ASSERT_TRUE(palette) << "While processing testcase " << i;
// The laser pointer mode only works with stylus.
ui::test::EventGenerator* event_generator = GetEventGenerator();
event_generator->EnterPenPointerMode();
// Palette does not appear until a stylus is seen for the first time.
event_generator->PressMoveAndReleaseTouchTo(display.bounds().CenterPoint());
gfx::Point center = palette->GetBoundsInScreen().CenterPoint();
// Tap the laser pointer both on and off of the palette.
controller_test_api_->SetEnabled(true);
event_generator->PressTouch(center);
EXPECT_FALSE(controller_test_api_->IsShowingLaserPointer())
<< "While processing testcase " << i;
event_generator->ReleaseTouch();
event_generator->PressTouch(display.bounds().CenterPoint());
EXPECT_TRUE(controller_test_api_->IsShowingLaserPointer())
<< "While processing testcase " << i;
event_generator->ReleaseTouch();
}
}
} // namespace ash
Codebase Browser
chromium