Fix ASSERT in Sky when dragging outside the window on linux

sky/engine/core/frame/NewEventHandler.cpp

 // Copyright 2015 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 "sky/engine/config.h"
 #include "sky/engine/core/frame/NewEventHandler.h"
 
 #include "sky/engine/core/dom/Document.h"
 #include "sky/engine/core/dom/NodeRenderingTraversal.h"
 #include "sky/engine/core/editing/Editor.h"
@@ skipping 151 matching lines @@
     // embedder regardless, so we set m_suppressNextCharEvent, will will prevent
     // us from dispatching the keypress event when we receive that Char event.
     if (handled && event.type == WebInputEvent::KeyDown)
         m_suppressNextCharEvent = true;
 
     return handled;
 }
 
 bool NewEventHandler::handlePointerDownEvent(const WebPointerEvent& event)
 {
+    // In principle, we shouldn't get another pointer down for the same
+    // pointer ID, but for mice, we don't get a pointer cancel when you
+    // drag outside the window frame on Linux. For now, send the pointer
+    // cancel at this point.
+    if (event.kind == WebPointerEvent::Mouse
+        && m_targetForPointer.find(event.pointer) != m_targetForPointer.end()) {
+        WebPointerEvent fakeCancel = event;
+        fakeCancel.type = WebInputEvent::PointerCancel;
+        handlePointerCancelEvent(fakeCancel);
+    }
+
     ASSERT(m_targetForPointer.find(event.pointer) == m_targetForPointer.end());
     HitTestResult hitTestResult = performHitTest(positionForEvent(event));
     RefPtr<Node> target = targetForHitTestResult(hitTestResult);
     if (!target)
         return false;
     m_targetForPointer[event.pointer] = target;
     bool eventSwallowed = !dispatchPointerEvent(*target, event);
     // TODO(abarth): Set the target for the pointer to something determined when
     // dispatching the event.
     updateSelectionForPointerDown(hitTestResult, event);
     return eventSwallowed;
 }
 
 bool NewEventHandler::handlePointerUpEvent(const WebPointerEvent& event)
 {
-    RefPtr<Node> target = m_targetForPointer[event.pointer];
-    if (!target)
+    auto it = m_targetForPointer.find(event.pointer);
+    if (it == m_targetForPointer.end())
         return false;
-    m_targetForPointer.erase(event.pointer);
+    RefPtr<Node> target = it->second;
+    m_targetForPointer.erase(it);
+    ASSERT(target);
     bool eventSwallowed = !dispatchPointerEvent(*target, event);
     // When the user releases the primary pointer, we need to dispatch a tap
     // event to the common ancestor for where the pointer went down and where
     // it came up.
     if (!dispatchClickEvent(*target, event))
         eventSwallowed = true;
     return eventSwallowed;
 }
 
 bool NewEventHandler::handlePointerMoveEvent(const WebPointerEvent& event)
 {
-    RefPtr<Node> target = m_targetForPointer[event.pointer];
-    return target && dispatchPointerEvent(*target.get(), event);
+    auto it = m_targetForPointer.find(event.pointer);
+    if (it == m_targetForPointer.end())
+        return false;
+    RefPtr<Node> target = it->second;
+    ASSERT(target);
+    return dispatchPointerEvent(*target.get(), event);
 }
 
 bool NewEventHandler::handlePointerCancelEvent(const WebPointerEvent& event)
 {
-    RefPtr<Node> target = m_targetForPointer[event.pointer];
-    return target && dispatchPointerEvent(*target, event);
+    auto it = m_targetForPointer.find(event.pointer);
+    if (it == m_targetForPointer.end())
+        return false;
+    RefPtr<Node> target = it->second;
+    m_targetForPointer.erase(it);
+    ASSERT(target);
+    return dispatchPointerEvent(*target, event);
 }
 
 }