input_device_settings: Changed script invocations to use new scripts

chrome/browser/chromeos/system/input_device_settings.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/system/input_device_settings.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 15 matching lines @@
 #include "content/public/browser/browser_thread.h"
 
 namespace chromeos {
 namespace system {
 
 namespace {
 
 InputDeviceSettings* g_instance_;
 InputDeviceSettings* g_test_instance_;
 
-const char kTpControl[] = "/opt/google/touchpad/tpcontrol";
-const char kMouseControl[] = "/opt/google/mouse/mousecontrol";
+const char kDeviceTypeTouchpad[] = "touchpad";
+const char kDeviceTypeMouse[] = "mouse";
+const char kInputControl[] = "/opt/google/input/inputcontrol";
 
 const char kRemoraRequisition[] = "remora";
 
 typedef base::RefCountedData<bool> RefCountedBool;
 
 bool ScriptExists(const std::string& script) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   return base::PathExists(base::FilePath(script));
 }
 
@@ skipping 26 matching lines @@
   // Control scripts can take long enough to cause SIGART during shutdown
   // (http://crbug.com/261426). Run the blocking pool task with
   // CONTINUE_ON_SHUTDOWN so it won't be joined when Chrome shuts down.
   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
   scoped_refptr<base::TaskRunner> runner =
       pool->GetTaskRunnerWithShutdownBehavior(
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   runner->PostTask(FROM_HERE, base::Bind(&ExecuteScriptOnFileThread, argv));
 }
 
-void AddSensitivityArguments(int value, std::vector<std::string>* argv) {
+void AddSensitivityArguments(const char* device_type, int value,
+                             std::vector<std::string>* argv) {
   DCHECK(value >= kMinPointerSensitivity && value <= kMaxPointerSensitivity);
-  argv->push_back("sensitivity");
-  argv->push_back(base::StringPrintf("%d", value));
+  argv->push_back(base::StringPrintf("--%s_sensitivity=%d",
+                                     device_type, value));
 }
 
 void AddTPControlArguments(const char* control,
                            bool enabled,
                            std::vector<std::string>* argv) {
-  argv->push_back(control);
-  argv->push_back(enabled ? "on" : "off");
+  argv->push_back(base::StringPrintf("--%s=%d", control, enabled ? 1 : 0));
 }
 
-void DeviceExistsBlockingPool(const char* script,
+void DeviceExistsBlockingPool(const char* device_type,
                               scoped_refptr<RefCountedBool> exists) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   exists->data = false;
-  if (!ScriptExists(script))
+  if (!ScriptExists(kInputControl))
     return;
 
   std::vector<std::string> argv;
-  argv.push_back(script);
-  argv.push_back("status");
+  argv.push_back(kInputControl);
+  argv.push_back(base::StringPrintf("--type=%s", device_type));
+  argv.push_back("--list");
   std::string output;
   // Output is empty if the device is not found.
   exists->data = base::GetAppOutput(CommandLine(argv), &output) &&
       !output.empty();
-  DVLOG(1) << "DeviceExistsBlockingPool:" << script << "=" << exists->data;
+  DVLOG(1) << "DeviceExistsBlockingPool:" << device_type << "=" << exists->data;
 }
 
 void RunCallbackUIThread(
     scoped_refptr<RefCountedBool> exists,
     const InputDeviceSettings::DeviceExistsCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DVLOG(1) << "RunCallbackUIThread " << exists->data;
   callback.Run(exists->data);
 }
 
@@ skipping 39 matching lines @@
   TouchpadSettings current_touchpad_settings_;
   MouseSettings current_mouse_settings_;
 
   DISALLOW_COPY_AND_ASSIGN(InputDeviceSettingsImpl);
 };
 
 InputDeviceSettingsImpl::InputDeviceSettingsImpl() {}
 
 void InputDeviceSettingsImpl::TouchpadExists(
     const DeviceExistsCallback& callback) {
-  DeviceExists(kTpControl, callback);
+  DeviceExists(kDeviceTypeTouchpad, callback);
 }
 
 void InputDeviceSettingsImpl::UpdateTouchpadSettings(
     const TouchpadSettings& settings) {
   std::vector<std::string> argv;
   if (current_touchpad_settings_.Update(settings, &argv))
     ExecuteScript(argv);
 }
 
 void InputDeviceSettingsImpl::SetTouchpadSensitivity(int value) {
@@ skipping 17 matching lines @@
 
 void InputDeviceSettingsImpl::SetTapDragging(bool enabled) {
   TouchpadSettings settings;
   settings.SetTapDragging(enabled);
   UpdateTouchpadSettings(settings);
 }
 
 void InputDeviceSettingsImpl::MouseExists(
     const DeviceExistsCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DeviceExists(kMouseControl, callback);
+  DeviceExists(kDeviceTypeMouse, callback);
 }
 
 void InputDeviceSettingsImpl::UpdateMouseSettings(const MouseSettings& update) {
   std::vector<std::string> argv;
   if (current_mouse_settings_.Update(update, &argv))
     ExecuteScript(argv);
 }
 
 void InputDeviceSettingsImpl::SetMouseSensitivity(int value) {
   MouseSettings settings;
@@ skipping 86 matching lines @@
   tap_dragging_.Set(enabled);
 }
 
 bool TouchpadSettings::GetTapDragging() const {
   return tap_dragging_.value();
 }
 
 bool TouchpadSettings::Update(const TouchpadSettings& settings,
                               std::vector<std::string>* argv) {
   if (argv)
-    argv->push_back(kTpControl);
+    argv->push_back(kInputControl);
   bool updated = false;
   if (sensitivity_.Update(settings.sensitivity_)) {
     updated = true;
     if (argv)
-      AddSensitivityArguments(sensitivity_.value(), argv);
+      AddSensitivityArguments(kDeviceTypeTouchpad, sensitivity_.value(), argv);
   }
   if (tap_to_click_.Update(settings.tap_to_click_)) {
     updated = true;
     if (argv)
-      AddTPControlArguments("taptoclick", tap_to_click_.value(), argv);
+      AddTPControlArguments("tapclick", tap_to_click_.value(), argv);
   }
   if (three_finger_click_.Update(settings.three_finger_click_)) {
     updated = true;
     if (argv)
       AddTPControlArguments("t5r2_three_finger_click",
                             three_finger_click_.value(),
                             argv);
   }
   if (tap_dragging_.Update(settings.tap_dragging_)) {
     updated = true;
     if (argv)
-      AddTPControlArguments("tap_dragging", tap_dragging_.value(), argv);
+      AddTPControlArguments("tapdrag", tap_dragging_.value(), argv);
   }
   return updated;
 }
 
 MouseSettings::MouseSettings() {}
 
 MouseSettings& MouseSettings::operator=(const MouseSettings& other) {
   if (&other != this) {
     sensitivity_ = other.sensitivity_;
     primary_button_right_ = other.primary_button_right_;
@@ skipping 13 matching lines @@
   primary_button_right_.Set(right);
 }
 
 bool MouseSettings::GetPrimaryButtonRight() const {
   return primary_button_right_.value();
 }
 
 bool MouseSettings::Update(const MouseSettings& settings,
                            std::vector<std::string>* argv) {
   if (argv)
-    argv->push_back(kMouseControl);
+    argv->push_back(kInputControl);
   bool updated = false;
   if (sensitivity_.Update(settings.sensitivity_)) {
     updated = true;
     if (argv)
-      AddSensitivityArguments(sensitivity_.value(), argv);
+      AddSensitivityArguments(kDeviceTypeMouse, sensitivity_.value(), argv);
   }
   if (primary_button_right_.Update(settings.primary_button_right_)) {
     updated = true;
     if (argv) {
-      argv->push_back("swap_left_right");
-      argv->push_back(settings.GetPrimaryButtonRight() ? "1" : "0");
+      AddTPControlArguments("mouse_swap_lr", primary_button_right_.value(),
+                            argv);
     }
   }
   return updated;
 }
 
 // static
 InputDeviceSettings* InputDeviceSettings::Get() {
   if (g_test_instance_)
     return g_test_instance_;
   if (!g_instance_)
     g_instance_ = new InputDeviceSettingsImpl;
   return g_instance_;
 }
 
 // static
 void InputDeviceSettings::SetSettingsForTesting(
     InputDeviceSettings* test_settings) {
   if (g_test_instance_ == test_settings)
     return;
   delete g_test_instance_;
   g_test_instance_ = test_settings;
 }
 
 }  // namespace system
 }  // namespace chromeos