No pointer captured when the pointer lock is applied

third_party/WebKit/Source/core/frame/WebFrameWidgetBase.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/frame/WebFrameWidgetBase.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/events/WebInputEventConversion.h"
 #include "core/exported/WebViewBase.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/VisualViewport.h"
 #include "core/frame/WebLocalFrameBase.h"
 #include "core/input/EventHandler.h"
 #include "core/page/DragActions.h"
 #include "core/page/DragController.h"
 #include "core/page/DragData.h"
 #include "core/page/DragSession.h"
+#include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/PointerLockController.h"
 #include "platform/UserGestureIndicator.h"
 #include "public/web/WebWidgetClient.h"
 
 namespace blink {
 
 namespace {
 
 // Helper to get LocalFrame* from WebLocalFrame*.
@@ skipping 200 matching lines @@
 WebViewBase* WebFrameWidgetBase::View() const {
   return ToWebLocalFrameBase(LocalRoot())->ViewImpl();
 }
 
 Page* WebFrameWidgetBase::GetPage() const {
   return View()->GetPage();
 }
 
 void WebFrameWidgetBase::DidAcquirePointerLock() {
   GetPage()->GetPointerLockController().DidAcquirePointerLock();
+
+  LocalFrame* focusedFrame = FocusedLocalFrameInWidget();
+  if (focusedFrame) {
+    focusedFrame->GetEventHandler().ReleaseMousePointerCapture();
+  }
 }
 
 void WebFrameWidgetBase::DidNotAcquirePointerLock() {
   GetPage()->GetPointerLockController().DidNotAcquirePointerLock();
 }
 
 void WebFrameWidgetBase::DidLosePointerLock() {
   pointer_lock_gesture_token_.Clear();
   GetPage()->GetPointerLockController().DidLosePointerLock();
 }
 
-void WebFrameWidgetBase::PointerLockMouseEvent(const WebInputEvent& event) {
+// TODO(665924): Remove direct dispatches of mouse events from
+// PointerLockController, instead passing them through EventHandler.
+void WebFrameWidgetBase::PointerLockMouseEvent(

[scheib, 2017/05/26 05:44:12]

NOTE: I'm not familiar enough with this code, and complexity is high, so I can't
vouch for it.

+    const WebCoalescedInputEvent& coalesced_event) {

[Navid Zolghadr, 2017/05/25 16:59:15]

I love the idea that you changed this to WebCoalescedInputEvent. We should be
using it in pointermoves being sent during pointerlock later to put the
coalesced events in there. So definitely keep this one.

nit: But there is no need to create and pass transformed_coalesced_events to
focusedFrame->GetEventHandler().ProcessPendingPointerCapture(). In there you can
just pass an empty vector (i.e. Vector<WebMouseEvent>()) to the
pointer_event_factory_.Create(...) as got/lostpointercapture events will never
have coalecsed events.

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

Done.

+  const WebInputEvent& input_event = coalesced_event.Event();
+  const WebMouseEvent& mouse_event =
+      static_cast<const WebMouseEvent&>(input_event);
+  WebMouseEvent transformed_event = TransformWebMouseEvent(
+      ToWebLocalFrameBase(LocalRoot())->GetFrameView(), mouse_event);
+
+  LocalFrame* focusedFrame = FocusedLocalFrameInWidget();
+  if (focusedFrame) {
+    Vector<WebMouseEvent> transformed_coalesced_events =
+        TransformWebMouseEventVector(
+            ToWebLocalFrameBase(LocalRoot())->GetFrameView(),
+            coalesced_event.GetCoalescedEventsPointers());
+    focusedFrame->GetEventHandler().ProcessPendingPointerCapture(
+        transformed_event, transformed_coalesced_events);
+  }
+
   std::unique_ptr<UserGestureIndicator> gesture_indicator;
   AtomicString event_type;
-  switch (event.GetType()) {
+  switch (input_event.GetType()) {
     case WebInputEvent::kMouseDown:
       event_type = EventTypeNames::mousedown;
       if (!GetPage() || !GetPage()->GetPointerLockController().GetElement())
         break;
       gesture_indicator = WTF::WrapUnique(new UserGestureIndicator(
           DocumentUserGestureToken::Create(&GetPage()
                                                 ->GetPointerLockController()
                                                 .GetElement()
                                                 ->GetDocument(),
                                            UserGestureToken::kNewGesture)));
       pointer_lock_gesture_token_ = gesture_indicator->CurrentToken();
       break;
     case WebInputEvent::kMouseUp:
       event_type = EventTypeNames::mouseup;
       gesture_indicator = WTF::WrapUnique(
           new UserGestureIndicator(pointer_lock_gesture_token_.Release()));
       break;
     case WebInputEvent::kMouseMove:
       event_type = EventTypeNames::mousemove;
       break;
     default:
       NOTREACHED();
   }
 
-  const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(event);
-
   if (GetPage()) {
-    WebMouseEvent transformed_event = TransformWebMouseEvent(
-        ToWebLocalFrameBase(LocalRoot())->GetFrameView(), mouse_event);
     GetPage()->GetPointerLockController().DispatchLockedMouseEvent(
         transformed_event, event_type);
   }
 }
 
+LocalFrame* WebFrameWidgetBase::FocusedLocalFrameInWidget() const {
+  LocalFrame* frame = GetPage()->GetFocusController().FocusedFrame();
+  return (frame && frame->LocalFrameRoot() == ToCoreFrame(LocalRoot()))
+             ? frame
+             : nullptr;
+}
+
 }  // namespace blink