No pointer captured when the pointer lock is applied

third_party/WebKit/Source/core/input/PointerEventManager.cpp

 // Copyright 2016 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 "core/input/PointerEventManager.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
@@ skipping 589 matching lines @@
     SetNodeUnderPointer(pointer_event, pending_pointer_capture_target);
     DispatchPointerEvent(pending_pointer_capture_target,
                          pointer_event_factory_.CreatePointerCaptureEvent(
                              pointer_event, EventTypeNames::gotpointercapture));
     pointer_capture_target_.Set(pointer_id, pending_pointer_capture_target);
   } else {
     pointer_capture_target_.erase(pointer_id);
   }
 }
 
+void PointerEventManager::ProcessPendingPointerCapture(
+    const WebMouseEvent& mouse_event,
+    const Vector<WebMouseEvent>& coalesced_events) {
+  PointerEvent* pointer_event = pointer_event_factory_.Create(
+      EventTypeNames::mousemove, mouse_event, coalesced_events,
+      frame_->GetDocument()->domWindow());
+  ProcessPendingPointerCapture(pointer_event);
+}
+
 void PointerEventManager::RemoveTargetFromPointerCapturingMapping(
     PointerCapturingMap& map,
     const EventTarget* target) {
   // We could have kept a reverse mapping to make this deletion possibly
   // faster but it adds some code complication which might not be worth of
   // the performance improvement considering there might not be a lot of
   // active pointer or pointer captures at the same time.
   PointerCapturingMap tmp = map;
   for (PointerCapturingMap::iterator it = tmp.begin(); it != tmp.end(); ++it) {
     if (it->value == target)
@@ skipping 39 matching lines @@
   // the capture. Note that this might be different from
   // |m_pointercaptureTarget|. |m_pointercaptureTarget| holds the element
   // that had the capture until now and has been receiving the pointerevents
   // but |m_pendingPointerCaptureTarget| indicated the element that gets the
   // very next pointer event. They will be the same if there was no change in
   // capturing of a particular |pointerId|. See crbug.com/614481.
   if (pending_pointer_capture_target_.at(pointer_id) == target)
     ReleasePointerCapture(pointer_id);
 }
 
+void PointerEventManager::ReleaseMousePointerCapture() {
+  ReleasePointerCapture(PointerEventFactory::kMouseId);
+}
+
 bool PointerEventManager::HasPointerCapture(int pointer_id,
                                             const EventTarget* target) const {
   return pending_pointer_capture_target_.at(pointer_id) == target;
 }
 
 bool PointerEventManager::HasProcessedPointerCapture(
     int pointer_id,
     const EventTarget* target) const {
   return pointer_capture_target_.at(pointer_id) == target;
 }
@@ skipping 38 matching lines @@
     if (first_id > unique_touch_event_id)
       return false;
     touch_ids_for_canceled_pointerdowns_.TakeFirst();
     if (first_id == unique_touch_event_id)
       return true;
   }
   return false;
 }
 
 }  // namespace blink