Fix software mirror mode on Ozone part 2/2

ui/events/devices/device_data_manager.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_DEVICES_DEVICE_DATA_MANAGER_H_
 #define UI_EVENTS_DEVICES_DEVICE_DATA_MANAGER_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 22 matching lines @@
   static DeviceDataManager* GetInstance();
   static bool HasInstance();
 
   void ClearTouchTransformerRecord();
   void UpdateTouchInfoForDisplay(int64_t display_id,
                                  unsigned int touch_device_id,
                                  const gfx::Transform& touch_transformer);
   void ApplyTouchTransformer(unsigned int touch_device_id, float* x, float* y);
   int64_t GetDisplayForTouchDevice(unsigned int touch_device_id) const;
 
+  // Sets/Gets the display that touches from |touch_device_id| should be
+  // redirected to.
+  void SetTargetDisplayForTouchDevice(unsigned int touch_device_id,
+                                      int64_t target_display_id);
+  int64_t GetTargetDisplayForTouchDevice(unsigned int touch_device_id);

[sadrul, 2015/03/02 16:56:18]

How is this different from GetDisplayForTouchDevice()?

[pkotwicz, 2015/03/02 17:55:53]

In mirror mode (either software or hardware):
- GetDisplayForTouchDevice() returns the display that the touch device is on.
This is a different display for each touch device.
- GetTargetDisplayForTouchDevice() returns the display that touches should be
forwarded to. This is the same display for all touch devices.

GetDisplayForTouchDevice() still exists for the sake of
DeviceDataManagerX11::TouchEventNeedsCalibrate(). We could remove the need for
GetDisplayForTouchDevice() by checking whether the touch device (instead of the
display) is internal or external. This is what Ozone does in
TouchEventConverterEvdev.

[sadrul, 2015/03/03 04:43:09]

We should have just one of these functions. Having two
pretty-similar-but-slightly-different information here is confusing.
Why doesn't Display have this information? e.g. in addition to a
ui::MultipleDisplayState, Display could have a |mirror_display_| id that points
to the mirroring display. That feels like the better place for this information.

[oshima, 2015/03/04 00:54:36]

How about using GetDisplayForTouchDevice() for all logical mapping,
and then let ash tell the device manager which device needs calibration? (looks
like TouchTransformerController can do this) This way, we don't need
two-pretty-similar-but-slightly-different functions, and can keep software
mirroring logic inside ash.
 

[sadrul, 2015/03/05 11:07:14]

I think that sounds good, yeah.

+
   void UpdateTouchRadiusScale(unsigned int touch_device_id, double scale);
   void ApplyTouchRadiusScale(unsigned int touch_device_id, double* radius);
 
   const std::vector<TouchscreenDevice>& touchscreen_devices() const {
     return touchscreen_devices_;
   }
 
   const std::vector<KeyboardDevice>& keyboard_devices() const {
     return keyboard_devices_;
   }
@@ skipping 18 matching lines @@
 
  private:
   static DeviceDataManager* instance_;
 
   bool IsTouchDeviceIdValid(unsigned int touch_device_id) const;
 
   double touch_radius_scale_map_[kMaxDeviceNum];
 
   // Table to keep track of which display id is mapped to which touch device.
   int64_t touch_device_to_display_map_[kMaxDeviceNum];
+  // Index table to find the target display id for a touch device.
+  int64_t touch_device_to_target_display_map_[kMaxDeviceNum];
   // Index table to find the TouchTransformer for a touch device.
   gfx::Transform touch_device_transformer_map_[kMaxDeviceNum];
 
   std::vector<TouchscreenDevice> touchscreen_devices_;
   std::vector<KeyboardDevice> keyboard_devices_;
 
   ObserverList<InputDeviceEventObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceDataManager);
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_DEVICES_DEVICE_DATA_MANAGER_H_