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 536 matching lines @@
     *pending_pointer_capture_target = pending_pointercapture_target_temp;
 
   return pointer_capture_target_temp != pending_pointercapture_target_temp;
 }
 
 EventTarget* PointerEventManager::ProcessCaptureAndPositionOfPointerEvent(
     PointerEvent* pointer_event,
     EventTarget* hit_test_target,
     const String& canvas_region_id,
     const WebMouseEvent& mouse_event,
     bool send_mouse_event) {

[mustaq, 2017/05/26 14:56:19]

A clean-up request: the last two parameters should be replaced by a single
WebMouseEvent pointer which defaults to null.

   ProcessPendingPointerCapture(pointer_event);
 
   PointerCapturingMap::const_iterator it =
       pointer_capture_target_.find(pointer_event->pointerId());
   if (EventTarget* pointercapture_target =
           (it != pointer_capture_target_.end()) ? it->value : nullptr)
     hit_test_target = pointercapture_target;
 
   SetNodeUnderPointer(pointer_event, hit_test_target);
   if (send_mouse_event) {
@@ skipping 33 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(

[mustaq, 2017/05/26 14:56:19]

The existing method with the same name is wrapped here for a particular purpose,
so let's make it clear from the name here.  May be
|ProcessPendingPointerCaptureForPointerLock|?

Also, as Navid suggested, drop the |coalesced_events| parameter and create an
empty vector when calling |Create()| here.

[lanwei, 2017/05/29 18:30:07]

Done.

+    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