power_manager/powerd/policy/input_device_controller_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2014 The Chromium OS 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 "power_manager/powerd/policy/input_device_controller.h"

 #include <cstdarg>

 #include <gtest/gtest.h>

 #include "power_manager/common/fake_prefs.h"
 #include "power_manager/common/power_constants.h"
 #include "power_manager/powerd/policy/backlight_controller_stub.h"
 #include "power_manager/powerd/system/acpi_wakeup_helper_stub.h"
 #include "power_manager/powerd/system/cros_ec_helper_stub.h"
 #include "power_manager/powerd/system/udev_stub.h"
 #include "power_manager/proto_bindings/backlight.pb.h"

 namespace power_manager {
 namespace policy {

 namespace {
 // An artificial syspath for tests.
 const char kSyspath0[] = "/sys/devices/test/0";

 // Create aliases for lengthy constant names.
 const char* const kTagInhibit = InputDeviceController::kTagInhibit;
 const char* const kTagUsableWhenDocked =
     InputDeviceController::kTagUsableWhenDocked;
 const char* const kTagUsableWhenDisplayOff =
     InputDeviceController::kTagUsableWhenDisplayOff;
 const char* const kTagUsableWhenLaptop =
     InputDeviceController::kTagUsableWhenLaptop;
 const char* const kTagUsableWhenTablet =
     InputDeviceController::kTagUsableWhenTablet;
 const char* const kTagWakeup = InputDeviceController::kTagWakeup;
 const char* const kTagWakeupWhenLaptop =
     InputDeviceController::kTagWakeupWhenLaptop;
 const char* const kTagWakeupOnlyWhenUsable =
     InputDeviceController::kTagWakeupOnlyWhenUsable;
 const char* const kTagWakeupDisabled =
     InputDeviceController::kTagWakeupDisabled;
 const char* const kEnabled = InputDeviceController::kWakeupEnabled;
 const char* const kDisabled = InputDeviceController::kWakeupDisabled;
 const char* const kInhibited = InputDeviceController::kInhibited;
 const char* const kTPAD = InputDeviceController::kTPAD;
 const char* const kTSCR = InputDeviceController::kTSCR;

 }  // namespace

 class InputDeviceControllerTest : public ::testing::Test {
  public:
   InputDeviceControllerTest() = default;
   InputDeviceControllerTest(const InputDeviceControllerTest&) = delete;
   InputDeviceControllerTest& operator=(const InputDeviceControllerTest&) =
       delete;

   ~InputDeviceControllerTest() override = default;

  protected:
   std::string GetSysattr(const std::string& syspath,
                          const std::string& sysattr) {
     std::string value;
     if (!udev_.GetSysattr(syspath, sysattr, &value))
       return "(error)";
     return value;
   }

   bool GetAcpiWakeup(const std::string& acpi_name) {
     bool value = false;
     if (!acpi_wakeup_helper_.GetWakeupEnabled(acpi_name, &value)) {
       ADD_FAILURE() << "Expected ACPI wakeup for " << acpi_name
                     << " to be defined";
     }
     return value;
   }

   // Adds a device at |syspath| with one or more udev tags. The tag list must be
   // null-terminated.
   void AddDeviceWithTags(const std::string& syspath, const char* tag, ...) {
     udev_.SetSysattr(syspath, kPowerWakeup, kDisabled);

     std::string tags;
     va_list arg_list;
     va_start(arg_list, tag);
     while (tag) {
       if (!tags.empty())
         tags += " ";
       tags += tag;
       tag = va_arg(arg_list, const char*);
     }
     va_end(arg_list);

     udev_.TaggedDeviceChanged(syspath, base::FilePath(syspath), tags);
   }

   void InitInputDeviceController() {
     input_device_controller_.Init(&backlight_controller_, &udev_,
                                   &acpi_wakeup_helper_, &ec_helper_,
                                   initial_lid_state_, initial_tablet_mode_,
                                   initial_display_mode_, &prefs_);
   }

   policy::BacklightControllerStub backlight_controller_;
   system::UdevStub udev_;
   system::AcpiWakeupHelperStub acpi_wakeup_helper_;
   system::CrosEcHelperStub ec_helper_;
   FakePrefs prefs_;

   LidState initial_lid_state_ = LidState::OPEN;
   TabletMode initial_tablet_mode_ = TabletMode::OFF;
   DisplayMode initial_display_mode_ = DisplayMode::NORMAL;

   InputDeviceController input_device_controller_;
 };

 TEST_F(InputDeviceControllerTest, ConfigureWakeupOnInit) {
   AddDeviceWithTags(kSyspath0, kTagWakeup, nullptr);

   EXPECT_EQ(kDisabled, GetSysattr(kSyspath0, kPowerWakeup));
   InitInputDeviceController();
   EXPECT_EQ(kEnabled, GetSysattr(kSyspath0, kPowerWakeup));
   EXPECT_TRUE(GetAcpiWakeup(kTPAD));
   EXPECT_FALSE(GetAcpiWakeup(kTSCR));
 }

 TEST_F(InputDeviceControllerTest, ConfigureWakeupOnAdd) {
   InitInputDeviceController();

   // The device starts out with wakeup disabled, but should get configured by
   // InputDeviceController right away.
   AddDeviceWithTags(kSyspath0, kTagWakeup, nullptr);
   EXPECT_EQ(kEnabled, GetSysattr(kSyspath0, kPowerWakeup));
 }

 TEST_F(InputDeviceControllerTest, DisableWakeupWhenClosed) {
   AddDeviceWithTags(kSyspath0, kTagWakeup, kTagWakeupOnlyWhenUsable,
                     kTagUsableWhenLaptop, nullptr);
   InitInputDeviceController();

   // In laptop mode, wakeup should be enabled.
   EXPECT_EQ(kEnabled, GetSysattr(kSyspath0, kPowerWakeup));
   EXPECT_TRUE(GetAcpiWakeup("TPAD"));

   // When the lid is closed, wakeup should be disabled.
   input_device_controller_.SetLidState(LidState::CLOSED);
   EXPECT_EQ(kDisabled, GetSysattr(kSyspath0, kPowerWakeup));
   EXPECT_FALSE(GetAcpiWakeup(kTPAD));
 }

 TEST_F(InputDeviceControllerTest, PermanentlyDisableWakeup) {
   AddDeviceWithTags(kSyspath0, kTagWakeup, kTagWakeupDisabled, nullptr);

   // Simulate a device that has wakeup enabled initially.
   udev_.SetSysattr(kSyspath0, kPowerWakeup, kEnabled);
   InitInputDeviceController();
   EXPECT_EQ(kDisabled, GetSysattr(kSyspath0, kPowerWakeup));
 }

 TEST_F(InputDeviceControllerTest, ConfigureInhibit) {
   AddDeviceWithTags(kSyspath0, kTagInhibit, kTagUsableWhenLaptop, nullptr);
   InitInputDeviceController();

   // In laptop mode, inhibit should be off.
   EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

   // When the lid is closed, inhibit should be on.
   input_device_controller_.SetLidState(LidState::CLOSED);
   EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));

   // When the lid is open, inhibit should be off again.
   input_device_controller_.SetLidState(LidState::OPEN);
   EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));
 }

 TEST_F(InputDeviceControllerTest, InhibitDocking) {
   AddDeviceWithTags(kSyspath0, kTagInhibit, kTagUsableWhenLaptop,
                     kTagUsableWhenDocked, nullptr);
   initial_display_mode_ = DisplayMode::PRESENTATION;
   InitInputDeviceController();

   // In laptop mode, inhibit should be off.
   EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

   // When the lid is closed, inhibit should remain off.
   input_device_controller_.SetLidState(LidState::CLOSED);
   EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

   // When the lid is open, inhibit should still be off.
   input_device_controller_.SetLidState(LidState::OPEN);
   EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));
 }

 TEST_F(InputDeviceControllerTest, SetDisplayModeExternalInput) {
   AddDeviceWithTags(kSyspath0, kTagInhibit, kTagUsableWhenLaptop,
                     kTagUsableWhenDocked, nullptr);
   initial_lid_state_ = LidState::CLOSED;
   InitInputDeviceController();

   // When the lid is closed with no external display, external input devices
   // should be inhibited.
   EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));

   // When an external display is attached, device should be un-inhibited.
   input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
   EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

   // When external display goes away, input should be inhibited again.
   input_device_controller_.SetDisplayMode(DisplayMode::NORMAL);
   EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));
 }

 TEST_F(InputDeviceControllerTest, SetDisplayModeInternalInput) {
   AddDeviceWithTags(kSyspath0, kTagInhibit, kTagUsableWhenLaptop, nullptr);
   InitInputDeviceController();

   // Devices that are only usable when in laptop mode should not be inhibited
   // while the lid is open.
   EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

   // When an external display is attached, device should remain uninhibited.
   input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
   EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

   // When the lid is closed, internal input should be inhibited regardless
   // of display mode.
   input_device_controller_.SetLidState(LidState::CLOSED);
   EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));

   input_device_controller_.SetDisplayMode(DisplayMode::NORMAL);
   EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));
 }

 TEST_F(InputDeviceControllerTest, AllowEcWakeupAsTabletWhenDisplayOff) {
   InitInputDeviceController();

   // Start in presentation mode at full brightness.
   input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
   backlight_controller_.NotifyObservers(
       100.0, BacklightBrightnessChange_Cause_USER_REQUEST);

   // EC wakeups should be inhibited in tablet mode while backlight is on.
   EXPECT_FALSE(ec_helper_.IsWakeupAsTabletAllowed());

   // Automated display off should not trigger a mode change.
   backlight_controller_.NotifyObservers(
       0.0, BacklightBrightnessChange_Cause_USER_INACTIVITY);
   EXPECT_FALSE(ec_helper_.IsWakeupAsTabletAllowed());

   // ...but manual should.
   backlight_controller_.NotifyObservers(
       0.0, BacklightBrightnessChange_Cause_USER_REQUEST);
   EXPECT_TRUE(ec_helper_.IsWakeupAsTabletAllowed());

   // Leaving presentation mode should disallow it.
   input_device_controller_.SetDisplayMode(DisplayMode::NORMAL);
   EXPECT_FALSE(ec_helper_.IsWakeupAsTabletAllowed());
   input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
   EXPECT_TRUE(ec_helper_.IsWakeupAsTabletAllowed());

   // As should raising the brightness, even if automatic.
   backlight_controller_.NotifyObservers(10.0,
                                         BacklightBrightnessChange_Cause_OTHER);
   EXPECT_FALSE(ec_helper_.IsWakeupAsTabletAllowed());
 }

 TEST_F(InputDeviceControllerTest, HandleTabletMode) {
   const char kKeyboardSyspath[] = "/sys/devices/keyboard/0";
   const char kTouchscreenSyspath[] = "/sys/devices/touchscreen/0";
   AddDeviceWithTags(kKeyboardSyspath, kTagInhibit, kTagWakeup,
                     kTagWakeupOnlyWhenUsable, kTagUsableWhenLaptop,
                     kTagUsableWhenDisplayOff, nullptr);
   AddDeviceWithTags(kTouchscreenSyspath, kTagInhibit, kTagWakeup,
                     kTagWakeupOnlyWhenUsable, kTagUsableWhenLaptop,
                     kTagUsableWhenTablet, nullptr);
   initial_tablet_mode_ = TabletMode::ON;

   // While in tablet mode, the keyboard should be inhibited with wakeup
   // disabled.
   InitInputDeviceController();
   EXPECT_EQ("1", GetSysattr(kKeyboardSyspath, kInhibited));
   EXPECT_EQ(kDisabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
   EXPECT_EQ("0", GetSysattr(kTouchscreenSyspath, kInhibited));
   EXPECT_EQ(kEnabled, GetSysattr(kTouchscreenSyspath, kPowerWakeup));

   // Switching to laptop mode should uninhibit the keyboard and permit wakeups.
   input_device_controller_.SetTabletMode(TabletMode::OFF);
   EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
   EXPECT_EQ(kEnabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
   EXPECT_EQ("0", GetSysattr(kTouchscreenSyspath, kInhibited));
   EXPECT_EQ(kEnabled, GetSysattr(kTouchscreenSyspath, kPowerWakeup));

   // Lid-closed mode should take precedence over tablet mode. (See b/119287727)
   input_device_controller_.SetTabletMode(TabletMode::ON);
   input_device_controller_.SetLidState(LidState::CLOSED);
   EXPECT_EQ("1", GetSysattr(kKeyboardSyspath, kInhibited));
   EXPECT_EQ(kDisabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
   EXPECT_EQ("1", GetSysattr(kTouchscreenSyspath, kInhibited));
   EXPECT_EQ(kDisabled, GetSysattr(kTouchscreenSyspath, kPowerWakeup));

   // Display-off mode should take precedence over tablet mode.
   input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
   input_device_controller_.SetLidState(LidState::OPEN);
   input_device_controller_.SetTabletMode(TabletMode::ON);
   input_device_controller_.OnBrightnessChange(
       0.0, BacklightBrightnessChange_Cause_USER_REQUEST,
       &backlight_controller_);
   EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
   EXPECT_EQ(kEnabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
   EXPECT_EQ("1", GetSysattr(kTouchscreenSyspath, kInhibited));
   EXPECT_EQ(kDisabled, GetSysattr(kTouchscreenSyspath, kPowerWakeup));
 }

 TEST_F(InputDeviceControllerTest, UsableWithoutWakeup) {
   // Add a keyboard device that should remain usable while in tablet mode (say,
   // because it also produces power button events: http://crbug.com/703691) but
   // that should only wake the device while in laptop mode.
   const char kKeyboardSyspath[] = "/sys/devices/keyboard/0";
   AddDeviceWithTags(kKeyboardSyspath, kTagInhibit, kTagUsableWhenLaptop,
                     kTagUsableWhenTablet, kTagWakeup, kTagWakeupWhenLaptop,
                     nullptr);

   initial_tablet_mode_ = TabletMode::OFF;
   InitInputDeviceController();
   EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
   EXPECT_EQ(kEnabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));

   input_device_controller_.SetTabletMode(TabletMode::ON);
   EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
   EXPECT_EQ(kDisabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));

   input_device_controller_.SetTabletMode(TabletMode::OFF);
   EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
   EXPECT_EQ(kEnabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
 }

 TEST_F(InputDeviceControllerTest, InitWithoutBacklightController) {
   // Init with null backlight controller shouldn't crash.
   input_device_controller_.Init(
       nullptr, &udev_, &acpi_wakeup_helper_, &ec_helper_, initial_lid_state_,
       initial_tablet_mode_, initial_display_mode_, &prefs_);
 }

 }  // namespace policy
 }  // namespace power_manager
	// Copyright 2014 The Chromium OS 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 "power_manager/powerd/policy/input_device_controller.h"

	#include <cstdarg>

	#include <gtest/gtest.h>

	#include "power_manager/common/fake_prefs.h"
	#include "power_manager/common/power_constants.h"
	#include "power_manager/powerd/policy/backlight_controller_stub.h"
	#include "power_manager/powerd/system/acpi_wakeup_helper_stub.h"
	#include "power_manager/powerd/system/cros_ec_helper_stub.h"
	#include "power_manager/powerd/system/udev_stub.h"
	#include "power_manager/proto_bindings/backlight.pb.h"

	namespace power_manager {
	namespace policy {

	namespace {
	// An artificial syspath for tests.
	const char kSyspath0[] = "/sys/devices/test/0";

	// Create aliases for lengthy constant names.
	const char* const kTagInhibit = InputDeviceController::kTagInhibit;
	const char* const kTagUsableWhenDocked =
	InputDeviceController::kTagUsableWhenDocked;
	const char* const kTagUsableWhenDisplayOff =
	InputDeviceController::kTagUsableWhenDisplayOff;
	const char* const kTagUsableWhenLaptop =
	InputDeviceController::kTagUsableWhenLaptop;
	const char* const kTagUsableWhenTablet =
	InputDeviceController::kTagUsableWhenTablet;
	const char* const kTagWakeup = InputDeviceController::kTagWakeup;
	const char* const kTagWakeupWhenLaptop =
	InputDeviceController::kTagWakeupWhenLaptop;
	const char* const kTagWakeupOnlyWhenUsable =
	InputDeviceController::kTagWakeupOnlyWhenUsable;
	const char* const kTagWakeupDisabled =
	InputDeviceController::kTagWakeupDisabled;
	const char* const kEnabled = InputDeviceController::kWakeupEnabled;
	const char* const kDisabled = InputDeviceController::kWakeupDisabled;
	const char* const kInhibited = InputDeviceController::kInhibited;
	const char* const kTPAD = InputDeviceController::kTPAD;
	const char* const kTSCR = InputDeviceController::kTSCR;

	} // namespace

	class InputDeviceControllerTest : public ::testing::Test {
	public:
	InputDeviceControllerTest() = default;
	InputDeviceControllerTest(const InputDeviceControllerTest&) = delete;
	InputDeviceControllerTest& operator=(const InputDeviceControllerTest&) =
	delete;

	~InputDeviceControllerTest() override = default;

	protected:
	std::string GetSysattr(const std::string& syspath,
	const std::string& sysattr) {
	std::string value;
	if (!udev_.GetSysattr(syspath, sysattr, &value))
	return "(error)";
	return value;
	}

	bool GetAcpiWakeup(const std::string& acpi_name) {
	bool value = false;
	if (!acpi_wakeup_helper_.GetWakeupEnabled(acpi_name, &value)) {
	ADD_FAILURE() << "Expected ACPI wakeup for " << acpi_name
	<< " to be defined";
	}
	return value;
	}

	// Adds a device at \|syspath\| with one or more udev tags. The tag list must be
	// null-terminated.
	void AddDeviceWithTags(const std::string& syspath, const char* tag, ...) {
	udev_.SetSysattr(syspath, kPowerWakeup, kDisabled);

	std::string tags;
	va_list arg_list;
	va_start(arg_list, tag);
	while (tag) {
	if (!tags.empty())
	tags += " ";
	tags += tag;
	tag = va_arg(arg_list, const char*);
	}
	va_end(arg_list);

	udev_.TaggedDeviceChanged(syspath, base::FilePath(syspath), tags);
	}

	void InitInputDeviceController() {
	input_device_controller_.Init(&backlight_controller_, &udev_,
	&acpi_wakeup_helper_, &ec_helper_,
	initial_lid_state_, initial_tablet_mode_,
	initial_display_mode_, &prefs_);
	}

	policy::BacklightControllerStub backlight_controller_;
	system::UdevStub udev_;
	system::AcpiWakeupHelperStub acpi_wakeup_helper_;
	system::CrosEcHelperStub ec_helper_;
	FakePrefs prefs_;

	LidState initial_lid_state_ = LidState::OPEN;
	TabletMode initial_tablet_mode_ = TabletMode::OFF;
	DisplayMode initial_display_mode_ = DisplayMode::NORMAL;

	InputDeviceController input_device_controller_;
	};

	TEST_F(InputDeviceControllerTest, ConfigureWakeupOnInit) {
	AddDeviceWithTags(kSyspath0, kTagWakeup, nullptr);

	EXPECT_EQ(kDisabled, GetSysattr(kSyspath0, kPowerWakeup));
	InitInputDeviceController();
	EXPECT_EQ(kEnabled, GetSysattr(kSyspath0, kPowerWakeup));
	EXPECT_TRUE(GetAcpiWakeup(kTPAD));
	EXPECT_FALSE(GetAcpiWakeup(kTSCR));
	}

	TEST_F(InputDeviceControllerTest, ConfigureWakeupOnAdd) {
	InitInputDeviceController();

	// The device starts out with wakeup disabled, but should get configured by
	// InputDeviceController right away.
	AddDeviceWithTags(kSyspath0, kTagWakeup, nullptr);
	EXPECT_EQ(kEnabled, GetSysattr(kSyspath0, kPowerWakeup));
	}

	TEST_F(InputDeviceControllerTest, DisableWakeupWhenClosed) {
	AddDeviceWithTags(kSyspath0, kTagWakeup, kTagWakeupOnlyWhenUsable,
	kTagUsableWhenLaptop, nullptr);
	InitInputDeviceController();

	// In laptop mode, wakeup should be enabled.
	EXPECT_EQ(kEnabled, GetSysattr(kSyspath0, kPowerWakeup));
	EXPECT_TRUE(GetAcpiWakeup("TPAD"));

	// When the lid is closed, wakeup should be disabled.
	input_device_controller_.SetLidState(LidState::CLOSED);
	EXPECT_EQ(kDisabled, GetSysattr(kSyspath0, kPowerWakeup));
	EXPECT_FALSE(GetAcpiWakeup(kTPAD));
	}

	TEST_F(InputDeviceControllerTest, PermanentlyDisableWakeup) {
	AddDeviceWithTags(kSyspath0, kTagWakeup, kTagWakeupDisabled, nullptr);

	// Simulate a device that has wakeup enabled initially.
	udev_.SetSysattr(kSyspath0, kPowerWakeup, kEnabled);
	InitInputDeviceController();
	EXPECT_EQ(kDisabled, GetSysattr(kSyspath0, kPowerWakeup));
	}

	TEST_F(InputDeviceControllerTest, ConfigureInhibit) {
	AddDeviceWithTags(kSyspath0, kTagInhibit, kTagUsableWhenLaptop, nullptr);
	InitInputDeviceController();

	// In laptop mode, inhibit should be off.
	EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

	// When the lid is closed, inhibit should be on.
	input_device_controller_.SetLidState(LidState::CLOSED);
	EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));

	// When the lid is open, inhibit should be off again.
	input_device_controller_.SetLidState(LidState::OPEN);
	EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));
	}

	TEST_F(InputDeviceControllerTest, InhibitDocking) {
	AddDeviceWithTags(kSyspath0, kTagInhibit, kTagUsableWhenLaptop,
	kTagUsableWhenDocked, nullptr);
	initial_display_mode_ = DisplayMode::PRESENTATION;
	InitInputDeviceController();

	// In laptop mode, inhibit should be off.
	EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

	// When the lid is closed, inhibit should remain off.
	input_device_controller_.SetLidState(LidState::CLOSED);
	EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

	// When the lid is open, inhibit should still be off.
	input_device_controller_.SetLidState(LidState::OPEN);
	EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));
	}

	TEST_F(InputDeviceControllerTest, SetDisplayModeExternalInput) {
	AddDeviceWithTags(kSyspath0, kTagInhibit, kTagUsableWhenLaptop,
	kTagUsableWhenDocked, nullptr);
	initial_lid_state_ = LidState::CLOSED;
	InitInputDeviceController();

	// When the lid is closed with no external display, external input devices
	// should be inhibited.
	EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));

	// When an external display is attached, device should be un-inhibited.
	input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
	EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

	// When external display goes away, input should be inhibited again.
	input_device_controller_.SetDisplayMode(DisplayMode::NORMAL);
	EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));
	}

	TEST_F(InputDeviceControllerTest, SetDisplayModeInternalInput) {
	AddDeviceWithTags(kSyspath0, kTagInhibit, kTagUsableWhenLaptop, nullptr);
	InitInputDeviceController();

	// Devices that are only usable when in laptop mode should not be inhibited
	// while the lid is open.
	EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

	// When an external display is attached, device should remain uninhibited.
	input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
	EXPECT_EQ("0", GetSysattr(kSyspath0, kInhibited));

	// When the lid is closed, internal input should be inhibited regardless
	// of display mode.
	input_device_controller_.SetLidState(LidState::CLOSED);
	EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));

	input_device_controller_.SetDisplayMode(DisplayMode::NORMAL);
	EXPECT_EQ("1", GetSysattr(kSyspath0, kInhibited));
	}

	TEST_F(InputDeviceControllerTest, AllowEcWakeupAsTabletWhenDisplayOff) {
	InitInputDeviceController();

	// Start in presentation mode at full brightness.
	input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
	backlight_controller_.NotifyObservers(
	100.0, BacklightBrightnessChange_Cause_USER_REQUEST);

	// EC wakeups should be inhibited in tablet mode while backlight is on.
	EXPECT_FALSE(ec_helper_.IsWakeupAsTabletAllowed());

	// Automated display off should not trigger a mode change.
	backlight_controller_.NotifyObservers(
	0.0, BacklightBrightnessChange_Cause_USER_INACTIVITY);
	EXPECT_FALSE(ec_helper_.IsWakeupAsTabletAllowed());

	// ...but manual should.
	backlight_controller_.NotifyObservers(
	0.0, BacklightBrightnessChange_Cause_USER_REQUEST);
	EXPECT_TRUE(ec_helper_.IsWakeupAsTabletAllowed());

	// Leaving presentation mode should disallow it.
	input_device_controller_.SetDisplayMode(DisplayMode::NORMAL);
	EXPECT_FALSE(ec_helper_.IsWakeupAsTabletAllowed());
	input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
	EXPECT_TRUE(ec_helper_.IsWakeupAsTabletAllowed());

	// As should raising the brightness, even if automatic.
	backlight_controller_.NotifyObservers(10.0,
	BacklightBrightnessChange_Cause_OTHER);
	EXPECT_FALSE(ec_helper_.IsWakeupAsTabletAllowed());
	}

	TEST_F(InputDeviceControllerTest, HandleTabletMode) {
	const char kKeyboardSyspath[] = "/sys/devices/keyboard/0";
	const char kTouchscreenSyspath[] = "/sys/devices/touchscreen/0";
	AddDeviceWithTags(kKeyboardSyspath, kTagInhibit, kTagWakeup,
	kTagWakeupOnlyWhenUsable, kTagUsableWhenLaptop,
	kTagUsableWhenDisplayOff, nullptr);
	AddDeviceWithTags(kTouchscreenSyspath, kTagInhibit, kTagWakeup,
	kTagWakeupOnlyWhenUsable, kTagUsableWhenLaptop,
	kTagUsableWhenTablet, nullptr);
	initial_tablet_mode_ = TabletMode::ON;

	// While in tablet mode, the keyboard should be inhibited with wakeup
	// disabled.
	InitInputDeviceController();
	EXPECT_EQ("1", GetSysattr(kKeyboardSyspath, kInhibited));
	EXPECT_EQ(kDisabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
	EXPECT_EQ("0", GetSysattr(kTouchscreenSyspath, kInhibited));
	EXPECT_EQ(kEnabled, GetSysattr(kTouchscreenSyspath, kPowerWakeup));

	// Switching to laptop mode should uninhibit the keyboard and permit wakeups.
	input_device_controller_.SetTabletMode(TabletMode::OFF);
	EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
	EXPECT_EQ(kEnabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
	EXPECT_EQ("0", GetSysattr(kTouchscreenSyspath, kInhibited));
	EXPECT_EQ(kEnabled, GetSysattr(kTouchscreenSyspath, kPowerWakeup));

	// Lid-closed mode should take precedence over tablet mode. (See b/119287727)
	input_device_controller_.SetTabletMode(TabletMode::ON);
	input_device_controller_.SetLidState(LidState::CLOSED);
	EXPECT_EQ("1", GetSysattr(kKeyboardSyspath, kInhibited));
	EXPECT_EQ(kDisabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
	EXPECT_EQ("1", GetSysattr(kTouchscreenSyspath, kInhibited));
	EXPECT_EQ(kDisabled, GetSysattr(kTouchscreenSyspath, kPowerWakeup));

	// Display-off mode should take precedence over tablet mode.
	input_device_controller_.SetDisplayMode(DisplayMode::PRESENTATION);
	input_device_controller_.SetLidState(LidState::OPEN);
	input_device_controller_.SetTabletMode(TabletMode::ON);
	input_device_controller_.OnBrightnessChange(
	0.0, BacklightBrightnessChange_Cause_USER_REQUEST,
	&backlight_controller_);
	EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
	EXPECT_EQ(kEnabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
	EXPECT_EQ("1", GetSysattr(kTouchscreenSyspath, kInhibited));
	EXPECT_EQ(kDisabled, GetSysattr(kTouchscreenSyspath, kPowerWakeup));
	}

	TEST_F(InputDeviceControllerTest, UsableWithoutWakeup) {
	// Add a keyboard device that should remain usable while in tablet mode (say,
	// because it also produces power button events: http://crbug.com/703691) but
	// that should only wake the device while in laptop mode.
	const char kKeyboardSyspath[] = "/sys/devices/keyboard/0";
	AddDeviceWithTags(kKeyboardSyspath, kTagInhibit, kTagUsableWhenLaptop,
	kTagUsableWhenTablet, kTagWakeup, kTagWakeupWhenLaptop,
	nullptr);

	initial_tablet_mode_ = TabletMode::OFF;
	InitInputDeviceController();
	EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
	EXPECT_EQ(kEnabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));

	input_device_controller_.SetTabletMode(TabletMode::ON);
	EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
	EXPECT_EQ(kDisabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));

	input_device_controller_.SetTabletMode(TabletMode::OFF);
	EXPECT_EQ("0", GetSysattr(kKeyboardSyspath, kInhibited));
	EXPECT_EQ(kEnabled, GetSysattr(kKeyboardSyspath, kPowerWakeup));
	}

	TEST_F(InputDeviceControllerTest, InitWithoutBacklightController) {
	// Init with null backlight controller shouldn't crash.
	input_device_controller_.Init(
	nullptr, &udev_, &acpi_wakeup_helper_, &ec_helper_, initial_lid_state_,
	initial_tablet_mode_, initial_display_mode_, &prefs_);
	}

	} // namespace policy
	} // namespace power_manager