ozone: evdev: Add gesture property provider

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

+// 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.
+
+#ifndef UI_EVENTS_OZONE_EVDEV_LIBGESTURES_GLUE_GESTURE_PROPERTY_PROVIDER_H_
+#define UI_EVENTS_OZONE_EVDEV_LIBGESTURES_GLUE_GESTURE_PROPERTY_PROVIDER_H_
+
+#include <gestures/gestures.h>
+#include <libevdev/libevdev.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/containers/hash_tables.h"
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "base/memory/scoped_vector.h"
+#include "ui/events/ozone/evdev/events_ozone_evdev_export.h"
+
+namespace ui {
+
+class GesturesPropFunctionsWrapper;
+class GestureInterpreterLibevdevCros;
+
+// A struct holding device properties that are useful when interacting with
+// the gestures lib.
+struct GestureDeviceProperties {
+  int area_left;
+  int area_right;
+  int area_top;
+  int area_bottom;
+  int res_y;
+  int res_x;
+  int orientation_minimum;
+  int orientation_maximum;
+  GesturesPropBool raw_passthrough;
+  GesturesPropBool dump_debug_log;
+};
+
+// Provide the interface to access the CrOS gesture library properties.
+// It maintains the property data for all input devices that runs with
+// the gesture library.
+//
+// The class also parses the configuration files on the system to
+// initialize the specified property values. The configuration files are
+// currently in the xorg-conf format so that they can be shared with non-Ozone
+// builds.
+class EVENTS_OZONE_EVDEV_EXPORT GesturePropertyProvider {
+ public:
+  // Device types.
+  enum DeviceType {
+    DT_MOUSE,
+    DT_TOUCHPAD,
+    DT_TOUCHSCREEN,
+    DT_MULTITOUCH,
+    DT_MULTITOUCH_MOUSE,
+    DT_ALL,
+  };
+
+  // Property types.
+  enum PropertyType {
+    PT_INT,
+    PT_SHORT,
+    PT_BOOL,
+    PT_STRING,
+    PT_REAL,
+  };
+
+  // Pointer that leads to the device info.
+  typedef Evdev* DevicePtr;
+
+  // The device ids are only maintained by GesturePropertyProvider to identify
+  // the input devices that uses the gesture lib and are not to be confused with
+  // the Evdev input node id, for example.
+  typedef int DeviceId;
+
+  GesturePropertyProvider();
+  ~GesturePropertyProvider();
+
+  // Get a list of device ids that matches a device type.
+  void GetDeviceIdsByType(const DeviceType type,
+                          std::vector<DeviceId>* device_ids);
+
+  // Property access functions for other classes in Chrome, e.g., the
+  // preferences page. Note that the values in preferences are not synced with
+  // the ones here in realtime - they are only applied from the preference
+  // side in a single way once appropriate (e.g., when the user clicked "OK").
+
+  // Get the property type.
+  bool GetPropertyType(const DeviceId device_id,
+                       const std::string& name,
+                       PropertyType* type) {
+    return GetProperty(device_id, name, type, NULL, NULL);
+  }
+
+  // Get the property value.
+  bool GetIntProperty(const DeviceId device_id,
+                      const std::string& name,
+                      int* val,
+                      size_t* count) {
+    return GetProperty(device_id, name, NULL, val, count);
+  }
+  bool GetShortProperty(const DeviceId device_id,
+                        const std::string& name,
+                        short* val,
+                        size_t* count) {
+    return GetProperty(device_id, name, NULL, val, count);
+  }
+  bool GetBoolProperty(const DeviceId device_id,
+                       const std::string& name,
+                       bool* val,
+                       size_t* count) {
+    return GetProperty(device_id, name, NULL, val, count);
+  }
+  bool GetStringProperty(const DeviceId device_id,
+                         const std::string& name,
+                         std::string* val,
+                         size_t* count) {
+    return GetProperty(device_id, name, NULL, val, count);
+  }
+  bool GetDoubleProperty(const DeviceId device_id,
+                         const std::string& name,
+                         double* val,
+                         size_t* count) {
+    return GetProperty(device_id, name, NULL, val, count);
+  }
+
+  // Set the property value. Note that one can't change the property type/count
+  // which are both fixed since the property was created. Also, one can't create
+  // new properties with the function. A property can only be created with
+  // creators in GesturesPropFunctionsWrapper.
+  bool SetIntProperty(const DeviceId device_id,
+                      const std::string& name,
+                      const int* val) {
+    return SetProperty(device_id, name, val);
+  }
+  bool SetShortProperty(const DeviceId device_id,
+                        const std::string& name,
+                        const short* val) {
+    return SetProperty(device_id, name, val);
+  }
+  bool SetBoolProperty(const DeviceId device_id,
+                       const std::string& name,
+                       const bool* val) {
+    return SetProperty(device_id, name, val);
+  }
+  bool SetStringProperty(const DeviceId device_id,
+                         const std::string& name,
+                         const char* val);
+  bool SetStringProperty(const DeviceId device_id,
+                         const std::string& name,
+                         const std::string* val) {
+    return SetProperty(device_id, name, val);
+  }
+  bool SetDoubleProperty(const DeviceId device_id,
+                         const std::string& name,
+                         const double* val) {
+    return SetProperty(device_id, name, val);
+  }
+
+ private:
+  friend class GesturesPropFunctionsWrapper;
+
+  // Base class for device match criterias in conf files.
+  // Check the xorg-conf spec for more detailed information.
+  class MatchCriteria {
+   public:
+    MatchCriteria(const std::string& arg);
+    virtual ~MatchCriteria() {};
+    virtual bool Match(DevicePtr device) = 0;
+   protected:
+    std::vector<std::string> args_;
+  };
+
+  // Trick for converting strings to class names.
+  template <typename T>
+  MatchCriteria* AllocateMatchCriteria(const std::string& arg) {

[spang, 2014/09/26 15:15:32]

Could you move this to the cc file? There shouldn't be anything in the header
file that doesn't need to be there. Looks like they can even be inside an
anonymous namespace.

[Shecky Lin, 2014/10/03 03:58:55]

I couldn't made it in an anonymous namespace because I need to use these types
in the function definition and also some variables. Forward declaration can't
work with anonymous namespace. I put them under namespace internal instead as
this seems to be a convention in the Chromium codebase.

+    return new T(arg);
+  }
+  typedef std::map<std::string,
+                   MatchCriteria* (ui::GesturePropertyProvider::*)(
+                       const std::string&)> MatchCriteriaCreatorMap;
+
+  // Match a device based on its evdev name string.
+  class MatchProduct : public MatchCriteria {

[spang, 2014/09/26 15:15:32]

Move all matchers to .cc file.

[Shecky Lin, 2014/10/03 03:58:55]

Done.

+   public:
+    MatchProduct(const std::string& arg);
+    virtual ~MatchProduct() {};
+    virtual bool Match(DevicePtr device);
+  };
+
+  // Math a device based on its device node path.
+  class MatchDevicePath : public MatchCriteria {
+   public:
+    MatchDevicePath(const std::string& arg);
+    virtual ~MatchDevicePath() {};
+    virtual bool Match(DevicePtr device);
+  };
+
+  // Math a USB device based on its USB vid and pid.
+  // Mostly used for external mice and touchpads.
+  class MatchUSBID : public MatchCriteria {
+   public:
+    MatchUSBID(const std::string& arg);
+    virtual ~MatchUSBID() {};
+    virtual bool Match(DevicePtr device);
+   private:
+    bool IsValidPattern(const std::string &pattern);
+    std::vector<std::string> vid_patterns_;
+    std::vector<std::string> pid_patterns_;
+  };
+
+  // Generic base class for device type math criteria.
+  class MatchDeviceType : public MatchCriteria {
+   public:
+    MatchDeviceType(const std::string& arg);
+    virtual ~MatchDeviceType() {};
+    virtual bool Match(DevicePtr device) = 0;
+   protected:
+    bool value_;
+    bool is_valid_;
+  };
+
+  // Check if a device is a pointer device.
+  class MatchIsPointer : public MatchDeviceType {
+   public:
+    MatchIsPointer(const std::string& arg);
+    virtual ~MatchIsPointer() {};
+    virtual bool Match(DevicePtr device);
+  };
+
+  // Check if a device is a touchpad.
+  class MatchIsTouchpad : public MatchDeviceType {
+   public:
+    MatchIsTouchpad(const std::string& arg);
+    virtual ~MatchIsTouchpad() {};
+    virtual bool Match(DevicePtr device);
+  };
+
+  // Check if a device is a touchscreen.
+  class MatchIsTouchscreen : public MatchDeviceType {
+   public:
+    MatchIsTouchscreen(const std::string& arg);
+    virtual ~MatchIsTouchscreen() {};
+    virtual bool Match(DevicePtr device);
+  };
+
+  // Struct for sections in xorg conf files.
+  struct ConfigurationSection {
+    bool Match(DevicePtr device);
+    std::string identifier;
+    ScopedVector<MatchCriteria> criterias;
+    ScopedVector<GesturesProp> properties;
+  };
+
+  // Mapping table from a dev pointer to its device id.
+  typedef std::map<DevicePtr, DeviceId> DeviceIdMap;
+
+  // Mapping table from a property name to its corresponding GesturesProp
+  // object pointer.
+  typedef base::hash_map<std::string, GesturesProp*> PropertyMap;
+  typedef base::ScopedPtrHashMap<std::string, GesturesProp> ScopedPropertyMap;
+
+  // Mapping table from a dev id to its property map.
+  typedef base::ScopedPtrHashMap<DeviceId, PropertyMap> ScopedDevicePropertyMap;
+  typedef base::ScopedPtrHashMap<DeviceId, ScopedPropertyMap>
+      ScopedDeviceScopedPropertyMap;
+
+  // Populate the match criteria creators in the creator map.
+  void RegisterMatchCriterias();
+
+  // Check if a device falls into one device type category.
+  static bool IsDeviceOfType(DevicePtr device, const DeviceType type);

[spang, 2014/09/26 15:15:32]

All of these private statics should be moved to the .cc file unless they need
access to class internals.

So move IsDeviceOfType, kMaxDeviceNum, IsMatch*, ParseBooleanKeyword.

[Shecky Lin, 2014/10/03 03:58:55]

Done.

+
+  // Get the device id of a device pointer. May create a new one if not
+  // currently mapped.
+  DeviceId GetDeviceId(DevicePtr dev, const bool do_create = false);

[spang, 2014/09/26 15:15:32]

Remove the default argument (they aren't allowed by the style guide).

[Shecky Lin, 2014/10/03 03:58:55]

Done.

+
+  // Core function of setting/getting property values.
+  bool SetProperty(const DeviceId device_id,
+                   const std::string& name,
+                   const void* val);
+  bool GetProperty(const DeviceId device_id,
+                   const std::string& name,
+                   PropertyType* type,
+                   void* val,
+                   size_t* count);
+
+  // Called by functions in GesturesPropFunctionsWrapper to manipulate
+  // properties. Note these functions do not new/delete the GesturesProp
+  // pointers. It is caller's responsibility to manage them.
+  void AddProperty(const DeviceId device_id,
+                   const std::string& name,
+                   GesturesProp* prop);
+  void DeleteProperty(const DeviceId device_id, const std::string& name);
+
+  // Check if a property exists for a device. Return if it is found.
+  GesturesProp* FindProperty(const DeviceId device_id, const std::string& name);
+
+  // Get the default value of a property based on the configuration files.
+  GesturesProp* GetDefaultProperty(const DeviceId device_id,
+                                   const std::string& name);
+
+  // The device configuration files are parsed and stored in the memory upon
+  // Chrome starts. The default property values are then applied to each device
+  // when it is attached/detected.
+  void LoadDeviceConfigurations();
+
+  // Parse a xorg-conf file. We ignore all sections other than InputClass.
+  // Check the xorg-conf spec for more infomation about its format.
+  void ParseXorgConfFile(const std::string& content);
+
+  // Check if a match criteria is currently implemented. Note that we didn't
+  // implemented all of them as some are inapplicable in the non-X world.
+  static bool IsMatchTypeSupported(const std::string& match_type);
+
+  // Check if a match criteria is a device type one.
+  static bool IsMatchDeviceType(const std::string& match_type);
+
+  // Create a match criteria.
+  MatchCriteria* CreateMatchCriteria(const std::string& match_type,
+                                     const std::string& arg);
+
+  // Create a property that comes from the conf files.
+  GesturesProp* CreateDefaultProperty(const std::string& name,
+                                      const std::string& value);
+
+  // Parse a boolean value keyword (e.g., on/off, true/false).
+  static int ParseBooleanKeyword(const std::string& value);
+
+  // Setup default property values for a newly found device.
+  void SetupDefaultProperties(const DeviceId device_id, DevicePtr dev);
+
+  // Max number of devices that we track.
+  static const DeviceId kMaxDeviceNum = 0xffff;
+
+  // A map that stores the match criteria creators.
+  MatchCriteriaCreatorMap match_criteria_map_;
+
+  // An incremental counter of the next device id to be used for mapping.
+  DeviceId device_id_counter_;
+
+  // Map of device ids.
+  DeviceIdMap device_ids_map_;
+
+  // Array of property maps indexed by their respective device ids. Owns all the
+  // GesturesProp objects in it.
+  ScopedDeviceScopedPropertyMap properties_maps_;
+
+  // Same as properties_maps_, but loaded with only values specified in the
+  // configuration files. Will be applied when a property of the same name is
+  // created. Note that it only references the properties in configurations_ and
+  // doesn't own any GesturesProp by itself.
+  ScopedDevicePropertyMap default_properties_maps_;
+
+  // A vector of parsed sections in configuration files. Owns MatchCriterias,
+  // GesturesProps and ConfigurationSections in it.
+  ScopedVector<ConfigurationSection> configurations_;
+
+  DISALLOW_COPY_AND_ASSIGN(GesturePropertyProvider);
+};
+
+// Wrapper of GesturesProp related functions. We group them together so that we
+// can friend them all at once.
+class GesturesPropFunctionsWrapper {
+ public:
+  // Property provider interface implementation.
+  //
+  // These functions will create a GesturesProp object that can link back to the
+  // memory that holds the real value, which is often declared in the gesture
+  // lib.
+  static GesturesProp* CreateInt(void*, const char*, int*, size_t, const int*);
+  static GesturesProp* CreateShort(void*,
+                                   const char*,
+                                   short*,
+                                   size_t,
+                                   const short*);
+  static GesturesProp* CreateBool(void*,
+                                  const char*,
+                                  GesturesPropBool*,
+                                  size_t,
+                                  const GesturesPropBool*);
+
+  // String GestureProps needs special care due to the use of const char* in the
+  // gesture lib. Its argument list is also different from numeric properties.
+  static GesturesProp* CreateString(void*,
+                                    const char*,
+                                    const char**,
+                                    const char*);
+
+  static GesturesProp* CreateReal(void*,
+                                  const char*,
+                                  double*,
+                                  size_t,
+                                  const double*);
+
+  // Set the handlers to call when a property is accessed.
+  static void RegisterHandlers(void*,
+                               GesturesProp*,
+                               void*,
+                               GesturesPropGetHandler,
+                               GesturesPropSetHandler);
+
+  // Free a property.
+  static void Free(void*, GesturesProp*);
+
+  // Initialize hardware-related device properties which will be used in the
+  // gesture lib.
+  static bool InitializeDeviceProperties(void*, GestureDeviceProperties* props);
+
+ private:
+  // Property helper functions.
+  // Core function for creating properties in GesturePropertyProvider.
+  template <typename T>
+  static GesturesProp* Create(void*,
+                              const char*,
+                              GesturePropertyProvider::PropertyType,
+                              T*,
+                              size_t);
+
+  // Template function for creating numeric GestureProps (e.g., int, short,
+  // double). String property doesn't use this.
+  template <typename T, GesturePropertyProvider::PropertyType type>
+  static GesturesProp* CreateProperty(void*, const char*, T*, size_t, const T*);
+
+  static GesturesProp* CreateIntSingle(void*, const char*, int*, int);
+  static GesturesProp* CreateBoolSingle(void*,
+                                        const char*,
+                                        GesturesPropBool*,
+                                        GesturesPropBool);
+
+  // Routines to get the device pointer and the property provider from the
+  // GestureInterpreterLibevdevCros pointer.
+  static GesturePropertyProvider* GetPropertyProvider(void*);
+  static GesturePropertyProvider::DevicePtr GetDevicePointer(void*);
+};
+
+extern const GesturesPropProvider kGesturePropProvider;
+
+}  // namspace ui
+
+#endif  // UI_EVENTS_OZONE_EVDEV_LIBGESTURES_GLUE_GESTURE_PROPERTY_PROVIDER_H_