Enabled/disable touch screen in TabletPowerButtonController

By exposing several apis in input_device_settings.h and add new local pref for TouchScreenEnabled, we can disable touch screen events when backlights are forced off so that no screen UI events can be triggered and enable touch screen when stopping backlights forced off is called properly.

BUG=655388
BUG=633304
TEST=manual test on device, and add test coverage.
also test that this added behavior is compatible with toggle touchscreen shortcut
The shortcut induced in https://codereview.chromium.org/2467023004 is per user pref, backlights-forced-off related touch screen status is per device pref. The final hardware touchscreen status is determined by the rule: enabled_in_local_state && enabled_in_user_pref

Review-Url: https://codereview.chromium.org/2533373002
Cr-Commit-Position: refs/heads/master@{#436177}

ash/common/accelerators/debug_commands.cc

@@ -128,7 +128,11 @@ void HandleToggleTouchpad() {
 
 void HandleToggleTouchscreen() {
   base::RecordAction(base::UserMetricsAction("Accel_Toggle_Touchscreen"));
-  ash::WmShell::Get()->delegate()->ToggleTouchscreen();
+  ShellDelegate* delegate = WmShell::Get()->delegate();
+  delegate->SetTouchscreenEnabledInPrefs(
+      !delegate->IsTouchscreenEnabledInPrefs(false /* use_local_state */),
+      false /* use_local_state */);
+  delegate->UpdateTouchscreenStatusFromPrefs();
 }
 
 void HandleToggleTouchView() {

ash/common/shell_delegate.h

@@ -133,9 +133,21 @@ class ASH_EXPORT ShellDelegate {
 
   virtual gfx::Image GetDeprecatedAcceleratorImage() const = 0;
 
-  // Toggles the status of the touchpad / touchscreen on or off.
+  // If |use_local_state| is true, returns the touchscreen status from local
+  // state, otherwise from user prefs.
+  virtual bool IsTouchscreenEnabledInPrefs(bool use_local_state) const = 0;
+
+  // Sets the status of touchscreen to |enabled| in prefs. If |use_local_state|,
+  // pref is set in local state, otherwise in user prefs.
+  virtual void SetTouchscreenEnabledInPrefs(bool enabled,
+                                            bool use_local_state) = 0;
+
+  // Updates the enabled/disabled status of the touchscreen from prefs. Enabled
+  // if both local state and user prefs are enabled, otherwise disabled.
+  virtual void UpdateTouchscreenStatusFromPrefs() = 0;
+
+  // Toggles the status of touchpad between enabled and disabled.
   virtual void ToggleTouchpad() {}
-  virtual void ToggleTouchscreen() {}
 };
 
 }  // namespace ash

ash/mus/shell_delegate_mus.cc

@@ -231,4 +231,18 @@ gfx::Image ShellDelegateMus::GetDeprecatedAcceleratorImage() const {
   return gfx::Image();
 }
 
+bool ShellDelegateMus::IsTouchscreenEnabledInPrefs(bool use_local_state) const {
+  NOTIMPLEMENTED();
+  return true;
+}
+
+void ShellDelegateMus::SetTouchscreenEnabledInPrefs(bool enabled,
+                                                    bool use_local_state) {
+  NOTIMPLEMENTED();
+}
+
+void ShellDelegateMus::UpdateTouchscreenStatusFromPrefs() {
+  NOTIMPLEMENTED();
+}
+
 }  // namespace ash

ash/mus/shell_delegate_mus.h

@@ -47,6 +47,10 @@ class ShellDelegateMus : public ShellDelegate {
   GPUSupport* CreateGPUSupport() override;
   base::string16 GetProductName() const override;
   gfx::Image GetDeprecatedAcceleratorImage() const override;
+  bool IsTouchscreenEnabledInPrefs(bool use_local_state) const override;
+  void SetTouchscreenEnabledInPrefs(bool enabled,
+                                    bool use_local_state) override;
+  void UpdateTouchscreenStatusFromPrefs() override;
 
  private:
   service_manager::Connector* connector_;

ash/shell/shell_delegate_impl.cc

@@ -265,5 +265,15 @@ gfx::Image ShellDelegateImpl::GetDeprecatedAcceleratorImage() const {
   return gfx::Image();
 }
 
+bool ShellDelegateImpl::IsTouchscreenEnabledInPrefs(
+    bool use_local_state) const {
+  return true;
+}
+
+void ShellDelegateImpl::SetTouchscreenEnabledInPrefs(bool enabled,
+                                                     bool use_local_state) {}
+
+void ShellDelegateImpl::UpdateTouchscreenStatusFromPrefs() {}
+
 }  // namespace shell
 }  // namespace ash

ash/shell/shell_delegate_impl.h

@@ -53,6 +53,10 @@ class ShellDelegateImpl : public ShellDelegate {
   GPUSupport* CreateGPUSupport() override;
   base::string16 GetProductName() const override;
   gfx::Image GetDeprecatedAcceleratorImage() const override;
+  bool IsTouchscreenEnabledInPrefs(bool use_local_state) const override;
+  void SetTouchscreenEnabledInPrefs(bool enabled,
+                                    bool use_local_state) override;
+  void UpdateTouchscreenStatusFromPrefs() override;
 
  private:
   ShelfDelegate* shelf_delegate_;

ash/system/chromeos/power/tablet_power_button_controller.cc

@@ -6,6 +6,7 @@
 
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/session/session_state_delegate.h"
+#include "ash/common/shell_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/shell.h"
@@ -96,24 +97,27 @@ void TabletPowerButtonController::OnPowerButtonEvent(
   // backlight has been turned back on before seeing the power button events
   // that woke the system. Ignore events just after resuming to ensure that we
   // don't turn the screen off in response to the events.
+  //
+  // TODO(warx): pressing power button should also StartShutdownTimer() in this
+  // case. Reorganize the code to support that.
   if (timestamp - last_resume_time_ <=
       base::TimeDelta::FromMilliseconds(kIgnorePowerButtonAfterResumeMs)) {
     // If backlights are forced off, stop forcing off because resuming system
     // doesn't handle this.
     if (down && backlights_forced_off_)
-      SetBacklightsForcedOff(false);
+      SetDisplayForcedOff(false);
     return;
   }
 
   if (down) {
     screen_off_when_power_button_down_ = brightness_level_is_zero_;
-    SetBacklightsForcedOff(false);
+    SetDisplayForcedOff(false);
     StartShutdownTimer();
   } else {
     if (shutdown_timer_.IsRunning()) {
       shutdown_timer_.Stop();
       if (!screen_off_when_power_button_down_) {
-        SetBacklightsForcedOff(true);
+        SetDisplayForcedOff(true);
         LockScreenIfRequired();
       }
     }
@@ -149,7 +153,7 @@ void TabletPowerButtonController::OnKeyEvent(ui::KeyEvent* event) {
     return;
 
   if (!IsTabletModeActive() && backlights_forced_off_)
-    SetBacklightsForcedOff(false);
+    SetDisplayForcedOff(false);
 }
 
 void TabletPowerButtonController::OnMouseEvent(ui::MouseEvent* event) {
@@ -161,13 +165,13 @@ void TabletPowerButtonController::OnMouseEvent(ui::MouseEvent* event) {
   }
 
   if (!IsTabletModeActive() && backlights_forced_off_)
-    SetBacklightsForcedOff(false);
+    SetDisplayForcedOff(false);
 }
 
 void TabletPowerButtonController::OnStylusStateChanged(ui::StylusState state) {
   if (IsTabletModeSupported() && state == ui::StylusState::REMOVED &&
       backlights_forced_off_) {
-    SetBacklightsForcedOff(false);
+    SetDisplayForcedOff(false);
   }
 }
 
@@ -177,15 +181,21 @@ void TabletPowerButtonController::SetTickClockForTesting(
   tick_clock_ = std::move(tick_clock);
 }
 
-void TabletPowerButtonController::SetBacklightsForcedOff(bool forced_off) {
+void TabletPowerButtonController::SetDisplayForcedOff(bool forced_off) {
   if (backlights_forced_off_ == forced_off)
     return;
 
+  // Set the display and keyboard backlights (if present) to |forced_off|.
   chromeos::DBusThreadManager::Get()
       ->GetPowerManagerClient()
       ->SetBacklightsForcedOff(forced_off);
   backlights_forced_off_ = forced_off;
 
+  ShellDelegate* delegate = WmShell::Get()->delegate();
+  delegate->SetTouchscreenEnabledInPrefs(!forced_off,
+                                         true /* use_local_state */);
+  delegate->UpdateTouchscreenStatusFromPrefs();
+
   // Send an a11y alert.
   WmShell::Get()->accessibility_delegate()->TriggerAccessibilityAlert(
       forced_off ? A11Y_ALERT_SCREEN_OFF : A11Y_ALERT_SCREEN_ON);

ash/system/chromeos/power/tablet_power_button_controller.h

@@ -72,8 +72,10 @@ class ASH_EXPORT TabletPowerButtonController
   void SetTickClockForTesting(std::unique_ptr<base::TickClock> tick_clock);
 
  private:
-  // Set backlights to |forced_off| if they aren't already.
-  void SetBacklightsForcedOff(bool forced_off);
+  // Updates the power manager's backlights-forced-off state and enables or
+  // disables the touchscreen. No-op if |backlights_forced_off_| already equals
+  // |forced_off|.
+  void SetDisplayForcedOff(bool forced_off);
 
   // Sends a request to powerd to get the backlights forced off state so that
   // |backlights_forced_off_| can be initialized.

ash/system/chromeos/power/tablet_power_button_controller_unittest.cc

@@ -13,6 +13,7 @@
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/lock_state_controller_test_api.h"
+#include "ash/test/test_shell_delegate.h"
 #include "ash/wm/lock_state_controller.h"
 #include "ash/wm/power_button_controller.h"
 #include "base/command_line.h"
@@ -64,6 +65,8 @@ class TabletPowerButtonControllerTest : public AshTestBase {
     tick_clock_ = new base::SimpleTestTickClock;
     tablet_controller_->SetTickClockForTesting(
         std::unique_ptr<base::TickClock>(tick_clock_));
+    shell_delegate_ =
+        static_cast<TestShellDelegate*>(WmShell::Get()->delegate());
     generator_ = &AshTestBase::GetEventGenerator();
     power_manager_client_->SendBrightnessChanged(kNonZeroBrightness, false);
     EXPECT_FALSE(GetBacklightsForcedOff());
@@ -119,6 +122,7 @@ class TabletPowerButtonControllerTest : public AshTestBase {
   TabletPowerButtonController* tablet_controller_;  // Not owned.
   std::unique_ptr<TabletPowerButtonController::TestApi> test_api_;
   base::SimpleTestTickClock* tick_clock_;  // Not owned.
+  TestShellDelegate* shell_delegate_;      // Not owned.
   ui::test::EventGenerator* generator_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(TabletPowerButtonControllerTest);
@@ -356,5 +360,43 @@ TEST_F(TabletPowerButtonControllerTest, IgnorePowerOnKeyEvent) {
   EXPECT_EQ(1, power_manager_client_->num_set_backlights_forced_off_calls());
 }
 
+// Tests that under (1) tablet power button pressed/released, (2) keyboard/mouse
+// events on laptop mode when screen is off, requesting/stopping backlights
+// forced off should also set corresponding touch screen state in local pref.
+TEST_F(TabletPowerButtonControllerTest, TouchScreenState) {
+  // Tests tablet power button.
+  EXPECT_TRUE(shell_delegate_->IsTouchscreenEnabledInPrefs(true));
+  PressPowerButton();
+  ReleasePowerButton();
+  power_manager_client_->SendBrightnessChanged(0, false);
+  EXPECT_FALSE(shell_delegate_->IsTouchscreenEnabledInPrefs(true));
+
+  PressPowerButton();
+  power_manager_client_->SendBrightnessChanged(kNonZeroBrightness, false);
+  ReleasePowerButton();
+  EXPECT_TRUE(shell_delegate_->IsTouchscreenEnabledInPrefs(true));
+
+  EnableMaximizeMode(false);
+  // KeyEvent on laptop mode when screen is off.
+  PressPowerButton();
+  ReleasePowerButton();
+  power_manager_client_->SendBrightnessChanged(0, false);
+  EXPECT_TRUE(GetBacklightsForcedOff());
+  EXPECT_FALSE(shell_delegate_->IsTouchscreenEnabledInPrefs(true));
+  generator_->PressKey(ui::VKEY_L, ui::EF_NONE);
+  power_manager_client_->SendBrightnessChanged(kNonZeroBrightness, false);
+  EXPECT_TRUE(shell_delegate_->IsTouchscreenEnabledInPrefs(true));
+
+  // MouseEvent on laptop mode when screen is off.
+  PressPowerButton();
+  ReleasePowerButton();
+  power_manager_client_->SendBrightnessChanged(0, false);
+  EXPECT_TRUE(GetBacklightsForcedOff());
+  EXPECT_FALSE(shell_delegate_->IsTouchscreenEnabledInPrefs(true));
+  generator_->MoveMouseBy(1, 1);
+  power_manager_client_->SendBrightnessChanged(kNonZeroBrightness, false);
+  EXPECT_TRUE(shell_delegate_->IsTouchscreenEnabledInPrefs(true));
+}
+
 }  // namespace test
 }  // namespace ash

ash/test/test_shell_delegate.cc

@@ -86,6 +86,7 @@ TestShellDelegate::TestShellDelegate()
     : num_exit_requests_(0),
       multi_profiles_enabled_(false),
       force_maximize_on_first_run_(false),
+      touchscreen_enabled_in_local_pref_(true),
       app_list_presenter_delegate_factory_(new AppListPresenterDelegateFactory(
           base::WrapUnique(new AppListViewDelegateFactoryImpl))) {}
 
@@ -184,6 +185,19 @@ gfx::Image TestShellDelegate::GetDeprecatedAcceleratorImage() const {
   return gfx::Image();
 }
 
+bool TestShellDelegate::IsTouchscreenEnabledInPrefs(
+    bool use_local_state) const {
+  return use_local_state ? touchscreen_enabled_in_local_pref_ : true;
+}
+
+void TestShellDelegate::SetTouchscreenEnabledInPrefs(bool enabled,
+                                                     bool use_local_state) {
+  if (use_local_state)
+    touchscreen_enabled_in_local_pref_ = enabled;
+}
+
+void TestShellDelegate::UpdateTouchscreenStatusFromPrefs() {}
+
 void TestShellDelegate::SetMediaCaptureState(MediaCaptureState state) {
 #if defined(OS_CHROMEOS)
   static_cast<MediaDelegateImpl*>(WmShell::Get()->media_delegate())

ash/test/test_shell_delegate.h

@@ -60,6 +60,11 @@ class TestShellDelegate : public ShellDelegate {
   base::string16 GetProductName() const override;
   gfx::Image GetDeprecatedAcceleratorImage() const override;
 
+  bool IsTouchscreenEnabledInPrefs(bool use_local_state) const override;
+  void SetTouchscreenEnabledInPrefs(bool enabled,
+                                    bool use_local_state) override;
+  void UpdateTouchscreenStatusFromPrefs() override;
+
   int num_exit_requests() const { return num_exit_requests_; }
 
   app_list::AppListPresenterImpl* app_list_presenter() {
@@ -75,6 +80,7 @@ class TestShellDelegate : public ShellDelegate {
   int num_exit_requests_;
   bool multi_profiles_enabled_;
   bool force_maximize_on_first_run_;
+  bool touchscreen_enabled_in_local_pref_;
 
   std::unique_ptr<app_list::AppListPresenterDelegateFactory>
       app_list_presenter_delegate_factory_;

chrome/browser/chromeos/chrome_browser_main_chromeos.cc

@@ -756,6 +756,8 @@ void ChromeBrowserMainPartsChromeos::PreBrowserStart() {
 
 void ChromeBrowserMainPartsChromeos::PostBrowserStart() {
   if (!chrome::IsRunningInMash()) {
+    system::InputDeviceSettings::Get()->UpdateTouchDevicesStatusFromPrefs();
+
     // These are dependent on the ash::Shell singleton already having been
     // initialized. Consequently, these cannot be used when running as a mus
     // client.

chrome/browser/chromeos/preferences.cc

@@ -707,8 +707,7 @@ void Preferences::ApplyPreferences(ApplyReason reason,
                                              prefs::kUse24HourClock, value);
   }
 
-  system::InputDeviceSettings::Get()
-      ->UpdateTouchDevicesStatusFromActiveProfilePrefs();
+  system::InputDeviceSettings::Get()->UpdateTouchDevicesStatusFromPrefs();
 }
 
 void Preferences::OnIsSyncingChanged() {

chrome/browser/chromeos/system/input_device_settings.cc

@@ -233,43 +233,70 @@ bool InputDeviceSettings::ForceKeyboardDrivenUINavigation() {
   return false;
 }
 
+// static
+void InputDeviceSettings::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterBooleanPref(::prefs::kTouchscreenEnabledLocal, true);
+}
+
 // static
 void InputDeviceSettings::RegisterProfilePrefs(PrefRegistrySimple* registry) {
-  registry->RegisterBooleanPref(::prefs::kTouchScreenEnabled, true);
-  registry->RegisterBooleanPref(::prefs::kTouchPadEnabled, true);
+  registry->RegisterBooleanPref(::prefs::kTouchscreenEnabled, true);
+  registry->RegisterBooleanPref(::prefs::kTouchpadEnabled, true);
 }
 
-void InputDeviceSettings::UpdateTouchDevicesStatusFromActiveProfilePrefs() {
+void InputDeviceSettings::UpdateTouchDevicesStatusFromPrefs() {
+  UpdateTouchscreenStatusFromPrefs();
+
   PrefService* user_prefs = GetActiveProfilePrefs();
   if (!user_prefs)
     return;
 
-  const bool touch_screen_status =
-      user_prefs->HasPrefPath(::prefs::kTouchScreenEnabled)
-          ? user_prefs->GetBoolean(::prefs::kTouchScreenEnabled)
+  const bool touchpad_status =
+      user_prefs->HasPrefPath(::prefs::kTouchpadEnabled)
+          ? user_prefs->GetBoolean(::prefs::kTouchpadEnabled)
           : true;
-
-  const bool touch_pad_status =
-      user_prefs->HasPrefPath(::prefs::kTouchPadEnabled)
-          ? user_prefs->GetBoolean(::prefs::kTouchPadEnabled)
-          : true;
-
-  SetTouchscreensEnabled(touch_screen_status);
-  SetInternalTouchpadEnabled(touch_pad_status);
+  SetInternalTouchpadEnabled(touchpad_status);
+}
+
+bool InputDeviceSettings::IsTouchscreenEnabledInPrefs(
+    bool use_local_state) const {
+  if (use_local_state) {
+    PrefService* local_state = g_browser_process->local_state();
+    DCHECK(local_state);
+
+    return local_state->HasPrefPath(::prefs::kTouchscreenEnabledLocal)
+               ? local_state->GetBoolean(::prefs::kTouchscreenEnabledLocal)
+               : true;
+  } else {
+    PrefService* user_prefs = GetActiveProfilePrefs();
+    if (!user_prefs)
+      return true;
+
+    return user_prefs->HasPrefPath(::prefs::kTouchscreenEnabled)
+               ? user_prefs->GetBoolean(::prefs::kTouchscreenEnabled)
+               : true;
+  }
 }
 
-void InputDeviceSettings::ToggleTouchscreen() {
-  PrefService* user_prefs = GetActiveProfilePrefs();
-  if (!user_prefs)
-    return;
+void InputDeviceSettings::SetTouchscreenEnabledInPrefs(bool enabled,
+                                                       bool use_local_state) {
+  if (use_local_state) {
+    PrefService* local_state = g_browser_process->local_state();
+    DCHECK(local_state);
+    local_state->SetBoolean(::prefs::kTouchscreenEnabledLocal, enabled);
+  } else {
+    PrefService* user_prefs = GetActiveProfilePrefs();
+    if (!user_prefs)
+      return;
 
-  const bool touch_screen_status =
-      user_prefs->HasPrefPath(::prefs::kTouchScreenEnabled)
-          ? user_prefs->GetBoolean(::prefs::kTouchScreenEnabled)
-          : true;
+    user_prefs->SetBoolean(::prefs::kTouchscreenEnabled, enabled);
+  }
+}
 
-  user_prefs->SetBoolean(::prefs::kTouchScreenEnabled, !touch_screen_status);
-  SetTouchscreensEnabled(!touch_screen_status);
+void InputDeviceSettings::UpdateTouchscreenStatusFromPrefs() {
+  bool enabled_in_local_state = IsTouchscreenEnabledInPrefs(true);
+  bool enabled_in_user_prefs = IsTouchscreenEnabledInPrefs(false);
+  SetTouchscreensEnabled(enabled_in_local_state && enabled_in_user_prefs);
 }
 
 void InputDeviceSettings::ToggleTouchpad() {
@@ -277,13 +304,13 @@ void InputDeviceSettings::ToggleTouchpad() {
   if (!user_prefs)
     return;
 
-  const bool touch_pad_status =
-      user_prefs->HasPrefPath(::prefs::kTouchPadEnabled)
-          ? user_prefs->GetBoolean(::prefs::kTouchPadEnabled)
+  const bool touchpad_status =
+      user_prefs->HasPrefPath(::prefs::kTouchpadEnabled)
+          ? user_prefs->GetBoolean(::prefs::kTouchpadEnabled)
           : true;
 
-  user_prefs->SetBoolean(::prefs::kTouchPadEnabled, !touch_pad_status);
-  SetInternalTouchpadEnabled(!touch_pad_status);
+  user_prefs->SetBoolean(::prefs::kTouchpadEnabled, !touchpad_status);
+  SetInternalTouchpadEnabled(!touchpad_status);
 }
 
 }  // namespace system

chrome/browser/chromeos/system/input_device_settings.h

@@ -174,16 +174,29 @@ class CHROMEOS_EXPORT InputDeviceSettings {
   // where other input devices like mouse are absent.
   static bool ForceKeyboardDrivenUINavigation();
 
-  // Registers profile pref names for touchpad and touch screen statuses.
+  // Registers local state pref names for touchscreen status.
+  static void RegisterPrefs(PrefRegistrySimple* registry);
+
+  // Registers profile pref names for touchpad and touchscreen statuses.
   static void RegisterProfilePrefs(PrefRegistrySimple* registry);
 
-  // Updates the on/off status of the touchscreen/touchpad from the active
-  // user's preferences.
-  void UpdateTouchDevicesStatusFromActiveProfilePrefs();
+  // Updates the enabled/disabled status of the touchscreen/touchpad from the
+  // preferences.
+  void UpdateTouchDevicesStatusFromPrefs();
+
+  // If |use_local_state| is true, returns the touchscreen status from local
+  // state, otherwise from user prefs.
+  bool IsTouchscreenEnabledInPrefs(bool use_local_state) const;
+
+  // Sets the status of touchscreen to |enabled| in prefs. If |use_local_state|,
+  // pref is set in local state, otherwise in user pref.
+  void SetTouchscreenEnabledInPrefs(bool enabled, bool use_local_state);
+
+  // Updates the enabled/disabled status of the touchscreen from prefs. Enabled
+  // if both local state and user prefs are enabled, otherwise disabled.
+  void UpdateTouchscreenStatusFromPrefs();
 
-  // Toggles the status of Touchscreen/Touchpad on or off and updates the local
-  // prefs.
-  void ToggleTouchscreen();
+  // Toggles the status of touchpad between enabled and disabled.
   void ToggleTouchpad();
 
   // Calls |callback|, possibly asynchronously, after determining if a touchpad

chrome/browser/prefs/browser_prefs.cc

@@ -429,6 +429,7 @@ void RegisterLocalState(PrefRegistrySimple* registry) {
   chromeos::SigninScreenHandler::RegisterPrefs(registry);
   chromeos::StartupUtils::RegisterPrefs(registry);
   chromeos::system::AutomaticRebootManager::RegisterPrefs(registry);
+  chromeos::system::InputDeviceSettings::RegisterPrefs(registry);
   chromeos::TimeZoneResolver::RegisterPrefs(registry);
   chromeos::UserImageManager::RegisterPrefs(registry);
   chromeos::UserSessionManager::RegisterPrefs(registry);
@@ -707,8 +708,8 @@ void RegisterLoginProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
 void MigrateObsoleteBrowserPrefs(Profile* profile, PrefService* local_state) {
 #if defined(OS_CHROMEOS)
   // Added 11/2016
-  local_state->ClearPref(prefs::kTouchScreenEnabled);
-  local_state->ClearPref(prefs::kTouchPadEnabled);
+  local_state->ClearPref(prefs::kTouchscreenEnabled);
+  local_state->ClearPref(prefs::kTouchpadEnabled);
 #endif  // defined(OS_CHROMEOS)
 }
 

chrome/browser/ui/ash/chrome_shell_delegate.cc

@@ -500,12 +500,25 @@ gfx::Image ChromeShellDelegate::GetDeprecatedAcceleratorImage() const {
       IDR_BLUETOOTH_KEYBOARD);
 }
 
-void ChromeShellDelegate::ToggleTouchpad() {
-  chromeos::system::InputDeviceSettings::Get()->ToggleTouchpad();
+bool ChromeShellDelegate::IsTouchscreenEnabledInPrefs(
+    bool use_local_state) const {
+  return chromeos::system::InputDeviceSettings::Get()
+      ->IsTouchscreenEnabledInPrefs(use_local_state);
+}
+
+void ChromeShellDelegate::SetTouchscreenEnabledInPrefs(bool enabled,
+                                                       bool use_local_state) {
+  chromeos::system::InputDeviceSettings::Get()->SetTouchscreenEnabledInPrefs(
+      enabled, use_local_state);
 }
 
-void ChromeShellDelegate::ToggleTouchscreen() {
-  chromeos::system::InputDeviceSettings::Get()->ToggleTouchscreen();
+void ChromeShellDelegate::UpdateTouchscreenStatusFromPrefs() {
+  chromeos::system::InputDeviceSettings::Get()
+      ->UpdateTouchscreenStatusFromPrefs();
+}
+
+void ChromeShellDelegate::ToggleTouchpad() {
+  chromeos::system::InputDeviceSettings::Get()->ToggleTouchpad();
 }
 
 keyboard::KeyboardUI* ChromeShellDelegate::CreateKeyboardUI() {

chrome/browser/ui/ash/chrome_shell_delegate.h

@@ -56,8 +56,11 @@ class ChromeShellDelegate : public ash::ShellDelegate,
   base::string16 GetProductName() const override;
   void OpenKeyboardShortcutHelpPage() const override;
   gfx::Image GetDeprecatedAcceleratorImage() const override;
+  bool IsTouchscreenEnabledInPrefs(bool use_local_state) const override;
+  void SetTouchscreenEnabledInPrefs(bool enabled,
+                                    bool use_local_state) override;
+  void UpdateTouchscreenStatusFromPrefs() override;
   void ToggleTouchpad() override;
-  void ToggleTouchscreen() override;
 
   // content::NotificationObserver override:
   void Observe(int type,

chrome/common/pref_names.cc

@@ -844,9 +844,9 @@ const char kFileSystemProviderMounted[] = "file_system_provider.mounted";
 // A boolean pref set to true if the virtual keyboard should be enabled.
 const char kTouchVirtualKeyboardEnabled[] = "ui.touch_virtual_keyboard_enabled";
 
-// Boolean prefs for the status of the touch screen and the touchpad.
-const char kTouchScreenEnabled[] = "events.touch_screen.enabled";
-const char kTouchPadEnabled[] = "events.touch_pad.enabled";
+// Boolean prefs for the status of the touchscreen and the touchpad.
+const char kTouchscreenEnabled[] = "events.touch_screen.enabled";
+const char kTouchpadEnabled[] = "events.touch_pad.enabled";
 
 // A boolean pref that controls whether the dark connect feature is enabled.
 // The dark connect feature allows a Chrome OS device to periodically wake
@@ -1415,13 +1415,6 @@ const char kTaskManagerColumnVisibility[] = "task_manager.column_visibility";
 // A boolean indicating if ending processes are enabled or disabled by policy.
 const char kTaskManagerEndProcessEnabled[] = "task_manager.end_process_enabled";
 
-#if defined(OS_CHROMEOS)
-// Dictionary indicating current network bandwidth throttling settings.
-// Contains a boolean (is throttling enabled) and two integers (upload rate
-// and download rate in kbits/s to throttle to)
-const char kNetworkThrottlingEnabled[] = "net.throttling_enabled";
-#endif
-
 // A collection of position, size, and other data relating to app windows to
 // restore on startup.
 const char kAppWindowPlacement[] = "browser.app_window_placement";
@@ -1883,6 +1876,14 @@ const char kIsBootstrappingSlave[] = "is_oobe_bootstrapping_slave";
 // A preference that controlles Android status reporting.
 const char kReportArcStatusEnabled[] = "arc.status_reporting_enabled";
 
+// Dictionary indicating current network bandwidth throttling settings.
+// Contains a boolean (is throttling enabled) and two integers (upload rate
+// and download rate in kbits/s to throttle to)
+const char kNetworkThrottlingEnabled[] = "net.throttling_enabled";
+
+// Boolean prefs for the local status of the touchscreen.
+const char kTouchscreenEnabledLocal[] = "events.touch_screen.enabled_local";
+
 #endif  // defined(OS_CHROMEOS)
 
 // Whether there is a Flash version installed that supports clearing LSO data.

chrome/common/pref_names.h

@@ -293,8 +293,8 @@ extern const char kTimeOnOobe[];
 extern const char kCurrentWallpaperAppName[];
 extern const char kFileSystemProviderMounted[];
 extern const char kTouchVirtualKeyboardEnabled[];
-extern const char kTouchScreenEnabled[];
-extern const char kTouchPadEnabled[];
+extern const char kTouchscreenEnabled[];
+extern const char kTouchpadEnabled[];
 extern const char kWakeOnWifiDarkConnect[];
 extern const char kCaptivePortalAuthenticationIgnoresProxy[];
 extern const char kForceMaximizeOnFirstRun[];
@@ -664,6 +664,7 @@ extern const char kConsumerManagementStage[];
 extern const char kIsBootstrappingSlave[];
 extern const char kReportArcStatusEnabled[];
 extern const char kNetworkThrottlingEnabled[];
+extern const char kTouchscreenEnabledLocal[];
 #endif  // defined(OS_CHROMEOS)
 
 extern const char kClearPluginLSODataEnabled[];