Dump property values for the touch log source

The CL dumps gesture property values for touch devices that run
with the CrOS gesture library. The format is designed to be
backward-compatible with the X11 behaviour.

Contributed by sheckylin@chromium.org

BUG=450159
TEST=samus ChromeOS build

Committed: https://crrev.com/8b1fb4fdf2b13b71e969cd541e500549163f742b
Cr-Commit-Position: refs/heads/master@{#313446}

Review URL: https://codereview.chromium.org/864253002

Cr-Commit-Position: refs/heads/master@{#313555}

chrome/browser/chromeos/system_logs/touch_log_source_ozone.cc

@@ -6,12 +6,17 @@
 
 #include "ash/touch/touch_hud_debug.h"
 #include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
 #include "base/process/launch.h"
 #include "components/feedback/feedback_util.h"
 #include "content/public/browser/browser_thread.h"
+#include "ui/ozone/public/input_controller.h"
+#include "ui/ozone/public/ozone_platform.h"
 
 using content::BrowserThread;
 
@@ -19,7 +24,26 @@ namespace {
 
 const char kHUDLogDataKey[] = "hud_log";
 
-void GetTouchLogsOzone(system_logs::SystemLogsResponse* response) {
+// The prefix "hack-33025" was historically chosen in http://crbug.com/139715.
+// We continue to go with it in order to be compatible with the existing touch
+// log processing toolchain.
+const char kDeviceStatusLogDataKey[] = "hack-33025-touchpad";
+
+// Callback for handing the outcome of GetTouchDeviceStatus(). Appends the
+// collected log to the SystemLogsResponse map.
+void OnStatusLogCollected(scoped_ptr<system_logs::SystemLogsResponse> response,
+                          const system_logs::SysLogsSourceCallback& callback,
+                          scoped_ptr<std::string> log) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  (*response)[kDeviceStatusLogDataKey] = *log;
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(callback, base::Owned(response.release())));
+}
+
+// Collect touch HUD debug logs. This needs to be done on the UI thread.
+void CollectTouchHudDebugLog(system_logs::SystemLogsResponse* response) {
   scoped_ptr<base::DictionaryValue> dictionary =
       ash::TouchHudDebug::GetAllAsDictionary();
   if (!dictionary->empty()) {
@@ -29,10 +53,6 @@ void GetTouchLogsOzone(system_logs::SystemLogsResponse* response) {
     if (json.Serialize(*dictionary) && !touch_log.empty())
       (*response)[kHUDLogDataKey] = touch_log;
   }
-
-  // TODO(sheckylin): Add ozone touch log collection implementation. See
-  // http://crbug.com/400022.
-  NOTIMPLEMENTED();
 }
 
 }  // namespace
@@ -43,10 +63,12 @@ void TouchLogSource::Fetch(const SysLogsSourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  SystemLogsResponse* response = new SystemLogsResponse;
-  BrowserThread::PostBlockingPoolTaskAndReply(
-      FROM_HERE, base::Bind(&GetTouchLogsOzone, response),
-      base::Bind(callback, base::Owned(response)));
+  scoped_ptr<SystemLogsResponse> response(new SystemLogsResponse);
+  CollectTouchHudDebugLog(response.get());
+
+  // Collect touch device status logs.
+  ui::OzonePlatform::GetInstance()->GetInputController()->GetTouchDeviceStatus(
+      base::Bind(&OnStatusLogCollected, base::Passed(&response), callback));
 }
 
 }  // namespace system_logs

ui/events/ozone/evdev/input_controller_evdev.cc

@@ -4,9 +4,13 @@
 
 #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"
 
@@ -40,6 +44,74 @@ void SetGestureBoolProperty(GesturePropertyProvider* provider,
     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();
+}
+
+// Dump touch device property values to a string.
+void DumpTouchDeviceStatus(EventFactoryEvdev* event_factory,
+                           GesturePropertyProvider* provider,
+                           std::string* status) {
+  // 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 (%zu):", names[j].c_str(), j));
+      GesturesProp* property = provider->GetProperty(ids[i], names[j]);
+      status->append("\t" + DumpGesturePropertyValue(property) + '\n');
+    }
+  }
+}
+
 #endif
 
 }  // namespace
@@ -184,4 +256,18 @@ 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);
+#if defined(USE_EVDEV_GESTURES)
+  std::string* status_ptr = status.get();
+  base::ThreadTaskRunnerHandle::Get()->PostTaskAndReply(
+      FROM_HERE, base::Bind(&DumpTouchDeviceStatus, event_factory_,
+                            gesture_property_provider_, status_ptr),
+      base::Bind(reply, base::Passed(&status)));
+#else
+  reply.Run(status.Pass());
+#endif
+}
+
 }  // namespace ui

ui/events/ozone/evdev/input_controller_evdev.h

@@ -55,6 +55,7 @@ class EVENTS_OZONE_EVDEV_EXPORT InputControllerEvdev : public InputController {
   void SetMouseSensitivity(int value) override;
   void SetPrimaryButtonRight(bool right) override;
   void SetTapToClickPaused(bool state) override;
+  void GetTouchDeviceStatus(const GetTouchDeviceStatusReply& reply) override;
   void DisableInternalTouchpad() override;
   void EnableInternalTouchpad() override;
   void DisableInternalKeyboardExceptKeys(

ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.cc

@@ -877,6 +877,30 @@ GesturesProp* GesturePropertyProvider::GetProperty(const DeviceId device_id,
   return FindProperty(device_id, name);
 }
 
+std::vector<std::string> GesturePropertyProvider::GetPropertyNamesById(
+    const DeviceId device_id) {
+  internal::GestureDevicePropertyData* device_data =
+      device_data_map_.get(device_id);
+  if (!device_data)
+    return std::vector<std::string>();
+
+  // Dump all property names of the device.
+  std::vector<std::string> names;
+  for (internal::ScopedPropertiesMap::const_iterator it =
+           device_data->properties.begin();
+       it != device_data->properties.end(); ++it)
+    names.push_back(it->first);
+  return names;
+}
+
+std::string GesturePropertyProvider::GetDeviceNameById(
+    const DeviceId device_id) {
+  DeviceMap::const_iterator it = device_map_.find(device_id);
+  if (it == device_map_.end())
+    return std::string();
+  return std::string(it->second->info.name);
+}
+
 void GesturePropertyProvider::RegisterDevice(const DeviceId id,
                                              const DevicePtr device) {
   DeviceMap::const_iterator it = device_map_.find(id);

ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h

@@ -96,6 +96,13 @@ class EVENTS_OZONE_EVDEV_EXPORT GesturePropertyProvider {
   // clicked "OK").
   GesturesProp* GetProperty(const DeviceId device_id, const std::string& name);
 
+  // Get the names of all properties of one device. Mostly used for the logging
+  // purpose.
+  std::vector<std::string> GetPropertyNamesById(const DeviceId device_id);
+
+  // Get the (Evdev) device name. Mostly used for the logging purpose.
+  std::string GetDeviceNameById(const DeviceId device_id);
+
  private:
   friend class GesturesPropFunctionsWrapper;
 

ui/ozone/public/input_controller.cc

@@ -36,6 +36,7 @@ class StubInputController : public InputController {
   void SetMouseSensitivity(int value) override;
   void SetPrimaryButtonRight(bool right) override;
   void SetTapToClickPaused(bool state) override;
+  void GetTouchDeviceStatus(const GetTouchDeviceStatusReply& reply) override;
   void DisableInternalTouchpad() override;
   void EnableInternalTouchpad() override;
   void DisableInternalKeyboardExceptKeys(
@@ -124,6 +125,11 @@ void StubInputController::SetTapToClickPaused(bool state) {
   NOTIMPLEMENTED();
 }
 
+void StubInputController::GetTouchDeviceStatus(
+    const GetTouchDeviceStatusReply& reply) {
+  reply.Run(scoped_ptr<std::string>(new std::string));
+}
+
 void StubInputController::DisableInternalTouchpad() {
   NOTIMPLEMENTED();
 }

ui/ozone/public/input_controller.h

@@ -6,7 +6,9 @@
 #define UI_OZONE_PUBLIC_INPUT_CONTROLLER_H_
 
 #include <set>
+#include <string>
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/ozone/ozone_export.h"
@@ -26,6 +28,9 @@ enum class DomCode;
 // script that is originally located at /opt/google/chrome/.
 class OZONE_EXPORT InputController {
  public:
+  typedef base::Callback<void(scoped_ptr<std::string>)>
+      GetTouchDeviceStatusReply;
+
   InputController() {}
   virtual ~InputController() {}
 
@@ -55,6 +60,9 @@ class OZONE_EXPORT InputController {
   virtual void SetMouseSensitivity(int value) = 0;
   virtual void SetPrimaryButtonRight(bool right) = 0;
 
+  // Touch log collection.
+  virtual void GetTouchDeviceStatus(const GetTouchDeviceStatusReply& reply) = 0;
+
   // Temporarily enable/disable Tap-to-click. Used to enhance the user
   // experience in some use cases (e.g., typing, watching video).
   virtual void SetTapToClickPaused(bool state) = 0;