Correctly release the touch events on Lenovo Horizon device

ui/views/win/hwnd_message_handler.h

 // 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.
 
 #ifndef UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_
 #define UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_
 
 #include <windows.h>
 
-#include <set>
+#include <array>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/win_util.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/base/win/window_event_target.h"
 #include "ui/events/event.h"
+#include "ui/events/gesture_detection/motion_event.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/sequential_id_generator.h"
 #include "ui/gfx/win/window_impl.h"
 #include "ui/views/ime/input_method_delegate.h"
 #include "ui/views/views_export.h"
 
 namespace gfx {
 class Canvas;
 class ImageSkia;
 class Insets;
@@ skipping 167 matching lines @@
   void set_use_system_default_icon(bool use_system_default_icon) {
     use_system_default_icon_ = use_system_default_icon;
   }
 
   void SetFullscreen(bool fullscreen);
 
   // Updates the window style to reflect whether it can be resized or maximized.
   void SizeConstraintsChanged();
 
  private:
-  typedef std::set<DWORD> TouchIDs;
+  FRIEND_TEST_ALL_PREFIXES(HWNDMessageHandler, TestCorrectTouchInputList);
+  FRIEND_TEST_ALL_PREFIXES(HWNDMessageHandler, TestMissingTouchRelease);
+  FRIEND_TEST_ALL_PREFIXES(HWNDMessageHandler, TestMissingTouchPress);
+  FRIEND_TEST_ALL_PREFIXES(HWNDMessageHandler, TestMissingTouchPressAndRelease);
+
+  // We use InTouchList self-defined type to specify if the touch point from
+  // last message is in the current message or not.
+  enum class InTouchList { NotPresent, InPreviousMessage, InCurrentMessage };
+
+  // We need the touch location to release a touch point which is not in the
+  // current message.
+  struct TouchPoint {
+    gfx::Point location;
+    InTouchList in_touch_list;
+
+    TouchPoint() : in_touch_list(InTouchList::NotPresent) {}
+  };
+
+  using TouchEvents = std::vector<ui::TouchEvent>;
+  using TouchPointArray =
+      std::array<TouchPoint, ui::MotionEvent::MAX_TOUCH_POINT_COUNT>;
 
   // Overridden from internal::InputMethodDelegate:
   void DispatchKeyEventPostIME(const ui::KeyEvent& key) override;
 
   // Overridden from WindowImpl:
   HICON GetDefaultWindowIcon() const override;
   HICON GetSmallWindowIcon() const override;
   LRESULT OnWndProc(UINT message, WPARAM w_param, LPARAM l_param) override;
 
   // Overridden from WindowEventTarget
@@ skipping 229 matching lines @@
   LRESULT OnSetIcon(UINT size_type, HICON new_icon);
   LRESULT OnSetText(const wchar_t* text);
   void OnSettingChange(UINT flags, const wchar_t* section);
   void OnSize(UINT param, const gfx::Size& size);
   void OnSysCommand(UINT notification_code, const gfx::Point& point);
   void OnThemeChanged();
   LRESULT OnTouchEvent(UINT message, WPARAM w_param, LPARAM l_param);
   void OnWindowPosChanging(WINDOWPOS* window_pos);
   void OnWindowPosChanged(WINDOWPOS* window_pos);
 
-  typedef std::vector<ui::TouchEvent> TouchEvents;
   // Helper to handle the list of touch events passed in. We need this because
   // touch events on windows don't fire if we enter a modal loop in the context
   // of a touch event.
   void HandleTouchEvents(const TouchEvents& touch_events);
 
   // Resets the flag which indicates that we are in the context of a touch down
   // event.
-  void ResetTouchDownContext();
+  void DecrementTouchDownContext(int decrement);
 
   // Helper to handle mouse events.
   // The |message|, |w_param|, |l_param| parameters identify the Windows mouse
   // message and its parameters respectively.
   // The |track_mouse| parameter indicates if we should track the mouse.
   LRESULT HandleMouseEventInternal(UINT message,
                                    WPARAM w_param,
                                    LPARAM l_param,
                                    bool track_mouse);
 
   // Returns true if the mouse message passed in is an OS synthesized mouse
   // message.
   // |message| identifies the mouse message.
   // |message_time| is the time when the message occurred.
   // |l_param| indicates the location of the mouse message.
   bool IsSynthesizedMouseMessage(unsigned int message,
                                  int message_time,
                                  LPARAM l_param);
 
   // Provides functionality to transition a frame to DWM.
   void PerformDwmTransition();
 
+  void PrepareTouchEventList(TOUCHINPUT input[],
+                             int num_points,
+                             TouchEvents* touch_events);
+
+  // From one WM_TOUCH message, we will generate corresponding touch events.
+  void GenerateTouchEvent(DWORD input_dwID,
+                          const gfx::Point& point_location,
+                          ui::EventType touch_event_type,
+                          TouchEvents* touch_events);
+
+  // It will release the touch points which are no longer in the current message
+  // because the messages are sent inconsistently, and also set the touch points
+  // we have seen in the current message to be InPreviousMessage.
+  void UpdateTouchPointStates(TouchEvents* touch_events);
+
+  const TouchPointArray& touch_id_list() const { return touch_id_list_; }
+
   HWNDMessageHandlerDelegate* delegate_;
 
   scoped_ptr<FullscreenHandler> fullscreen_handler_;
 
   // Set to true in Close() and false is CloseNow().
   bool waiting_for_close_now_;
 
   bool remove_standard_frame_;
 
   bool use_system_default_icon_;
@@ skipping 13 matching lines @@
 
   // The flags currently being used with TrackMouseEvent to track mouse
   // messages. 0 if there is no active tracking. The value of this member is
   // used when tracking is canceled.
   DWORD active_mouse_tracking_flags_;
 
   // Set to true when the user presses the right mouse button on the caption
   // area. We need this so we can correctly show the context menu on mouse-up.
   bool is_right_mouse_pressed_on_caption_;
 
-  // The set of touch devices currently down.
-  TouchIDs touch_ids_;
-
   // ScopedRedrawLock ----------------------------------------------------------
 
   // Represents the number of ScopedRedrawLocks active against this widget.
   // If this is greater than zero, the widget should be locked against updates.
   int lock_updates_count_;
 
   // Window resizing -----------------------------------------------------------
 
   // When true, this flag makes us discard incoming SetWindowPos() requests that
   // only change our position/size.  (We still allow changes to Z-order,
@@ skipping 78 matching lines @@
   long last_mouse_hwheel_time_;
 
   // On Windows Vista and beyond, if we are transitioning from custom frame
   // to Aero(glass) we delay setting the DWM related properties in full
   // screen mode as DWM is not supported in full screen windows. We perform
   // the DWM related operations when the window comes out of fullscreen mode.
   // This member variable is set to true if the window is transitioning to
   // glass. Defaults to false.
   bool dwm_transition_desired_;
 
+  // The WM_TOUCH message at times sends inconsistent number of touch pointers,
+  // so we keep the IDs of touch pointers we have seen from last message, and
+  // compare with the current message in order to release the ones which are not
+  // in the current list, or send a touchpress when we see a new touch point.
+  // The index of the array is the touch_ID.
+  TouchPointArray touch_id_list_;
+
+  // Keep the count of the current active touch points.
+  int active_touch_point_count_;
+
   // A factory used to lookup appbar autohide edges.
   base::WeakPtrFactory<HWNDMessageHandler> autohide_factory_;
 
   // The factory used with BEGIN_SAFE_MSG_MAP_EX.
   base::WeakPtrFactory<HWNDMessageHandler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HWNDMessageHandler);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_