blob: f72e1e05889b77de226ecc13bf2b861ef1c00b2f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
// 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.
#include "content/renderer/mouse_lock_dispatcher.h"
#include "base/logging.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
namespace content {
MouseLockDispatcher::MouseLockDispatcher() : mouse_locked_(false),
pending_lock_request_(false),
pending_unlock_request_(false),
unlocked_by_target_(false),
target_(NULL) {
}
MouseLockDispatcher::~MouseLockDispatcher() {
}
bool MouseLockDispatcher::LockMouse(LockTarget* target) {
if (MouseLockedOrPendingAction())
return false;
pending_lock_request_ = true;
target_ = target;
SendLockMouseRequest(unlocked_by_target_);
unlocked_by_target_ = false;
return true;
}
void MouseLockDispatcher::UnlockMouse(LockTarget* target) {
if (target && target == target_ && !pending_unlock_request_) {
pending_unlock_request_ = true;
// When a target application voluntarily unlocks the mouse we permit
// relocking the mouse silently and with no user gesture requirement.
// Check that the lock request is not currently pending and not yet
// accepted by the browser process before setting |unlocked_by_target_|.
if (!pending_lock_request_)
unlocked_by_target_ = true;
SendUnlockMouseRequest();
}
}
void MouseLockDispatcher::OnLockTargetDestroyed(LockTarget* target) {
if (target == target_) {
UnlockMouse(target);
target_ = NULL;
}
}
bool MouseLockDispatcher::IsMouseLockedTo(LockTarget* target) {
return mouse_locked_ && target_ == target;
}
bool MouseLockDispatcher::WillHandleMouseEvent(
const blink::WebMouseEvent& event) {
if (mouse_locked_ && target_)
return target_->HandleMouseLockedInputEvent(event);
return false;
}
void MouseLockDispatcher::OnLockMouseACK(bool succeeded) {
DCHECK(!mouse_locked_ && pending_lock_request_);
mouse_locked_ = succeeded;
pending_lock_request_ = false;
if (pending_unlock_request_ && !succeeded) {
// We have sent an unlock request after the lock request. However, since
// the lock request has failed, the unlock request will be ignored by the
// browser side and there won't be any response to it.
pending_unlock_request_ = false;
}
LockTarget* last_target = target_;
if (!succeeded)
target_ = NULL;
// Callbacks made after all state modification to prevent reentrant errors
// such as OnLockMouseACK() synchronously calling LockMouse().
if (last_target)
last_target->OnLockMouseACK(succeeded);
}
void MouseLockDispatcher::OnMouseLockLost() {
DCHECK(mouse_locked_ && !pending_lock_request_);
mouse_locked_ = false;
pending_unlock_request_ = false;
LockTarget* last_target = target_;
target_ = NULL;
// Callbacks made after all state modification to prevent reentrant errors
// such as OnMouseLockLost() synchronously calling LockMouse().
if (last_target)
last_target->OnMouseLockLost();
}
} // namespace content
|
