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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// 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.
#import "content/browser/renderer_host/text_input_client_mac.h"
#include "base/memory/singleton.h"
#include "base/metrics/histogram_macros.h"
#include "base/threading/thread_restrictions.h"
#include "base/time/time.h"
#include "content/browser/renderer_host/render_widget_host_delegate.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/common/text_input_client_messages.h"
namespace content {
namespace {
// TODO(ekaramad): TextInputClientObserver, the renderer side of
// TextInputClientMac for each RenderWidgetHost, expects to have a
// WebFrameWidget to use for handling these IPCs. However, for fullscreen flash,
// we end up with a PepperWidget. For those scenarios, do not send the IPCs. We
// need to figure out what features are properly supported and perhaps send the
// IPC to the parent widget of the plugin (https://crbug.com/663384).
bool SendMessageToRenderWidget(RenderWidgetHostImpl* widget,
IPC::Message* message) {
if (!widget->delegate() ||
widget == widget->delegate()->GetFullscreenRenderWidgetHost()) {
delete message;
return false;
}
DCHECK_EQ(widget->GetRoutingID(), message->routing_id());
return widget->Send(message);
}
}
// The amount of time in milliseconds that the browser process will wait for a
// response from the renderer.
// TODO(rsesek): Using the histogram data, find the best upper-bound for this
// value.
const float kWaitTimeout = 1500;
TextInputClientMac::TextInputClientMac()
: character_index_(UINT32_MAX), lock_(), condition_(&lock_) {}
TextInputClientMac::~TextInputClientMac() {
}
// static
TextInputClientMac* TextInputClientMac::GetInstance() {
return base::Singleton<TextInputClientMac>::get();
}
void TextInputClientMac::GetStringAtPoint(RenderWidgetHost* rwh,
const gfx::Point& point,
GetStringCallback callback) {
// TODO(ekaramad): In principle, we are using the same handler regardless of
// the |rwh| which requested this. We should track the callbacks for each
// |rwh| individually so that one slow RWH will not end up clearing the
// callback for another (https://crbug.com/643233).
DCHECK(!replyForPointHandler_);
replyForPointHandler_ = std::move(callback);
RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
SendMessageToRenderWidget(
rwhi, new TextInputClientMsg_StringAtPoint(rwhi->GetRoutingID(), point));
}
void TextInputClientMac::GetStringAtPointReply(
const mac::AttributedStringCoder::EncodedString& string,
const gfx::Point& point) {
if (replyForPointHandler_) {
std::move(replyForPointHandler_).Run(string, point);
}
}
void TextInputClientMac::GetStringFromRange(RenderWidgetHost* rwh,
const gfx::Range& range,
GetStringCallback callback) {
DCHECK(!replyForRangeHandler_);
replyForRangeHandler_ = std::move(callback);
RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
SendMessageToRenderWidget(
rwhi, new TextInputClientMsg_StringForRange(rwhi->GetRoutingID(), range));
}
void TextInputClientMac::GetStringFromRangeReply(
const mac::AttributedStringCoder::EncodedString& string,
const gfx::Point& point) {
if (replyForRangeHandler_) {
std::move(replyForRangeHandler_).Run(string, point);
}
}
uint32_t TextInputClientMac::GetCharacterIndexAtPoint(RenderWidgetHost* rwh,
const gfx::Point& point) {
RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
if (!SendMessageToRenderWidget(rwhi,
new TextInputClientMsg_CharacterIndexForPoint(
rwhi->GetRoutingID(), point))) {
return UINT32_MAX;
}
base::TimeTicks start = base::TimeTicks::Now();
BeforeRequest();
// http://crbug.com/121917
base::ThreadRestrictions::ScopedAllowWait allow_wait;
condition_.TimedWait(base::TimeDelta::FromMilliseconds(kWaitTimeout));
AfterRequest();
base::TimeDelta delta(base::TimeTicks::Now() - start);
UMA_HISTOGRAM_LONG_TIMES("TextInputClient.CharacterIndex",
delta * base::Time::kMicrosecondsPerMillisecond);
return character_index_;
}
gfx::Rect TextInputClientMac::GetFirstRectForRange(RenderWidgetHost* rwh,
const gfx::Range& range) {
RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rwh);
if (!SendMessageToRenderWidget(
rwhi, new TextInputClientMsg_FirstRectForCharacterRange(
rwhi->GetRoutingID(), range))) {
return gfx::Rect();
}
base::TimeTicks start = base::TimeTicks::Now();
BeforeRequest();
// http://crbug.com/121917
base::ThreadRestrictions::ScopedAllowWait allow_wait;
condition_.TimedWait(base::TimeDelta::FromMilliseconds(kWaitTimeout));
AfterRequest();
base::TimeDelta delta(base::TimeTicks::Now() - start);
UMA_HISTOGRAM_LONG_TIMES("TextInputClient.FirstRect",
delta * base::Time::kMicrosecondsPerMillisecond);
return first_rect_;
}
void TextInputClientMac::SetCharacterIndexAndSignal(uint32_t index) {
lock_.Acquire();
character_index_ = index;
lock_.Release();
condition_.Signal();
}
void TextInputClientMac::SetFirstRectAndSignal(const gfx::Rect& first_rect) {
lock_.Acquire();
first_rect_ = first_rect;
lock_.Release();
condition_.Signal();
}
void TextInputClientMac::BeforeRequest() {
base::TimeTicks start = base::TimeTicks::Now();
lock_.Acquire();
base::TimeDelta delta(base::TimeTicks::Now() - start);
UMA_HISTOGRAM_LONG_TIMES("TextInputClient.LockWait",
delta * base::Time::kMicrosecondsPerMillisecond);
character_index_ = UINT32_MAX;
first_rect_ = gfx::Rect();
}
void TextInputClientMac::AfterRequest() {
lock_.Release();
}
} // namespace content
|
