Dump property values for the touch log source

ui/events/ozone/evdev/input_controller_evdev.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/events/ozone/evdev/input_controller_evdev.h"
 
+#include <algorithm>
 #include <linux/input.h>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
 #include "ui/events/ozone/evdev/mouse_button_map_evdev.h"
 
 #if defined(USE_EVDEV_GESTURES)
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 #endif
 
 namespace ui {
 
 namespace {
@@ skipping 13 matching lines @@
 void SetGestureBoolProperty(GesturePropertyProvider* provider,
                             int id,
                             const std::string& name,
                             bool value) {
   GesturesProp* property = provider->GetProperty(id, name);
   if (property) {
     std::vector<bool> values(1, value);
     property->SetBoolValue(values);
   }
 }
+
+// Return the values in an array in one string. Used for touch logging.
+template <typename T>
+std::string DumpArrayProperty(const std::vector<T>& value, const char* format) {
+  std::string ret;
+  for (size_t i = 0; i < value.size(); ++i) {
+    if (i > 0)
+      ret.append(", ");
+    ret.append(base::StringPrintf(format, value[i]));
+  }
+  return ret;
+}
+
+// Return the values in a gesture property in one string. Used for touch
+// logging.
+std::string DumpGesturePropertyValue(GesturesProp* property) {
+  switch (property->type()) {
+    case GesturePropertyProvider::PT_INT:
+      return DumpArrayProperty(property->GetIntValue(), "%d");
+      break;
+    case GesturePropertyProvider::PT_SHORT:
+      return DumpArrayProperty(property->GetShortValue(), "%d");
+      break;
+    case GesturePropertyProvider::PT_BOOL:
+      return DumpArrayProperty(property->GetBoolValue(), "%d");
+      break;
+    case GesturePropertyProvider::PT_STRING:
+      return "\"" + property->GetStringValue() + "\"";
+      break;
+    case GesturePropertyProvider::PT_REAL:
+      return DumpArrayProperty(property->GetDoubleValue(), "%lf");
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+  return std::string();
+}
+
 #endif
 
+// Dump touch device property values to a string.
+void DumpTouchDeviceStatus(EventFactoryEvdev* event_factory,
+#if defined(USE_EVDEV_GESTURES)
+                           GesturePropertyProvider* provider,
+#endif
+                           std::string* status) {
+#if defined(USE_EVDEV_GESTURES)
+  // We use DT_ALL since we want gesture property values for all devices that
+  // run with the gesture library, not just mice or touchpads.
+  std::vector<int> ids;
+  event_factory->GetDeviceIdsByType(DT_ALL, &ids);
+
+  // Dump the property names and values for each device.
+  for (size_t i = 0; i < ids.size(); ++i) {
+    std::vector<std::string> names = provider->GetPropertyNamesById(ids[i]);
+    status->append("\n");
+    status->append(base::StringPrintf("ID %d:\n", ids[i]));
+    status->append(base::StringPrintf(
+        "Device \'%s\':\n", provider->GetDeviceNameById(ids[i]).c_str()));
+
+    // Note that, unlike X11, we don't maintain the "atom" concept here.
+    // Therefore, the property name indices we output here shouldn't be treated
+    // as unique identifiers of the properties.
+    std::sort(names.begin(), names.end());
+    for (size_t j = 0; j < names.size(); ++j) {
+      status->append(base::StringPrintf("\t%s (%lu):", names[j].c_str(), j));
+      GesturesProp* property = provider->GetProperty(ids[i], names[j]);
+      status->append("\t" + DumpGesturePropertyValue(property) + '\n');
+    }
+  }
+#endif
+}
+
 }  // namespace
 
 InputControllerEvdev::InputControllerEvdev(
     EventFactoryEvdev* event_factory,
     KeyboardEvdev* keyboard,
     MouseButtonMapEvdev* button_map
 #if defined(USE_EVDEV_GESTURES)
     ,
     GesturePropertyProvider* gesture_property_provider
 #endif
@@ skipping 122 matching lines @@
 
 void InputControllerEvdev::SetPrimaryButtonRight(bool right) {
   button_map_->UpdateButtonMap(BTN_LEFT, right ? BTN_RIGHT : BTN_LEFT);
   button_map_->UpdateButtonMap(BTN_RIGHT, right ? BTN_LEFT : BTN_RIGHT);
 }
 
 void InputControllerEvdev::SetTapToClickPaused(bool state) {
   SetBoolPropertyForOneType(DT_TOUCHPAD, "Tap Paused", state);
 }
 
+void InputControllerEvdev::GetTouchDeviceStatus(
+    const GetTouchDeviceStatusReply& reply) {
+  scoped_ptr<std::string> status(new std::string);
+  std::string* status_ptr = status.get();

[spang, 2015/01/28 00:50:47]

Probably better to do something like:

#if defined(USE_EVDEV_GESTURES)
  // PostTaskAndReply
#else
  reply.Run(make_scoped_ptr(new std::string)));
#endif


and just #ifdef out the whole function.

[Shecky Lin, 2015/01/28 01:02:00]

Done.

+  base::ThreadTaskRunnerHandle::Get()->PostTaskAndReply(
+      FROM_HERE, base::Bind(&DumpTouchDeviceStatus, event_factory_,
+#if defined(USE_EVDEV_GESTURES)
+                            gesture_property_provider_,
+#endif
+                            status_ptr),
+      base::Bind(reply, base::Passed(&status)));
+}
+
 }  // namespace ui