1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "content/renderer/render_view_impl.h"
10 #include "base/auto_reset.h"
11 #include "base/bind.h"
12 #include "base/bind_helpers.h"
13 #include "base/command_line.h"
14 #include "base/compiler_specific.h"
15 #include "base/debug/alias.h"
16 #include "base/files/file_path.h"
17 #include "base/i18n/rtl.h"
18 #include "base/json/json_writer.h"
19 #include "base/lazy_instance.h"
20 #include "base/memory/scoped_ptr.h"
21 #include "base/metrics/field_trial.h"
22 #include "base/metrics/histogram.h"
23 #include "base/process/kill.h"
24 #include "base/process/process.h"
25 #include "base/strings/string_number_conversions.h"
26 #include "base/strings/string_piece.h"
27 #include "base/strings/string_split.h"
28 #include "base/strings/string_util.h"
29 #include "base/strings/sys_string_conversions.h"
30 #include "base/strings/utf_string_conversions.h"
31 #include "base/time/time.h"
32 #include "base/trace_event/trace_event.h"
33 #include "content/child/appcache/appcache_dispatcher.h"
34 #include "content/child/appcache/web_application_cache_host_impl.h"
35 #include "content/child/child_shared_bitmap_manager.h"
36 #include "content/child/npapi/webplugin_delegate_impl.h"
37 #include "content/child/request_extra_data.h"
38 #include "content/child/v8_value_converter_impl.h"
39 #include "content/child/webmessageportchannel_impl.h"
40 #include "content/common/content_constants_internal.h"
41 #include "content/common/database_messages.h"
42 #include "content/common/dom_storage/dom_storage_types.h"
43 #include "content/common/drag_messages.h"
44 #include "content/common/frame_messages.h"
45 #include "content/common/frame_replication_state.h"
46 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
47 #include "content/common/input_messages.h"
48 #include "content/common/pepper_messages.h"
49 #include "content/common/site_isolation_policy.h"
50 #include "content/common/ssl_status_serialization.h"
51 #include "content/common/view_messages.h"
52 #include "content/public/common/bindings_policy.h"
53 #include "content/public/common/content_client.h"
54 #include "content/public/common/content_constants.h"
55 #include "content/public/common/content_switches.h"
56 #include "content/public/common/drop_data.h"
57 #include "content/public/common/favicon_url.h"
58 #include "content/public/common/file_chooser_file_info.h"
59 #include "content/public/common/file_chooser_params.h"
60 #include "content/public/common/page_state.h"
61 #include "content/public/common/page_zoom.h"
62 #include "content/public/common/ssl_status.h"
63 #include "content/public/common/three_d_api_types.h"
64 #include "content/public/common/url_constants.h"
65 #include "content/public/common/url_utils.h"
66 #include "content/public/common/web_preferences.h"
67 #include "content/public/renderer/content_renderer_client.h"
68 #include "content/public/renderer/document_state.h"
69 #include "content/public/renderer/navigation_state.h"
70 #include "content/public/renderer/render_view_observer.h"
71 #include "content/public/renderer/render_view_visitor.h"
72 #include "content/renderer/browser_plugin/browser_plugin.h"
73 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
74 #include "content/renderer/disambiguation_popup_helper.h"
75 #include "content/renderer/dom_storage/webstoragenamespace_impl.h"
76 #include "content/renderer/drop_data_builder.h"
77 #include "content/renderer/gpu/render_widget_compositor.h"
78 #include "content/renderer/history_controller.h"
79 #include "content/renderer/history_serialization.h"
80 #include "content/renderer/idle_user_detector.h"
81 #include "content/renderer/ime_event_guard.h"
82 #include "content/renderer/input/input_handler_manager.h"
83 #include "content/renderer/internal_document_state_data.h"
84 #include "content/renderer/media/audio_device_factory.h"
85 #include "content/renderer/media/video_capture_impl_manager.h"
86 #include "content/renderer/mhtml_generator.h"
87 #include "content/renderer/navigation_state_impl.h"
88 #include "content/renderer/net_info_helper.h"
89 #include "content/renderer/render_frame_impl.h"
90 #include "content/renderer/render_frame_proxy.h"
91 #include "content/renderer/render_process.h"
92 #include "content/renderer/render_thread_impl.h"
93 #include "content/renderer/render_view_mouse_lock_dispatcher.h"
94 #include "content/renderer/render_widget_fullscreen_pepper.h"
95 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
96 #include "content/renderer/resizing_mode_selector.h"
97 #include "content/renderer/savable_resources.h"
98 #include "content/renderer/speech_recognition_dispatcher.h"
99 #include "content/renderer/text_input_client_observer.h"
100 #include "content/renderer/web_ui_extension_data.h"
101 #include "content/renderer/web_ui_mojo.h"
102 #include "content/renderer/websharedworker_proxy.h"
103 #include "media/audio/audio_output_device.h"
104 #include "media/base/media_switches.h"
105 #include "media/renderers/audio_renderer_impl.h"
106 #include "media/renderers/gpu_video_accelerator_factories.h"
107 #include "net/base/data_url.h"
108 #include "net/base/escape.h"
109 #include "net/base/net_errors.h"
110 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
111 #include "net/http/http_util.h"
112 #include "skia/ext/platform_canvas.h"
113 #include "third_party/WebKit/public/platform/WebCString.h"
114 #include "third_party/WebKit/public/platform/WebConnectionType.h"
115 #include "third_party/WebKit/public/platform/WebDragData.h"
116 #include "third_party/WebKit/public/platform/WebHTTPBody.h"
117 #include "third_party/WebKit/public/platform/WebImage.h"
118 #include "third_party/WebKit/public/platform/WebMessagePortChannel.h"
119 #include "third_party/WebKit/public/platform/WebPoint.h"
120 #include "third_party/WebKit/public/platform/WebRect.h"
121 #include "third_party/WebKit/public/platform/WebSize.h"
122 #include "third_party/WebKit/public/platform/WebStorageQuotaCallbacks.h"
123 #include "third_party/WebKit/public/platform/WebString.h"
124 #include "third_party/WebKit/public/platform/WebURL.h"
125 #include "third_party/WebKit/public/platform/WebURLError.h"
126 #include "third_party/WebKit/public/platform/WebURLRequest.h"
127 #include "third_party/WebKit/public/platform/WebURLResponse.h"
128 #include "third_party/WebKit/public/platform/WebVector.h"
129 #include "third_party/WebKit/public/web/WebAXObject.h"
130 #include "third_party/WebKit/public/web/WebColorName.h"
131 #include "third_party/WebKit/public/web/WebColorSuggestion.h"
132 #include "third_party/WebKit/public/web/WebDOMEvent.h"
133 #include "third_party/WebKit/public/web/WebDOMMessageEvent.h"
134 #include "third_party/WebKit/public/web/WebDataSource.h"
135 #include "third_party/WebKit/public/web/WebDateTimeChooserCompletion.h"
136 #include "third_party/WebKit/public/web/WebDateTimeChooserParams.h"
137 #include "third_party/WebKit/public/web/WebDocument.h"
138 #include "third_party/WebKit/public/web/WebElement.h"
139 #include "third_party/WebKit/public/web/WebFileChooserParams.h"
140 #include "third_party/WebKit/public/web/WebFindOptions.h"
141 #include "third_party/WebKit/public/web/WebFormControlElement.h"
142 #include "third_party/WebKit/public/web/WebFormElement.h"
143 #include "third_party/WebKit/public/web/WebFrame.h"
144 #include "third_party/WebKit/public/web/WebGlyphCache.h"
145 #include "third_party/WebKit/public/web/WebHistoryItem.h"
146 #include "third_party/WebKit/public/web/WebHitTestResult.h"
147 #include "third_party/WebKit/public/web/WebInputElement.h"
148 #include "third_party/WebKit/public/web/WebInputEvent.h"
149 #include "third_party/WebKit/public/web/WebLocalFrame.h"
150 #include "third_party/WebKit/public/web/WebMediaPlayerAction.h"
151 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
152 #include "third_party/WebKit/public/web/WebNetworkStateNotifier.h"
153 #include "third_party/WebKit/public/web/WebNodeList.h"
154 #include "third_party/WebKit/public/web/WebPageSerializer.h"
155 #include "third_party/WebKit/public/web/WebPlugin.h"
156 #include "third_party/WebKit/public/web/WebPluginAction.h"
157 #include "third_party/WebKit/public/web/WebPluginContainer.h"
158 #include "third_party/WebKit/public/web/WebPluginDocument.h"
159 #include "third_party/WebKit/public/web/WebRange.h"
160 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
161 #include "third_party/WebKit/public/web/WebScriptSource.h"
162 #include "third_party/WebKit/public/web/WebSearchableFormData.h"
163 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
164 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
165 #include "third_party/WebKit/public/web/WebSettings.h"
166 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
167 #include "third_party/WebKit/public/web/WebView.h"
168 #include "third_party/WebKit/public/web/WebWindowFeatures.h"
169 #include "third_party/WebKit/public/web/default/WebRenderTheme.h"
170 #include "third_party/icu/source/common/unicode/uchar.h"
171 #include "third_party/icu/source/common/unicode/uscript.h"
172 #include "ui/base/clipboard/clipboard.h"
173 #include "ui/base/ui_base_switches_util.h"
174 #include "ui/events/latency_info.h"
175 #include "ui/gfx/geometry/point.h"
176 #include "ui/gfx/geometry/rect.h"
177 #include "ui/gfx/geometry/rect_conversions.h"
178 #include "ui/gfx/geometry/size_conversions.h"
179 #include "ui/gfx/native_widget_types.h"
180 #include "v8/include/v8.h"
182 #if defined(OS_ANDROID)
183 #include <cpu-features.h>
185 #include "content/renderer/android/address_detector.h"
186 #include "content/renderer/android/content_detector.h"
187 #include "content/renderer/android/email_detector.h"
188 #include "content/renderer/android/phone_number_detector.h"
189 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
190 #include "third_party/WebKit/public/platform/WebFloatRect.h"
191 #include "ui/gfx/geometry/rect_f.h"
193 #elif defined(OS_WIN)
194 // TODO(port): these files are currently Windows only because they concern:
196 #include "ui/native_theme/native_theme_win.h"
197 #elif defined(USE_X11)
198 #include "ui/native_theme/native_theme.h"
199 #elif defined(OS_MACOSX)
200 #include "skia/ext/skia_utils_mac.h"
203 #if defined(ENABLE_PLUGINS)
204 #include "content/renderer/npapi/webplugin_delegate_proxy.h"
205 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
206 #include "content/renderer/pepper/pepper_plugin_registry.h"
209 #if defined(ENABLE_WEBRTC)
210 #include "content/renderer/media/rtc_peer_connection_handler.h"
211 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
214 using blink::WebAXObject
;
215 using blink::WebApplicationCacheHost
;
216 using blink::WebApplicationCacheHostClient
;
217 using blink::WebCString
;
218 using blink::WebColor
;
219 using blink::WebColorName
;
220 using blink::WebConsoleMessage
;
221 using blink::WebData
;
222 using blink::WebDataSource
;
223 using blink::WebDocument
;
224 using blink::WebDragData
;
225 using blink::WebDragOperation
;
226 using blink::WebDragOperationsMask
;
227 using blink::WebElement
;
228 using blink::WebFileChooserCompletion
;
229 using blink::WebFindOptions
;
230 using blink::WebFormControlElement
;
231 using blink::WebFormElement
;
232 using blink::WebFrame
;
233 using blink::WebGestureEvent
;
234 using blink::WebHistoryItem
;
235 using blink::WebHTTPBody
;
236 using blink::WebIconURL
;
237 using blink::WebImage
;
238 using blink::WebInputElement
;
239 using blink::WebInputEvent
;
240 using blink::WebLocalFrame
;
241 using blink::WebMediaPlayerAction
;
242 using blink::WebMouseEvent
;
243 using blink::WebNavigationPolicy
;
244 using blink::WebNavigationType
;
245 using blink::WebNode
;
246 using blink::WebPageSerializer
;
247 using blink::WebPageSerializerClient
;
248 using blink::WebPeerConnection00Handler
;
249 using blink::WebPeerConnection00HandlerClient
;
250 using blink::WebPeerConnectionHandler
;
251 using blink::WebPeerConnectionHandlerClient
;
252 using blink::WebPluginAction
;
253 using blink::WebPluginContainer
;
254 using blink::WebPluginDocument
;
255 using blink::WebPoint
;
256 using blink::WebRange
;
257 using blink::WebRect
;
258 using blink::WebReferrerPolicy
;
259 using blink::WebScriptSource
;
260 using blink::WebSearchableFormData
;
261 using blink::WebSecurityOrigin
;
262 using blink::WebSecurityPolicy
;
263 using blink::WebSettings
;
264 using blink::WebSize
;
265 using blink::WebStorageNamespace
;
266 using blink::WebStorageQuotaCallbacks
;
267 using blink::WebStorageQuotaError
;
268 using blink::WebStorageQuotaType
;
269 using blink::WebString
;
270 using blink::WebTextAffinity
;
271 using blink::WebTextDirection
;
272 using blink::WebTouchEvent
;
274 using blink::WebURLError
;
275 using blink::WebURLRequest
;
276 using blink::WebURLResponse
;
277 using blink::WebUserGestureIndicator
;
278 using blink::WebVector
;
279 using blink::WebView
;
280 using blink::WebWidget
;
281 using blink::WebWindowFeatures
;
282 using blink::WebNetworkStateNotifier
;
283 using blink::WebRuntimeFeatures
;
285 using base::TimeDelta
;
287 #if defined(OS_ANDROID)
288 using blink::WebContentDetectionResult
;
289 using blink::WebFloatPoint
;
290 using blink::WebFloatRect
;
291 using blink::WebHitTestResult
;
296 //-----------------------------------------------------------------------------
298 typedef std::map
<blink::WebView
*, RenderViewImpl
*> ViewMap
;
299 static base::LazyInstance
<ViewMap
> g_view_map
= LAZY_INSTANCE_INITIALIZER
;
300 typedef std::map
<int32
, RenderViewImpl
*> RoutingIDViewMap
;
301 static base::LazyInstance
<RoutingIDViewMap
> g_routing_id_view_map
=
302 LAZY_INSTANCE_INITIALIZER
;
304 // Time, in seconds, we delay before sending content state changes (such as form
305 // state and scroll position) to the browser. We delay sending changes to avoid
306 // spamming the browser.
307 // To avoid having tab/session restore require sending a message to get the
308 // current content state during tab closing we use a shorter timeout for the
309 // foreground renderer. This means there is a small window of time from which
310 // content state is modified and not sent to session restore, but this is
311 // better than having to wake up all renderers during shutdown.
312 const int kDelaySecondsForContentStateSyncHidden
= 5;
313 const int kDelaySecondsForContentStateSync
= 1;
315 #if defined(OS_ANDROID)
316 // Delay between tapping in content and launching the associated android intent.
317 // Used to allow users see what has been recognized as content.
318 const size_t kContentIntentDelayMilliseconds
= 700;
321 static RenderViewImpl
* (*g_create_render_view_impl
)(
322 CompositorDependencies
* compositor_deps
,
323 const ViewMsg_New_Params
&) = nullptr;
326 Referrer
RenderViewImpl::GetReferrerFromRequest(
328 const WebURLRequest
& request
) {
329 return Referrer(GURL(request
.httpHeaderField(WebString::fromUTF8("Referer"))),
330 request
.referrerPolicy());
334 WindowOpenDisposition
RenderViewImpl::NavigationPolicyToDisposition(
335 WebNavigationPolicy policy
) {
337 case blink::WebNavigationPolicyIgnore
:
338 return IGNORE_ACTION
;
339 case blink::WebNavigationPolicyDownload
:
341 case blink::WebNavigationPolicyCurrentTab
:
343 case blink::WebNavigationPolicyNewBackgroundTab
:
344 return NEW_BACKGROUND_TAB
;
345 case blink::WebNavigationPolicyNewForegroundTab
:
346 return NEW_FOREGROUND_TAB
;
347 case blink::WebNavigationPolicyNewWindow
:
349 case blink::WebNavigationPolicyNewPopup
:
352 NOTREACHED() << "Unexpected WebNavigationPolicy";
353 return IGNORE_ACTION
;
357 // Returns true if the device scale is high enough that losing subpixel
358 // antialiasing won't have a noticeable effect on text quality.
359 static bool DeviceScaleEnsuresTextQuality(float device_scale_factor
) {
360 #if defined(OS_ANDROID)
361 // On Android, we never have subpixel antialiasing.
364 // 1.5 is a common touchscreen tablet device scale factor. For such
365 // devices main thread antialiasing is a heavy burden.
366 return device_scale_factor
>= 1.5f
;
371 static bool PreferCompositingToLCDText(CompositorDependencies
* compositor_deps
,
372 float device_scale_factor
) {
373 const base::CommandLine
& command_line
=
374 *base::CommandLine::ForCurrentProcess();
375 if (command_line
.HasSwitch(switches::kDisablePreferCompositingToLCDText
))
377 if (command_line
.HasSwitch(switches::kEnablePreferCompositingToLCDText
))
379 if (!compositor_deps
->IsLcdTextEnabled())
381 return DeviceScaleEnsuresTextQuality(device_scale_factor
);
384 static FaviconURL::IconType
ToFaviconType(blink::WebIconURL::Type type
) {
386 case blink::WebIconURL::TypeFavicon
:
387 return FaviconURL::FAVICON
;
388 case blink::WebIconURL::TypeTouch
:
389 return FaviconURL::TOUCH_ICON
;
390 case blink::WebIconURL::TypeTouchPrecomposed
:
391 return FaviconURL::TOUCH_PRECOMPOSED_ICON
;
392 case blink::WebIconURL::TypeInvalid
:
393 return FaviconURL::INVALID_ICON
;
395 return FaviconURL::INVALID_ICON
;
398 static void ConvertToFaviconSizes(
399 const blink::WebVector
<blink::WebSize
>& web_sizes
,
400 std::vector
<gfx::Size
>* sizes
) {
401 DCHECK(sizes
->empty());
402 sizes
->reserve(web_sizes
.size());
403 for (size_t i
= 0; i
< web_sizes
.size(); ++i
)
404 sizes
->push_back(gfx::Size(web_sizes
[i
]));
407 ///////////////////////////////////////////////////////////////////////////////
409 struct RenderViewImpl::PendingFileChooser
{
410 PendingFileChooser(const FileChooserParams
& p
, WebFileChooserCompletion
* c
)
414 FileChooserParams params
;
415 WebFileChooserCompletion
* completion
; // MAY BE NULL to skip callback.
420 class WebWidgetLockTarget
: public MouseLockDispatcher::LockTarget
{
422 explicit WebWidgetLockTarget(blink::WebWidget
* webwidget
)
423 : webwidget_(webwidget
) {}
425 void OnLockMouseACK(bool succeeded
) override
{
427 webwidget_
->didAcquirePointerLock();
429 webwidget_
->didNotAcquirePointerLock();
432 void OnMouseLockLost() override
{ webwidget_
->didLosePointerLock(); }
434 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent
& event
) override
{
435 // The WebWidget handles mouse lock in WebKit's handleInputEvent().
440 blink::WebWidget
* webwidget_
;
443 WebDragData
DropDataToWebDragData(const DropData
& drop_data
) {
444 std::vector
<WebDragData::Item
> item_list
;
446 // These fields are currently unused when dragging into WebKit.
447 DCHECK(drop_data
.download_metadata
.empty());
448 DCHECK(drop_data
.file_contents
.empty());
449 DCHECK(drop_data
.file_description_filename
.empty());
451 if (!drop_data
.text
.is_null()) {
452 WebDragData::Item item
;
453 item
.storageType
= WebDragData::Item::StorageTypeString
;
454 item
.stringType
= WebString::fromUTF8(ui::Clipboard::kMimeTypeText
);
455 item
.stringData
= drop_data
.text
.string();
456 item_list
.push_back(item
);
459 // TODO(dcheng): Do we need to distinguish between null and empty URLs? Is it
460 // meaningful to write an empty URL to the clipboard?
461 if (!drop_data
.url
.is_empty()) {
462 WebDragData::Item item
;
463 item
.storageType
= WebDragData::Item::StorageTypeString
;
464 item
.stringType
= WebString::fromUTF8(ui::Clipboard::kMimeTypeURIList
);
465 item
.stringData
= WebString::fromUTF8(drop_data
.url
.spec());
466 item
.title
= drop_data
.url_title
;
467 item_list
.push_back(item
);
470 if (!drop_data
.html
.is_null()) {
471 WebDragData::Item item
;
472 item
.storageType
= WebDragData::Item::StorageTypeString
;
473 item
.stringType
= WebString::fromUTF8(ui::Clipboard::kMimeTypeHTML
);
474 item
.stringData
= drop_data
.html
.string();
475 item
.baseURL
= drop_data
.html_base_url
;
476 item_list
.push_back(item
);
479 for (std::vector
<ui::FileInfo
>::const_iterator it
=
480 drop_data
.filenames
.begin();
481 it
!= drop_data
.filenames
.end();
483 WebDragData::Item item
;
484 item
.storageType
= WebDragData::Item::StorageTypeFilename
;
485 item
.filenameData
= it
->path
.AsUTF16Unsafe();
486 item
.displayNameData
= it
->display_name
.AsUTF16Unsafe();
487 item_list
.push_back(item
);
490 for (std::vector
<DropData::FileSystemFileInfo
>::const_iterator it
=
491 drop_data
.file_system_files
.begin();
492 it
!= drop_data
.file_system_files
.end();
494 WebDragData::Item item
;
495 item
.storageType
= WebDragData::Item::StorageTypeFileSystemFile
;
496 item
.fileSystemURL
= it
->url
;
497 item
.fileSystemFileSize
= it
->size
;
498 item_list
.push_back(item
);
501 for (std::map
<base::string16
, base::string16
>::const_iterator it
=
502 drop_data
.custom_data
.begin();
503 it
!= drop_data
.custom_data
.end();
505 WebDragData::Item item
;
506 item
.storageType
= WebDragData::Item::StorageTypeString
;
507 item
.stringType
= it
->first
;
508 item
.stringData
= it
->second
;
509 item_list
.push_back(item
);
514 result
.setItems(item_list
);
515 result
.setFilesystemId(drop_data
.filesystem_id
);
519 typedef void (*SetFontFamilyWrapper
)(blink::WebSettings
*,
520 const base::string16
&,
523 void SetStandardFontFamilyWrapper(WebSettings
* settings
,
524 const base::string16
& font
,
525 UScriptCode script
) {
526 settings
->setStandardFontFamily(font
, script
);
529 void SetFixedFontFamilyWrapper(WebSettings
* settings
,
530 const base::string16
& font
,
531 UScriptCode script
) {
532 settings
->setFixedFontFamily(font
, script
);
535 void SetSerifFontFamilyWrapper(WebSettings
* settings
,
536 const base::string16
& font
,
537 UScriptCode script
) {
538 settings
->setSerifFontFamily(font
, script
);
541 void SetSansSerifFontFamilyWrapper(WebSettings
* settings
,
542 const base::string16
& font
,
543 UScriptCode script
) {
544 settings
->setSansSerifFontFamily(font
, script
);
547 void SetCursiveFontFamilyWrapper(WebSettings
* settings
,
548 const base::string16
& font
,
549 UScriptCode script
) {
550 settings
->setCursiveFontFamily(font
, script
);
553 void SetFantasyFontFamilyWrapper(WebSettings
* settings
,
554 const base::string16
& font
,
555 UScriptCode script
) {
556 settings
->setFantasyFontFamily(font
, script
);
559 void SetPictographFontFamilyWrapper(WebSettings
* settings
,
560 const base::string16
& font
,
561 UScriptCode script
) {
562 settings
->setPictographFontFamily(font
, script
);
565 // If |scriptCode| is a member of a family of "similar" script codes, returns
566 // the script code in that family that is used by WebKit for font selection
567 // purposes. For example, USCRIPT_KATAKANA_OR_HIRAGANA and USCRIPT_JAPANESE are
568 // considered equivalent for the purposes of font selection. WebKit uses the
569 // script code USCRIPT_KATAKANA_OR_HIRAGANA. So, if |scriptCode| is
570 // USCRIPT_JAPANESE, the function returns USCRIPT_KATAKANA_OR_HIRAGANA. WebKit
571 // uses different scripts than the ones in Chrome pref names because the version
572 // of ICU included on certain ports does not have some of the newer scripts. If
573 // |scriptCode| is not a member of such a family, returns |scriptCode|.
574 UScriptCode
GetScriptForWebSettings(UScriptCode scriptCode
) {
575 switch (scriptCode
) {
576 case USCRIPT_HIRAGANA
:
577 case USCRIPT_KATAKANA
:
578 case USCRIPT_JAPANESE
:
579 return USCRIPT_KATAKANA_OR_HIRAGANA
;
581 return USCRIPT_HANGUL
;
587 void ApplyFontsFromMap(const ScriptFontFamilyMap
& map
,
588 SetFontFamilyWrapper setter
,
589 WebSettings
* settings
) {
590 for (ScriptFontFamilyMap::const_iterator it
= map
.begin(); it
!= map
.end();
592 int32 script
= u_getPropertyValueEnum(UCHAR_SCRIPT
, (it
->first
).c_str());
593 if (script
>= 0 && script
< USCRIPT_CODE_LIMIT
) {
594 UScriptCode code
= static_cast<UScriptCode
>(script
);
595 (*setter
)(settings
, it
->second
, GetScriptForWebSettings(code
));
600 void ApplyBlinkSettings(const base::CommandLine
& command_line
,
601 WebSettings
* settings
) {
602 if (!command_line
.HasSwitch(switches::kBlinkSettings
))
605 std::vector
<std::string
> blink_settings
= base::SplitString(
606 command_line
.GetSwitchValueASCII(switches::kBlinkSettings
),
607 ",", base::TRIM_WHITESPACE
, base::SPLIT_WANT_ALL
);
608 for (const std::string
& setting
: blink_settings
) {
609 size_t pos
= setting
.find('=');
610 settings
->setFromStrings(
611 blink::WebString::fromLatin1(setting
.substr(0, pos
)),
612 blink::WebString::fromLatin1(
613 pos
== std::string::npos
? "" : setting
.substr(pos
+ 1)));
619 RenderViewImpl::RenderViewImpl(CompositorDependencies
* compositor_deps
,
620 const ViewMsg_New_Params
& params
)
621 : RenderWidget(compositor_deps
,
622 blink::WebPopupTypeNone
,
623 params
.initial_size
.screen_info
,
626 params
.never_visible
),
627 webkit_preferences_(params
.web_preferences
),
628 send_content_state_immediately_(false),
629 enabled_bindings_(0),
630 send_preferred_size_changes_(false),
631 navigation_gesture_(NavigationGestureUnknown
),
632 opened_by_user_gesture_(true),
633 opener_suppressed_(false),
634 suppress_dialogs_until_swap_out_(false),
636 next_page_id_(params
.next_page_id
),
637 history_list_offset_(-1),
638 history_list_length_(0),
639 frames_in_progress_(0),
640 target_url_status_(TARGET_NONE
),
641 uses_temporary_zoom_level_(false),
642 #if defined(OS_ANDROID)
643 top_controls_constraints_(TOP_CONTROLS_STATE_BOTH
),
645 has_scrolled_focused_editable_node_into_rect_(false),
646 main_render_frame_(nullptr),
647 speech_recognition_dispatcher_(NULL
),
648 mouse_lock_dispatcher_(NULL
),
649 #if defined(OS_ANDROID)
650 expected_content_intent_id_(0),
653 focused_plugin_id_(-1),
655 #if defined(ENABLE_PLUGINS)
656 plugin_find_handler_(NULL
),
657 focused_pepper_plugin_(NULL
),
658 pepper_last_mouse_event_target_(NULL
),
660 enumeration_completion_id_(0),
661 session_storage_namespace_id_(params
.session_storage_namespace_id
),
662 page_scale_factor_is_one_(true) {
665 void RenderViewImpl::Initialize(const ViewMsg_New_Params
& params
,
666 bool was_created_by_renderer
) {
667 routing_id_
= params
.view_id
;
668 surface_id_
= params
.surface_id
;
670 int opener_view_routing_id
;
671 WebFrame
* opener_frame
= RenderFrameImpl::ResolveOpener(
672 params
.opener_frame_route_id
, &opener_view_routing_id
);
673 if (opener_view_routing_id
!= MSG_ROUTING_NONE
&& was_created_by_renderer
)
674 opener_id_
= opener_view_routing_id
;
676 display_mode_
= params
.initial_size
.display_mode
;
678 // Ensure we start with a valid next_page_id_ from the browser.
679 DCHECK_GE(next_page_id_
, 0);
681 webwidget_
= WebView::create(this);
682 webwidget_mouse_lock_target_
.reset(new WebWidgetLockTarget(webwidget_
));
684 g_view_map
.Get().insert(std::make_pair(webview(), this));
685 g_routing_id_view_map
.Get().insert(std::make_pair(routing_id_
, this));
687 const base::CommandLine
& command_line
=
688 *base::CommandLine::ForCurrentProcess();
690 if (command_line
.HasSwitch(switches::kStatsCollectionController
))
691 stats_collection_observer_
.reset(new StatsCollectionObserver(this));
693 if (params
.main_frame_routing_id
!= MSG_ROUTING_NONE
) {
695 RenderFrameImpl::CreateMainFrame(this, params
.main_frame_routing_id
);
698 if (params
.proxy_routing_id
!= MSG_ROUTING_NONE
) {
699 CHECK(params
.swapped_out
);
700 if (main_render_frame_
) {
701 DCHECK(!SiteIsolationPolicy::IsSwappedOutStateForbidden());
702 RenderFrameProxy
* proxy
= RenderFrameProxy::CreateProxyToReplaceFrame(
703 main_render_frame_
, params
.proxy_routing_id
,
704 blink::WebTreeScopeType::Document
);
705 main_render_frame_
->set_render_frame_proxy(proxy
);
707 DCHECK(SiteIsolationPolicy::IsSwappedOutStateForbidden());
708 // Pass MSG_ROUTING_NONE for opener, since actual opener (if any) will be
709 // set separately below.
710 RenderFrameProxy::CreateFrameProxy(params
.proxy_routing_id
, routing_id_
,
711 MSG_ROUTING_NONE
, MSG_ROUTING_NONE
,
712 params
.replicated_frame_state
);
716 if (main_render_frame_
)
717 main_render_frame_
->Initialize();
719 #if defined(OS_ANDROID)
720 content_detectors_
.push_back(linked_ptr
<ContentDetector
>(
721 new AddressDetector()));
722 const std::string
& contry_iso
=
723 params
.renderer_preferences
.network_contry_iso
;
724 if (!contry_iso
.empty()) {
725 content_detectors_
.push_back(linked_ptr
<ContentDetector
>(
726 new PhoneNumberDetector(contry_iso
)));
728 content_detectors_
.push_back(linked_ptr
<ContentDetector
>(
729 new EmailDetector()));
732 RenderThread::Get()->AddRoute(routing_id_
, this);
733 // Take a reference on behalf of the RenderThread. This will be balanced
734 // when we receive ViewMsg_Close in the RenderWidget (which RenderView
737 if (RenderThreadImpl::current()) {
738 RenderThreadImpl::current()->WidgetCreated();
740 RenderThreadImpl::current()->WidgetHidden();
743 // If this is a popup, we must wait for the CreatingNew_ACK message before
744 // completing initialization. Otherwise, we can finish it now.
745 if (opener_id_
== MSG_ROUTING_NONE
) {
750 webview()->setDeviceScaleFactor(device_scale_factor_
);
751 webview()->setDisplayMode(display_mode_
);
752 webview()->settings()->setPreferCompositingToLCDTextEnabled(
753 PreferCompositingToLCDText(compositor_deps_
, device_scale_factor_
));
754 webview()->settings()->setThreadedScrollingEnabled(
755 !command_line
.HasSwitch(switches::kDisableThreadedScrolling
));
756 webview()->settings()->setRootLayerScrolls(
757 command_line
.HasSwitch(switches::kRootLayerScrolls
));
759 ApplyWebPreferencesInternal(webkit_preferences_
, webview(), compositor_deps_
);
761 if (switches::IsTouchDragDropEnabled())
762 webview()->settings()->setTouchDragDropEnabled(true);
764 if (switches::IsTouchEditingEnabled())
765 webview()->settings()->setTouchEditingEnabled(true);
767 WebSettings::SelectionStrategyType selection_strategy
=
768 WebSettings::SelectionStrategyType::Character
;
769 const std::string selection_strategy_str
=
770 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
771 switches::kTouchTextSelectionStrategy
);
772 if (selection_strategy_str
== "direction")
773 selection_strategy
= WebSettings::SelectionStrategyType::Direction
;
774 webview()->settings()->setSelectionStrategy(selection_strategy
);
776 // Set the main frame's name. Only needs to be done for WebLocalFrames,
777 // since the remote case was handled as part of SetReplicatedState on the
779 if (!params
.replicated_frame_state
.name
.empty() &&
780 webview()->mainFrame()->isWebLocalFrame()) {
781 webview()->mainFrame()->setName(
782 blink::WebString::fromUTF8(params
.replicated_frame_state
.name
));
785 // TODO(davidben): Move this state from Blink into content.
786 if (params
.window_was_created_with_opener
)
787 webview()->setOpenedByDOM();
789 OnSetRendererPrefs(params
.renderer_preferences
);
791 ApplyBlinkSettings(command_line
, webview()->settings());
793 if (!params
.enable_auto_resize
) {
794 OnResize(params
.initial_size
);
796 OnEnableAutoResize(params
.min_size
, params
.max_size
);
799 new MHTMLGenerator(this);
800 #if defined(OS_MACOSX)
801 new TextInputClientObserver(this);
802 #endif // defined(OS_MACOSX)
804 // The next group of objects all implement RenderViewObserver, so are deleted
805 // along with the RenderView automatically.
806 mouse_lock_dispatcher_
= new RenderViewMouseLockDispatcher(this);
808 history_controller_
.reset(new HistoryController(this));
810 new IdleUserDetector(this);
812 if (command_line
.HasSwitch(switches::kDomAutomationController
))
813 enabled_bindings_
|= BINDINGS_POLICY_DOM_AUTOMATION
;
814 if (command_line
.HasSwitch(switches::kStatsCollectionController
))
815 enabled_bindings_
|= BINDINGS_POLICY_STATS_COLLECTION
;
817 GetContentClient()->renderer()->RenderViewCreated(this);
819 // If we have an opener_frame but we weren't created by a renderer, then it's
820 // the browser asking us to set our opener to another frame.
821 if (opener_frame
&& !was_created_by_renderer
)
822 webview()->mainFrame()->setOpener(opener_frame
);
824 // If we are initially swapped out, navigate to kSwappedOutURL.
825 // This ensures we are in a unique origin that others cannot script.
826 if (is_swapped_out_
&& webview()->mainFrame()->isWebLocalFrame())
827 main_render_frame_
->NavigateToSwappedOutURL();
830 RenderViewImpl::~RenderViewImpl() {
831 for (BitmapMap::iterator it
= disambiguation_bitmaps_
.begin();
832 it
!= disambiguation_bitmaps_
.end();
836 // If file chooser is still waiting for answer, dispatch empty answer.
837 while (!file_chooser_completions_
.empty()) {
838 if (file_chooser_completions_
.front()->completion
) {
839 file_chooser_completions_
.front()->completion
->didChooseFile(
840 WebVector
<WebString
>());
842 file_chooser_completions_
.pop_front();
845 #if defined(OS_ANDROID)
846 // The date/time picker client is both a scoped_ptr member of this class and
847 // a RenderViewObserver. Reset it to prevent double deletion.
848 date_time_picker_client_
.reset();
852 // Make sure we are no longer referenced by the ViewMap or RoutingIDViewMap.
853 ViewMap
* views
= g_view_map
.Pointer();
854 for (ViewMap::iterator it
= views
->begin(); it
!= views
->end(); ++it
)
855 DCHECK_NE(this, it
->second
) << "Failed to call Close?";
856 RoutingIDViewMap
* routing_id_views
= g_routing_id_view_map
.Pointer();
857 for (RoutingIDViewMap::iterator it
= routing_id_views
->begin();
858 it
!= routing_id_views
->end(); ++it
)
859 DCHECK_NE(this, it
->second
) << "Failed to call Close?";
862 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, RenderViewGone());
863 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, OnDestruct());
867 RenderViewImpl
* RenderViewImpl::FromWebView(WebView
* webview
) {
868 ViewMap
* views
= g_view_map
.Pointer();
869 ViewMap::iterator it
= views
->find(webview
);
870 return it
== views
->end() ? NULL
: it
->second
;
874 RenderView
* RenderView::FromWebView(blink::WebView
* webview
) {
875 return RenderViewImpl::FromWebView(webview
);
879 RenderViewImpl
* RenderViewImpl::FromRoutingID(int32 routing_id
) {
880 RoutingIDViewMap
* views
= g_routing_id_view_map
.Pointer();
881 RoutingIDViewMap::iterator it
= views
->find(routing_id
);
882 return it
== views
->end() ? NULL
: it
->second
;
886 RenderView
* RenderView::FromRoutingID(int routing_id
) {
887 return RenderViewImpl::FromRoutingID(routing_id
);
891 size_t RenderView::GetRenderViewCount() {
892 return g_view_map
.Get().size();
896 void RenderView::ForEach(RenderViewVisitor
* visitor
) {
897 ViewMap
* views
= g_view_map
.Pointer();
898 for (ViewMap::iterator it
= views
->begin(); it
!= views
->end(); ++it
) {
899 if (!visitor
->Visit(it
->second
))
905 void RenderView::ApplyWebPreferences(const WebPreferences
& prefs
,
907 WebSettings
* settings
= web_view
->settings();
908 ApplyFontsFromMap(prefs
.standard_font_family_map
,
909 SetStandardFontFamilyWrapper
, settings
);
910 ApplyFontsFromMap(prefs
.fixed_font_family_map
,
911 SetFixedFontFamilyWrapper
, settings
);
912 ApplyFontsFromMap(prefs
.serif_font_family_map
,
913 SetSerifFontFamilyWrapper
, settings
);
914 ApplyFontsFromMap(prefs
.sans_serif_font_family_map
,
915 SetSansSerifFontFamilyWrapper
, settings
);
916 ApplyFontsFromMap(prefs
.cursive_font_family_map
,
917 SetCursiveFontFamilyWrapper
, settings
);
918 ApplyFontsFromMap(prefs
.fantasy_font_family_map
,
919 SetFantasyFontFamilyWrapper
, settings
);
920 ApplyFontsFromMap(prefs
.pictograph_font_family_map
,
921 SetPictographFontFamilyWrapper
, settings
);
922 settings
->setDefaultFontSize(prefs
.default_font_size
);
923 settings
->setDefaultFixedFontSize(prefs
.default_fixed_font_size
);
924 settings
->setMinimumFontSize(prefs
.minimum_font_size
);
925 settings
->setMinimumLogicalFontSize(prefs
.minimum_logical_font_size
);
926 settings
->setDefaultTextEncodingName(
927 base::ASCIIToUTF16(prefs
.default_encoding
));
928 settings
->setJavaScriptEnabled(prefs
.javascript_enabled
);
929 settings
->setWebSecurityEnabled(prefs
.web_security_enabled
);
930 settings
->setJavaScriptCanOpenWindowsAutomatically(
931 prefs
.javascript_can_open_windows_automatically
);
932 settings
->setLoadsImagesAutomatically(prefs
.loads_images_automatically
);
933 settings
->setImagesEnabled(prefs
.images_enabled
);
934 settings
->setPluginsEnabled(prefs
.plugins_enabled
);
935 settings
->setDOMPasteAllowed(prefs
.dom_paste_enabled
);
936 settings
->setUsesEncodingDetector(prefs
.uses_universal_detector
);
937 settings
->setTextAreasAreResizable(prefs
.text_areas_are_resizable
);
938 settings
->setAllowScriptsToCloseWindows(prefs
.allow_scripts_to_close_windows
);
939 settings
->setDownloadableBinaryFontsEnabled(prefs
.remote_fonts_enabled
);
940 settings
->setJavaScriptCanAccessClipboard(
941 prefs
.javascript_can_access_clipboard
);
942 WebRuntimeFeatures::enableXSLT(prefs
.xslt_enabled
);
943 WebRuntimeFeatures::enableSlimmingPaintV2(prefs
.slimming_paint_v2_enabled
);
944 settings
->setXSSAuditorEnabled(prefs
.xss_auditor_enabled
);
945 settings
->setDNSPrefetchingEnabled(prefs
.dns_prefetching_enabled
);
946 settings
->setLocalStorageEnabled(prefs
.local_storage_enabled
);
947 settings
->setSyncXHRInDocumentsEnabled(prefs
.sync_xhr_in_documents_enabled
);
948 WebRuntimeFeatures::enableDatabase(prefs
.databases_enabled
);
949 settings
->setOfflineWebApplicationCacheEnabled(
950 prefs
.application_cache_enabled
);
951 settings
->setCaretBrowsingEnabled(prefs
.caret_browsing_enabled
);
952 settings
->setHyperlinkAuditingEnabled(prefs
.hyperlink_auditing_enabled
);
953 settings
->setCookieEnabled(prefs
.cookie_enabled
);
954 settings
->setNavigateOnDragDrop(prefs
.navigate_on_drag_drop
);
956 // By default, allow_universal_access_from_file_urls is set to false and thus
957 // we mitigate attacks from local HTML files by not granting file:// URLs
958 // universal access. Only test shell will enable this.
959 settings
->setAllowUniversalAccessFromFileURLs(
960 prefs
.allow_universal_access_from_file_urls
);
961 settings
->setAllowFileAccessFromFileURLs(
962 prefs
.allow_file_access_from_file_urls
);
964 // Enable the web audio API if requested on the command line.
965 settings
->setWebAudioEnabled(prefs
.webaudio_enabled
);
967 // Enable experimental WebGL support if requested on command line
968 // and support is compiled in.
969 settings
->setExperimentalWebGLEnabled(prefs
.experimental_webgl_enabled
);
971 // Disable GL multisampling if requested on command line.
972 settings
->setOpenGLMultisamplingEnabled(prefs
.gl_multisampling_enabled
);
974 // Enable WebGL errors to the JS console if requested.
975 settings
->setWebGLErrorsToConsoleEnabled(
976 prefs
.webgl_errors_to_console_enabled
);
978 // Uses the mock theme engine for scrollbars.
979 settings
->setMockScrollbarsEnabled(prefs
.mock_scrollbars_enabled
);
981 // Enable gpu-accelerated 2d canvas if requested on the command line.
982 settings
->setAccelerated2dCanvasEnabled(prefs
.accelerated_2d_canvas_enabled
);
984 settings
->setMinimumAccelerated2dCanvasSize(
985 prefs
.minimum_accelerated_2d_canvas_size
);
987 // Disable antialiasing for 2d canvas if requested on the command line.
988 settings
->setAntialiased2dCanvasEnabled(
989 !prefs
.antialiased_2d_canvas_disabled
);
991 // Enabled antialiasing of clips for 2d canvas if requested on the command
993 settings
->setAntialiasedClips2dCanvasEnabled(
994 prefs
.antialiased_clips_2d_canvas_enabled
);
996 // Set MSAA sample count for 2d canvas if requested on the command line (or
997 // default value if not).
998 settings
->setAccelerated2dCanvasMSAASampleCount(
999 prefs
.accelerated_2d_canvas_msaa_sample_count
);
1001 settings
->setAsynchronousSpellCheckingEnabled(
1002 prefs
.asynchronous_spell_checking_enabled
);
1003 settings
->setUnifiedTextCheckerEnabled(prefs
.unified_textchecker_enabled
);
1005 // Tabs to link is not part of the settings. WebCore calls
1006 // ChromeClient::tabsToLinks which is part of the glue code.
1007 web_view
->setTabsToLinks(prefs
.tabs_to_links
);
1009 settings
->setAllowDisplayOfInsecureContent(
1010 prefs
.allow_displaying_insecure_content
);
1011 settings
->setAllowRunningOfInsecureContent(
1012 prefs
.allow_running_insecure_content
);
1013 settings
->setDisableReadingFromCanvas(prefs
.disable_reading_from_canvas
);
1014 settings
->setStrictMixedContentChecking(prefs
.strict_mixed_content_checking
);
1016 settings
->setStrictlyBlockBlockableMixedContent(
1017 prefs
.strictly_block_blockable_mixed_content
);
1019 settings
->setStrictMixedContentCheckingForPlugin(
1020 prefs
.block_mixed_plugin_content
);
1022 settings
->setStrictPowerfulFeatureRestrictions(
1023 prefs
.strict_powerful_feature_restrictions
);
1024 settings
->setPasswordEchoEnabled(prefs
.password_echo_enabled
);
1025 settings
->setShouldPrintBackgrounds(prefs
.should_print_backgrounds
);
1026 settings
->setShouldClearDocumentBackground(
1027 prefs
.should_clear_document_background
);
1028 settings
->setEnableScrollAnimator(prefs
.enable_scroll_animator
);
1030 WebRuntimeFeatures::enableTouch(prefs
.touch_enabled
);
1031 settings
->setMaxTouchPoints(prefs
.pointer_events_max_touch_points
);
1032 settings
->setAvailablePointerTypes(prefs
.available_pointer_types
);
1033 settings
->setPrimaryPointerType(
1034 static_cast<WebSettings::PointerType
>(prefs
.primary_pointer_type
));
1035 settings
->setAvailableHoverTypes(prefs
.available_hover_types
);
1036 settings
->setPrimaryHoverType(
1037 static_cast<WebSettings::HoverType
>(prefs
.primary_hover_type
));
1038 settings
->setDeviceSupportsTouch(prefs
.device_supports_touch
);
1039 settings
->setDeviceSupportsMouse(prefs
.device_supports_mouse
);
1040 settings
->setEnableTouchAdjustment(prefs
.touch_adjustment_enabled
);
1041 settings
->setMultiTargetTapNotificationEnabled(
1042 switches::IsLinkDisambiguationPopupEnabled());
1044 WebRuntimeFeatures::enableImageColorProfiles(
1045 prefs
.image_color_profiles_enabled
);
1046 settings
->setShouldRespectImageOrientation(
1047 prefs
.should_respect_image_orientation
);
1049 settings
->setUnsafePluginPastingEnabled(false);
1050 settings
->setEditingBehavior(
1051 static_cast<WebSettings::EditingBehavior
>(prefs
.editing_behavior
));
1053 settings
->setSupportsMultipleWindows(prefs
.supports_multiple_windows
);
1055 // TODO(bokan): Remove once Blink side is gone.
1056 settings
->setInvertViewportScrollOrder(true);
1058 settings
->setViewportEnabled(prefs
.viewport_enabled
);
1059 settings
->setLoadWithOverviewMode(prefs
.initialize_at_minimum_page_scale
);
1060 settings
->setViewportMetaEnabled(prefs
.viewport_meta_enabled
);
1061 settings
->setMainFrameResizesAreOrientationChanges(
1062 prefs
.main_frame_resizes_are_orientation_changes
);
1064 settings
->setSmartInsertDeleteEnabled(prefs
.smart_insert_delete_enabled
);
1066 settings
->setSpatialNavigationEnabled(prefs
.spatial_navigation_enabled
);
1068 settings
->setSelectionIncludesAltImageText(true);
1070 settings
->setV8CacheOptions(
1071 static_cast<WebSettings::V8CacheOptions
>(prefs
.v8_cache_options
));
1073 settings
->setImageAnimationPolicy(
1074 static_cast<WebSettings::ImageAnimationPolicy
>(prefs
.animation_policy
));
1076 // Needs to happen before setIgnoreVIewportTagScaleLimits below.
1077 web_view
->setDefaultPageScaleLimits(
1078 prefs
.default_minimum_page_scale_factor
,
1079 prefs
.default_maximum_page_scale_factor
);
1081 #if defined(OS_ANDROID)
1082 settings
->setAllowCustomScrollbarInMainFrame(false);
1083 settings
->setTextAutosizingEnabled(prefs
.text_autosizing_enabled
);
1084 settings
->setAccessibilityFontScaleFactor(prefs
.font_scale_factor
);
1085 settings
->setDeviceScaleAdjustment(prefs
.device_scale_adjustment
);
1086 settings
->setFullscreenSupported(prefs
.fullscreen_supported
);
1087 web_view
->setIgnoreViewportTagScaleLimits(prefs
.force_enable_zoom
);
1088 settings
->setAutoZoomFocusedNodeToLegibleScale(true);
1089 settings
->setDoubleTapToZoomEnabled(prefs
.double_tap_to_zoom_enabled
);
1090 settings
->setMediaControlsOverlayPlayButtonEnabled(true);
1091 settings
->setMediaPlaybackRequiresUserGesture(
1092 prefs
.user_gesture_required_for_media_playback
);
1093 settings
->setDefaultVideoPosterURL(
1094 base::ASCIIToUTF16(prefs
.default_video_poster_url
.spec()));
1095 settings
->setSupportDeprecatedTargetDensityDPI(
1096 prefs
.support_deprecated_target_density_dpi
);
1097 settings
->setUseLegacyBackgroundSizeShorthandBehavior(
1098 prefs
.use_legacy_background_size_shorthand_behavior
);
1099 settings
->setWideViewportQuirkEnabled(prefs
.wide_viewport_quirk
);
1100 settings
->setUseWideViewport(prefs
.use_wide_viewport
);
1101 settings
->setForceZeroLayoutHeight(prefs
.force_zero_layout_height
);
1102 settings
->setViewportMetaLayoutSizeQuirk(
1103 prefs
.viewport_meta_layout_size_quirk
);
1104 settings
->setViewportMetaMergeContentQuirk(
1105 prefs
.viewport_meta_merge_content_quirk
);
1106 settings
->setViewportMetaNonUserScalableQuirk(
1107 prefs
.viewport_meta_non_user_scalable_quirk
);
1108 settings
->setViewportMetaZeroValuesQuirk(
1109 prefs
.viewport_meta_zero_values_quirk
);
1110 settings
->setClobberUserAgentInitialScaleQuirk(
1111 prefs
.clobber_user_agent_initial_scale_quirk
);
1112 settings
->setIgnoreMainFrameOverflowHiddenQuirk(
1113 prefs
.ignore_main_frame_overflow_hidden_quirk
);
1114 settings
->setReportScreenSizeInPhysicalPixelsQuirk(
1115 prefs
.report_screen_size_in_physical_pixels_quirk
);
1116 settings
->setPreferHiddenVolumeControls(true);
1117 settings
->setMainFrameClipsContent(!prefs
.record_whole_document
);
1118 settings
->setShrinksViewportContentToFit(true);
1119 settings
->setUseMobileViewportStyle(true);
1120 settings
->setAutoplayExperimentMode(
1121 blink::WebString::fromUTF8(prefs
.autoplay_experiment_mode
));
1124 WebNetworkStateNotifier::setOnLine(prefs
.is_online
);
1125 WebNetworkStateNotifier::setWebConnection(
1126 NetConnectionTypeToWebConnectionType(prefs
.net_info_connection_type
),
1127 prefs
.net_info_max_bandwidth_mbps
);
1129 settings
->setPinchOverlayScrollbarThickness(
1130 prefs
.pinch_overlay_scrollbar_thickness
);
1131 settings
->setUseSolidColorScrollbars(prefs
.use_solid_color_scrollbars
);
1133 settings
->setShowContextMenuOnMouseUp(prefs
.context_menu_on_mouse_up
);
1135 #if defined(OS_MACOSX)
1136 settings
->setDoubleTapToZoomEnabled(true);
1137 web_view
->setMaximumLegibleScale(prefs
.default_maximum_page_scale_factor
);
1140 #if !defined(OS_ANDROID) && !defined(OS_MACOSX)
1141 // On platforms where the pinch viewport and the layout viewport can
1142 // both show scrollbars, hide pinch scrollbars when we are near minimum
1143 // page scale. (See http://crbug.com/446411 and http://crbug.com/515746.)
1144 settings
->setHidePinchScrollbarsNearMinScale(true);
1149 RenderViewImpl
* RenderViewImpl::Create(CompositorDependencies
* compositor_deps
,
1150 const ViewMsg_New_Params
& params
,
1151 bool was_created_by_renderer
) {
1152 DCHECK(params
.view_id
!= MSG_ROUTING_NONE
);
1153 RenderViewImpl
* render_view
= NULL
;
1154 if (g_create_render_view_impl
)
1155 render_view
= g_create_render_view_impl(compositor_deps
, params
);
1157 render_view
= new RenderViewImpl(compositor_deps
, params
);
1159 render_view
->Initialize(params
, was_created_by_renderer
);
1164 void RenderViewImpl::InstallCreateHook(RenderViewImpl
* (
1165 *create_render_view_impl
)(CompositorDependencies
* compositor_deps
,
1166 const ViewMsg_New_Params
&)) {
1167 CHECK(!g_create_render_view_impl
);
1168 g_create_render_view_impl
= create_render_view_impl
;
1171 void RenderViewImpl::AddObserver(RenderViewObserver
* observer
) {
1172 observers_
.AddObserver(observer
);
1175 void RenderViewImpl::RemoveObserver(RenderViewObserver
* observer
) {
1176 observer
->RenderViewGone();
1177 observers_
.RemoveObserver(observer
);
1180 blink::WebView
* RenderViewImpl::webview() const {
1181 return static_cast<blink::WebView
*>(webwidget());
1184 #if defined(ENABLE_PLUGINS)
1185 void RenderViewImpl::PepperInstanceCreated(
1186 PepperPluginInstanceImpl
* instance
) {
1187 active_pepper_instances_
.insert(instance
);
1189 RenderFrameImpl
* const render_frame
= instance
->render_frame();
1191 new FrameHostMsg_PepperInstanceCreated(render_frame
->GetRoutingID()));
1194 void RenderViewImpl::PepperInstanceDeleted(
1195 PepperPluginInstanceImpl
* instance
) {
1196 active_pepper_instances_
.erase(instance
);
1198 if (pepper_last_mouse_event_target_
== instance
)
1199 pepper_last_mouse_event_target_
= NULL
;
1200 if (focused_pepper_plugin_
== instance
)
1201 PepperFocusChanged(instance
, false);
1203 RenderFrameImpl
* const render_frame
= instance
->render_frame();
1206 new FrameHostMsg_PepperInstanceDeleted(render_frame
->GetRoutingID()));
1209 void RenderViewImpl::PepperFocusChanged(PepperPluginInstanceImpl
* instance
,
1212 focused_pepper_plugin_
= instance
;
1213 else if (focused_pepper_plugin_
== instance
)
1214 focused_pepper_plugin_
= NULL
;
1216 UpdateTextInputState(NO_SHOW_IME
, FROM_NON_IME
);
1217 UpdateSelectionBounds();
1220 void RenderViewImpl::RegisterPluginDelegate(WebPluginDelegateProxy
* delegate
) {
1221 plugin_delegates_
.insert(delegate
);
1222 // If the renderer is visible, set initial visibility and focus state.
1224 #if defined(OS_MACOSX)
1225 delegate
->SetContainerVisibility(true);
1226 if (webview() && webview()->isActive())
1227 delegate
->SetWindowFocus(true);
1230 // Plugins start assuming the content has focus (so that they work in
1231 // environments where RenderView isn't hosting them), so we always have to
1232 // set the initial state. See webplugin_delegate_impl.h for details.
1233 delegate
->SetContentAreaFocus(has_focus());
1236 void RenderViewImpl::UnregisterPluginDelegate(
1237 WebPluginDelegateProxy
* delegate
) {
1238 plugin_delegates_
.erase(delegate
);
1242 void RenderViewImpl::PluginFocusChanged(bool focused
, int plugin_id
) {
1244 focused_plugin_id_
= plugin_id
;
1246 focused_plugin_id_
= -1;
1250 #if defined(OS_MACOSX)
1251 void RenderViewImpl::PluginFocusChanged(bool focused
, int plugin_id
) {
1252 Send(new ViewHostMsg_PluginFocusChanged(routing_id(), focused
, plugin_id
));
1255 void RenderViewImpl::OnGetRenderedText() {
1258 // Get rendered text from WebLocalFrame.
1259 // TODO: Currently IPC truncates any data that has a
1260 // size > kMaximumMessageSize. May be split the text into smaller chunks and
1261 // send back using multiple IPC. See http://crbug.com/393444.
1262 static const size_t kMaximumMessageSize
= 8 * 1024 * 1024;
1263 std::string text
= webview()->mainFrame()->contentAsText(
1264 kMaximumMessageSize
).utf8();
1266 Send(new ViewMsg_GetRenderedTextCompleted(routing_id(), text
));
1269 void RenderViewImpl::StartPluginIme() {
1270 IPC::Message
* msg
= new ViewHostMsg_StartPluginIme(routing_id());
1271 // This message can be sent during event-handling, and needs to be delivered
1272 // within that context.
1273 msg
->set_unblock(true);
1276 #endif // defined(OS_MACOSX)
1278 #endif // ENABLE_PLUGINS
1280 void RenderViewImpl::TransferActiveWheelFlingAnimation(
1281 const blink::WebActiveWheelFlingParameters
& params
) {
1283 webview()->transferActiveWheelFlingAnimation(params
);
1286 bool RenderViewImpl::HasIMETextFocus() {
1287 return GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE
;
1290 bool RenderViewImpl::OnMessageReceived(const IPC::Message
& message
) {
1291 WebFrame
* main_frame
= webview() ? webview()->mainFrame() : NULL
;
1292 if (main_frame
&& main_frame
->isWebLocalFrame())
1293 GetContentClient()->SetActiveURL(main_frame
->document().url());
1295 base::ObserverListBase
<RenderViewObserver
>::Iterator
it(&observers_
);
1296 RenderViewObserver
* observer
;
1297 while ((observer
= it
.GetNext()) != NULL
)
1298 if (observer
->OnMessageReceived(message
))
1301 bool handled
= true;
1302 IPC_BEGIN_MESSAGE_MAP(RenderViewImpl
, message
)
1303 IPC_MESSAGE_HANDLER(InputMsg_ExecuteEditCommand
, OnExecuteEditCommand
)
1304 IPC_MESSAGE_HANDLER(InputMsg_MoveCaret
, OnMoveCaret
)
1305 IPC_MESSAGE_HANDLER(InputMsg_ScrollFocusedEditableNodeIntoRect
,
1306 OnScrollFocusedEditableNodeIntoRect
)
1307 IPC_MESSAGE_HANDLER(InputMsg_SetEditCommandsForNextKeyEvent
,
1308 OnSetEditCommandsForNextKeyEvent
)
1309 IPC_MESSAGE_HANDLER(ViewMsg_CopyImageAt
, OnCopyImageAt
)
1310 IPC_MESSAGE_HANDLER(ViewMsg_SaveImageAt
, OnSaveImageAt
)
1311 IPC_MESSAGE_HANDLER(ViewMsg_Find
, OnFind
)
1312 IPC_MESSAGE_HANDLER(ViewMsg_StopFinding
, OnStopFinding
)
1313 IPC_MESSAGE_HANDLER(ViewMsg_ResetPageScale
, OnResetPageScale
)
1314 IPC_MESSAGE_HANDLER(ViewMsg_Zoom
, OnZoom
)
1315 IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForLoadingURL
,
1316 OnSetZoomLevelForLoadingURL
)
1317 IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForView
,
1318 OnSetZoomLevelForView
)
1319 IPC_MESSAGE_HANDLER(ViewMsg_SetPageEncoding
, OnSetPageEncoding
)
1320 IPC_MESSAGE_HANDLER(ViewMsg_ResetPageEncodingToDefault
,
1321 OnResetPageEncodingToDefault
)
1322 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter
, OnDragTargetDragEnter
)
1323 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver
, OnDragTargetDragOver
)
1324 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave
, OnDragTargetDragLeave
)
1325 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop
, OnDragTargetDrop
)
1326 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded
, OnDragSourceEnded
)
1327 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded
,
1328 OnDragSourceSystemDragEnded
)
1329 IPC_MESSAGE_HANDLER(ViewMsg_AllowBindings
, OnAllowBindings
)
1330 IPC_MESSAGE_HANDLER(ViewMsg_SetInitialFocus
, OnSetInitialFocus
)
1331 IPC_MESSAGE_HANDLER(ViewMsg_UpdateTargetURL_ACK
, OnUpdateTargetURLAck
)
1332 IPC_MESSAGE_HANDLER(ViewMsg_UpdateWebPreferences
, OnUpdateWebPreferences
)
1333 IPC_MESSAGE_HANDLER(ViewMsg_EnumerateDirectoryResponse
,
1334 OnEnumerateDirectoryResponse
)
1335 IPC_MESSAGE_HANDLER(ViewMsg_RunFileChooserResponse
, OnFileChooserResponse
)
1336 IPC_MESSAGE_HANDLER(ViewMsg_SuppressDialogsUntilSwapOut
,
1337 OnSuppressDialogsUntilSwapOut
)
1338 IPC_MESSAGE_HANDLER(ViewMsg_ClosePage
, OnClosePage
)
1339 IPC_MESSAGE_HANDLER(ViewMsg_ThemeChanged
, OnThemeChanged
)
1340 IPC_MESSAGE_HANDLER(ViewMsg_MoveOrResizeStarted
, OnMoveOrResizeStarted
)
1341 IPC_MESSAGE_HANDLER(ViewMsg_ClearFocusedElement
, OnClearFocusedElement
)
1342 IPC_MESSAGE_HANDLER(ViewMsg_SetBackgroundOpaque
, OnSetBackgroundOpaque
)
1343 IPC_MESSAGE_HANDLER(ViewMsg_EnablePreferredSizeChangedMode
,
1344 OnEnablePreferredSizeChangedMode
)
1345 IPC_MESSAGE_HANDLER(ViewMsg_EnableAutoResize
, OnEnableAutoResize
)
1346 IPC_MESSAGE_HANDLER(ViewMsg_DisableAutoResize
, OnDisableAutoResize
)
1347 IPC_MESSAGE_HANDLER(ViewMsg_DisableScrollbarsForSmallWindows
,
1348 OnDisableScrollbarsForSmallWindows
)
1349 IPC_MESSAGE_HANDLER(ViewMsg_SetRendererPrefs
, OnSetRendererPrefs
)
1350 IPC_MESSAGE_HANDLER(ViewMsg_MediaPlayerActionAt
, OnMediaPlayerActionAt
)
1351 IPC_MESSAGE_HANDLER(ViewMsg_PluginActionAt
, OnPluginActionAt
)
1352 IPC_MESSAGE_HANDLER(ViewMsg_SetActive
, OnSetActive
)
1353 IPC_MESSAGE_HANDLER(ViewMsg_GetAllSavableResourceLinksForCurrentPage
,
1354 OnGetAllSavableResourceLinksForCurrentPage
)
1355 IPC_MESSAGE_HANDLER(
1356 ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks
,
1357 OnGetSerializedHtmlDataForCurrentPageWithLocalLinks
)
1358 IPC_MESSAGE_HANDLER(ViewMsg_ShowContextMenu
, OnShowContextMenu
)
1359 // TODO(viettrungluu): Move to a separate message filter.
1360 IPC_MESSAGE_HANDLER(ViewMsg_SetHistoryOffsetAndLength
,
1361 OnSetHistoryOffsetAndLength
)
1362 IPC_MESSAGE_HANDLER(ViewMsg_EnableViewSourceMode
, OnEnableViewSourceMode
)
1363 IPC_MESSAGE_HANDLER(ViewMsg_ReleaseDisambiguationPopupBitmap
,
1364 OnReleaseDisambiguationPopupBitmap
)
1365 IPC_MESSAGE_HANDLER(ViewMsg_ForceRedraw
, OnForceRedraw
)
1366 IPC_MESSAGE_HANDLER(ViewMsg_SelectWordAroundCaret
, OnSelectWordAroundCaret
)
1367 #if defined(OS_ANDROID)
1368 IPC_MESSAGE_HANDLER(InputMsg_ActivateNearestFindResult
,
1369 OnActivateNearestFindResult
)
1370 IPC_MESSAGE_HANDLER(ViewMsg_FindMatchRects
, OnFindMatchRects
)
1371 IPC_MESSAGE_HANDLER(ViewMsg_UpdateTopControlsState
,
1372 OnUpdateTopControlsState
)
1373 IPC_MESSAGE_HANDLER(ViewMsg_ExtractSmartClipData
, OnExtractSmartClipData
)
1374 #elif defined(OS_MACOSX)
1375 IPC_MESSAGE_HANDLER(ViewMsg_GetRenderedText
,
1377 IPC_MESSAGE_HANDLER(ViewMsg_PluginImeCompositionCompleted
,
1378 OnPluginImeCompositionCompleted
)
1379 IPC_MESSAGE_HANDLER(ViewMsg_Close
, OnClose
)
1380 IPC_MESSAGE_HANDLER(ViewMsg_SetInLiveResize
, OnSetInLiveResize
)
1381 IPC_MESSAGE_HANDLER(ViewMsg_SetWindowVisibility
, OnSetWindowVisibility
)
1382 IPC_MESSAGE_HANDLER(ViewMsg_WindowFrameChanged
, OnWindowFrameChanged
)
1384 // Adding a new message? Add platform independent ones first, then put the
1385 // platform specific ones at the end.
1387 // Have the super handle all other messages.
1388 IPC_MESSAGE_UNHANDLED(handled
= RenderWidget::OnMessageReceived(message
))
1389 IPC_END_MESSAGE_MAP()
1394 void RenderViewImpl::OnSelectWordAroundCaret() {
1398 handling_input_event_
= true;
1399 webview()->focusedFrame()->selectWordAroundCaret();
1400 handling_input_event_
= false;
1403 void RenderViewImpl::OnCopyImageAt(int x
, int y
) {
1404 webview()->copyImageAt(WebPoint(x
, y
));
1407 void RenderViewImpl::OnSaveImageAt(int x
, int y
) {
1408 webview()->saveImageAt(WebPoint(x
, y
));
1411 void RenderViewImpl::OnUpdateTargetURLAck() {
1412 // Check if there is a targeturl waiting to be sent.
1413 if (target_url_status_
== TARGET_PENDING
)
1414 Send(new ViewHostMsg_UpdateTargetURL(routing_id_
, pending_target_url_
));
1416 target_url_status_
= TARGET_NONE
;
1419 void RenderViewImpl::OnExecuteEditCommand(const std::string
& name
,
1420 const std::string
& value
) {
1421 if (!webview() || !webview()->focusedFrame())
1424 webview()->focusedFrame()->executeCommand(
1425 WebString::fromUTF8(name
), WebString::fromUTF8(value
));
1428 void RenderViewImpl::OnMoveCaret(const gfx::Point
& point
) {
1432 Send(new InputHostMsg_MoveCaret_ACK(routing_id_
));
1434 webview()->focusedFrame()->moveCaretSelection(point
);
1437 void RenderViewImpl::OnScrollFocusedEditableNodeIntoRect(
1438 const gfx::Rect
& rect
) {
1439 if (has_scrolled_focused_editable_node_into_rect_
&&
1440 rect
== rect_for_scrolled_focused_editable_node_
) {
1441 FocusChangeComplete();
1445 blink::WebElement element
= GetFocusedElement();
1446 bool will_animate
= false;
1447 if (!element
.isNull() && element
.isEditable()) {
1448 rect_for_scrolled_focused_editable_node_
= rect
;
1449 has_scrolled_focused_editable_node_into_rect_
= true;
1450 will_animate
= webview()->scrollFocusedNodeIntoRect(rect
);
1454 FocusChangeComplete();
1457 void RenderViewImpl::OnSetEditCommandsForNextKeyEvent(
1458 const EditCommands
& edit_commands
) {
1459 edit_commands_
= edit_commands
;
1462 void RenderViewImpl::OnSetHistoryOffsetAndLength(int history_offset
,
1463 int history_length
) {
1464 DCHECK_GE(history_offset
, -1);
1465 DCHECK_GE(history_length
, 0);
1467 history_list_offset_
= history_offset
;
1468 history_list_length_
= history_length
;
1471 void RenderViewImpl::OnSetInitialFocus(bool reverse
) {
1474 webview()->setInitialFocus(reverse
);
1477 #if defined(OS_MACOSX)
1478 void RenderViewImpl::OnSetInLiveResize(bool in_live_resize
) {
1482 webview()->willStartLiveResize();
1484 webview()->willEndLiveResize();
1488 ///////////////////////////////////////////////////////////////////////////////
1490 void RenderViewImpl::SendUpdateState() {
1491 HistoryEntry
* entry
= history_controller_
->GetCurrentEntry();
1495 // Don't send state updates for kSwappedOutURL.
1496 if (entry
->root().urlString() == WebString::fromUTF8(kSwappedOutURL
))
1499 Send(new ViewHostMsg_UpdateState(
1500 routing_id_
, page_id_
, HistoryEntryToPageState(entry
)));
1503 void RenderViewImpl::ApplyWebPreferencesInternal(
1504 const WebPreferences
& prefs
,
1505 blink::WebView
* web_view
,
1506 CompositorDependencies
* compositor_deps
) {
1507 ApplyWebPreferences(prefs
, web_view
);
1508 #if defined(OS_MACOSX) && !defined(OS_IOS)
1509 DCHECK(compositor_deps
);
1510 bool is_elastic_overscroll_enabled
=
1511 compositor_deps
->IsElasticOverscrollEnabled();
1512 web_view
->settings()->setReportWheelOverscroll(is_elastic_overscroll_enabled
);
1516 bool RenderViewImpl::SendAndRunNestedMessageLoop(IPC::SyncMessage
* message
) {
1517 // Before WebKit asks us to show an alert (etc.), it takes care of doing the
1518 // equivalent of WebView::willEnterModalLoop. In the case of showModalDialog
1519 // it is particularly important that we do not call willEnterModalLoop as
1520 // that would defer resource loads for the dialog itself.
1521 if (RenderThreadImpl::current()) // Will be NULL during unit tests.
1522 RenderThreadImpl::current()->DoNotNotifyWebKitOfModalLoop();
1524 message
->EnableMessagePumping(); // Runs a nested message loop.
1525 return Send(message
);
1528 void RenderViewImpl::OnForceRedraw(int id
) {
1529 ui::LatencyInfo latency_info
;
1531 latency_info
.AddLatencyNumber(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT
,
1535 scoped_ptr
<cc::SwapPromiseMonitor
> latency_info_swap_promise_monitor
;
1536 if (RenderWidgetCompositor
* rwc
= compositor()) {
1537 latency_info_swap_promise_monitor
=
1538 rwc
->CreateLatencyInfoSwapPromiseMonitor(&latency_info
).Pass();
1540 ScheduleCompositeWithForcedRedraw();
1543 // blink::WebViewClient ------------------------------------------------------
1545 WebView
* RenderViewImpl::createView(WebLocalFrame
* creator
,
1546 const WebURLRequest
& request
,
1547 const WebWindowFeatures
& features
,
1548 const WebString
& frame_name
,
1549 WebNavigationPolicy policy
,
1550 bool suppress_opener
) {
1551 ViewHostMsg_CreateWindow_Params params
;
1552 params
.opener_id
= routing_id_
;
1553 params
.user_gesture
= WebUserGestureIndicator::isProcessingUserGesture();
1554 if (GetContentClient()->renderer()->AllowPopup())
1555 params
.user_gesture
= true;
1556 params
.window_container_type
= WindowFeaturesToContainerType(features
);
1557 params
.session_storage_namespace_id
= session_storage_namespace_id_
;
1558 if (frame_name
!= "_blank")
1559 params
.frame_name
= base::UTF16ToUTF8(base::StringPiece16(frame_name
));
1560 params
.opener_render_frame_id
=
1561 RenderFrameImpl::FromWebFrame(creator
)->GetRoutingID();
1562 params
.opener_url
= creator
->document().url();
1564 // The browser process uses the top frame's URL for a content settings check
1565 // to determine whether the popup is allowed. If the top frame is remote,
1566 // its URL is not available, so use its replicated origin instead.
1568 // TODO(alexmos): This works fine for regular origins but may break path
1569 // matching for file URLs with OOP subframes that open popups. This should
1570 // be fixed by either moving this lookup to the browser process or removing
1571 // path-based matching for file URLs from content settings. See
1572 // https://crbug.com/466297.
1573 if (creator
->top()->isWebLocalFrame()) {
1574 params
.opener_top_level_frame_url
= creator
->top()->document().url();
1576 params
.opener_top_level_frame_url
=
1577 GURL(creator
->top()->securityOrigin().toString());
1580 GURL
security_url(creator
->document().securityOrigin().toString());
1581 if (!security_url
.is_valid())
1582 security_url
= GURL();
1583 params
.opener_security_origin
= security_url
;
1584 params
.opener_suppressed
= suppress_opener
;
1585 params
.disposition
= NavigationPolicyToDisposition(policy
);
1586 if (!request
.isNull()) {
1587 params
.target_url
= request
.url();
1588 params
.referrer
= GetReferrerFromRequest(creator
, request
);
1590 params
.features
= features
;
1592 for (size_t i
= 0; i
< features
.additionalFeatures
.size(); ++i
)
1593 params
.additional_features
.push_back(features
.additionalFeatures
[i
]);
1595 int32 routing_id
= MSG_ROUTING_NONE
;
1596 int32 main_frame_routing_id
= MSG_ROUTING_NONE
;
1597 int32 surface_id
= 0;
1598 int64 cloned_session_storage_namespace_id
= 0;
1600 RenderThread::Get()->Send(new ViewHostMsg_CreateWindow(
1601 params
, &routing_id
, &main_frame_routing_id
, &surface_id
,
1602 &cloned_session_storage_namespace_id
));
1603 if (routing_id
== MSG_ROUTING_NONE
)
1606 WebUserGestureIndicator::consumeUserGesture();
1608 // While this view may be a background extension page, it can spawn a visible
1609 // render view. So we just assume that the new one is not another background
1610 // page instead of passing on our own value.
1611 // TODO(vangelis): Can we tell if the new view will be a background page?
1612 bool never_visible
= false;
1614 ViewMsg_Resize_Params initial_size
= ViewMsg_Resize_Params();
1615 initial_size
.screen_info
= screen_info_
;
1617 // The initial hidden state for the RenderViewImpl here has to match what the
1618 // browser will eventually decide for the given disposition. Since we have to
1619 // return from this call synchronously, we just have to make our best guess
1620 // and rely on the browser sending a WasHidden / WasShown message if it
1622 ViewMsg_New_Params view_params
;
1624 RenderFrameImpl
* creator_frame
= RenderFrameImpl::FromWebFrame(creator
);
1625 view_params
.opener_frame_route_id
= creator_frame
->GetRoutingID();
1626 DCHECK_EQ(routing_id_
, creator_frame
->render_view()->GetRoutingID());
1628 view_params
.window_was_created_with_opener
= true;
1629 view_params
.renderer_preferences
= renderer_preferences_
;
1630 view_params
.web_preferences
= webkit_preferences_
;
1631 view_params
.view_id
= routing_id
;
1632 view_params
.main_frame_routing_id
= main_frame_routing_id
;
1633 view_params
.surface_id
= surface_id
;
1634 view_params
.session_storage_namespace_id
=
1635 cloned_session_storage_namespace_id
;
1636 view_params
.swapped_out
= false;
1637 // WebCore will take care of setting the correct name.
1638 view_params
.replicated_frame_state
= FrameReplicationState();
1639 view_params
.proxy_routing_id
= MSG_ROUTING_NONE
;
1640 view_params
.hidden
= (params
.disposition
== NEW_BACKGROUND_TAB
);
1641 view_params
.never_visible
= never_visible
;
1642 view_params
.next_page_id
= 1;
1643 view_params
.initial_size
= initial_size
;
1644 view_params
.enable_auto_resize
= false;
1645 view_params
.min_size
= gfx::Size();
1646 view_params
.max_size
= gfx::Size();
1648 RenderViewImpl
* view
=
1649 RenderViewImpl::Create(compositor_deps_
, view_params
, true);
1650 view
->opened_by_user_gesture_
= params
.user_gesture
;
1652 // Record whether the creator frame is trying to suppress the opener field.
1653 view
->opener_suppressed_
= params
.opener_suppressed
;
1655 return view
->webview();
1658 WebWidget
* RenderViewImpl::createPopupMenu(blink::WebPopupType popup_type
) {
1659 RenderWidget
* widget
= RenderWidget::Create(routing_id_
, compositor_deps_
,
1660 popup_type
, screen_info_
);
1663 if (screen_metrics_emulator_
) {
1664 widget
->SetPopupOriginAdjustmentsForEmulation(
1665 screen_metrics_emulator_
.get());
1667 return widget
->webwidget();
1670 WebStorageNamespace
* RenderViewImpl::createSessionStorageNamespace() {
1671 CHECK(session_storage_namespace_id_
!= kInvalidSessionStorageNamespaceId
);
1672 return new WebStorageNamespaceImpl(session_storage_namespace_id_
);
1675 void RenderViewImpl::printPage(WebLocalFrame
* frame
) {
1676 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
,
1677 PrintPage(frame
, handling_input_event_
));
1680 void RenderViewImpl::saveImageFromDataURL(const blink::WebString
& data_url
) {
1681 // Note: We should basically send GURL but we use size-limited string instead
1682 // in order to send a larger data url to save a image for <canvas> or <img>.
1683 if (data_url
.length() < kMaxLengthOfDataURLString
)
1684 Send(new ViewHostMsg_SaveImageFromDataURL(
1685 routing_id_
, GetMainRenderFrame()->GetRoutingID(), data_url
.utf8()));
1688 bool RenderViewImpl::enumerateChosenDirectory(
1689 const WebString
& path
,
1690 WebFileChooserCompletion
* chooser_completion
) {
1691 int id
= enumeration_completion_id_
++;
1692 enumeration_completions_
[id
] = chooser_completion
;
1693 return Send(new ViewHostMsg_EnumerateDirectory(
1696 base::FilePath::FromUTF16Unsafe(path
)));
1699 void RenderViewImpl::FrameDidStartLoading(WebFrame
* frame
) {
1700 DCHECK_GE(frames_in_progress_
, 0);
1701 if (frames_in_progress_
== 0)
1702 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, DidStartLoading());
1703 frames_in_progress_
++;
1706 void RenderViewImpl::FrameDidStopLoading(WebFrame
* frame
) {
1707 // TODO(japhet): This should be a DCHECK, but the pdf plugin sometimes
1708 // calls DidStopLoading() without a matching DidStartLoading().
1709 if (frames_in_progress_
== 0)
1711 frames_in_progress_
--;
1712 if (frames_in_progress_
== 0) {
1713 DidStopLoadingIcons();
1714 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, DidStopLoading());
1718 void RenderViewImpl::SetZoomLevel(double zoom_level
) {
1719 webview()->setZoomLevel(zoom_level
);
1720 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, OnZoomLevelChanged());
1723 void RenderViewImpl::didCancelCompositionOnSelectionChange() {
1724 Send(new InputHostMsg_ImeCancelComposition(routing_id()));
1727 bool RenderViewImpl::handleCurrentKeyboardEvent() {
1728 if (edit_commands_
.empty())
1731 WebFrame
* frame
= webview()->focusedFrame();
1735 EditCommands::iterator it
= edit_commands_
.begin();
1736 EditCommands::iterator end
= edit_commands_
.end();
1738 bool did_execute_command
= false;
1739 for (; it
!= end
; ++it
) {
1740 // In gtk and cocoa, it's possible to bind multiple edit commands to one
1741 // key (but it's the exception). Once one edit command is not executed, it
1742 // seems safest to not execute the rest.
1743 if (!frame
->executeCommand(WebString::fromUTF8(it
->name
),
1744 WebString::fromUTF8(it
->value
),
1745 GetFocusedElement()))
1747 did_execute_command
= true;
1750 return did_execute_command
;
1753 bool RenderViewImpl::runFileChooser(
1754 const blink::WebFileChooserParams
& params
,
1755 WebFileChooserCompletion
* chooser_completion
) {
1756 // Do not open the file dialog in a hidden RenderView.
1759 FileChooserParams ipc_params
;
1760 if (params
.directory
)
1761 ipc_params
.mode
= FileChooserParams::UploadFolder
;
1762 else if (params
.multiSelect
)
1763 ipc_params
.mode
= FileChooserParams::OpenMultiple
;
1764 else if (params
.saveAs
)
1765 ipc_params
.mode
= FileChooserParams::Save
;
1767 ipc_params
.mode
= FileChooserParams::Open
;
1768 ipc_params
.title
= params
.title
;
1769 ipc_params
.default_file_name
=
1770 base::FilePath::FromUTF16Unsafe(params
.initialValue
).BaseName();
1771 ipc_params
.accept_types
.reserve(params
.acceptTypes
.size());
1772 for (size_t i
= 0; i
< params
.acceptTypes
.size(); ++i
)
1773 ipc_params
.accept_types
.push_back(params
.acceptTypes
[i
]);
1774 ipc_params
.need_local_path
= params
.needLocalPath
;
1775 #if defined(OS_ANDROID)
1776 ipc_params
.capture
= params
.useMediaCapture
;
1779 return ScheduleFileChooser(ipc_params
, chooser_completion
);
1782 void RenderViewImpl::SetValidationMessageDirection(
1783 base::string16
* wrapped_main_text
,
1784 blink::WebTextDirection main_text_hint
,
1785 base::string16
* wrapped_sub_text
,
1786 blink::WebTextDirection sub_text_hint
) {
1787 if (main_text_hint
== blink::WebTextDirectionLeftToRight
) {
1788 *wrapped_main_text
=
1789 base::i18n::GetDisplayStringInLTRDirectionality(*wrapped_main_text
);
1790 } else if (main_text_hint
== blink::WebTextDirectionRightToLeft
&&
1791 !base::i18n::IsRTL()) {
1792 base::i18n::WrapStringWithRTLFormatting(wrapped_main_text
);
1795 if (!wrapped_sub_text
->empty()) {
1796 if (sub_text_hint
== blink::WebTextDirectionLeftToRight
) {
1798 base::i18n::GetDisplayStringInLTRDirectionality(*wrapped_sub_text
);
1799 } else if (sub_text_hint
== blink::WebTextDirectionRightToLeft
) {
1800 base::i18n::WrapStringWithRTLFormatting(wrapped_sub_text
);
1805 void RenderViewImpl::showValidationMessage(
1806 const blink::WebRect
& anchor_in_root_view
,
1807 const blink::WebString
& main_text
,
1808 blink::WebTextDirection main_text_hint
,
1809 const blink::WebString
& sub_text
,
1810 blink::WebTextDirection sub_text_hint
) {
1811 base::string16 wrapped_main_text
= main_text
;
1812 base::string16 wrapped_sub_text
= sub_text
;
1814 SetValidationMessageDirection(
1815 &wrapped_main_text
, main_text_hint
, &wrapped_sub_text
, sub_text_hint
);
1817 Send(new ViewHostMsg_ShowValidationMessage(
1818 routing_id(), AdjustValidationMessageAnchor(anchor_in_root_view
),
1819 wrapped_main_text
, wrapped_sub_text
));
1822 void RenderViewImpl::hideValidationMessage() {
1823 Send(new ViewHostMsg_HideValidationMessage(routing_id()));
1826 void RenderViewImpl::moveValidationMessage(
1827 const blink::WebRect
& anchor_in_root_view
) {
1828 Send(new ViewHostMsg_MoveValidationMessage(
1829 routing_id(), AdjustValidationMessageAnchor(anchor_in_root_view
)));
1832 void RenderViewImpl::setStatusText(const WebString
& text
) {
1835 void RenderViewImpl::UpdateTargetURL(const GURL
& url
,
1836 const GURL
& fallback_url
) {
1837 GURL latest_url
= url
.is_empty() ? fallback_url
: url
;
1838 if (latest_url
== target_url_
)
1841 // Tell the browser to display a destination link.
1842 if (target_url_status_
== TARGET_INFLIGHT
||
1843 target_url_status_
== TARGET_PENDING
) {
1844 // If we have a request in-flight, save the URL to be sent when we
1845 // receive an ACK to the in-flight request. We can happily overwrite
1846 // any existing pending sends.
1847 pending_target_url_
= latest_url
;
1848 target_url_status_
= TARGET_PENDING
;
1850 // URLs larger than |MaxURLChars()| cannot be sent through IPC -
1851 // see |ParamTraits<GURL>|.
1852 if (latest_url
.possibly_invalid_spec().size() > GetMaxURLChars())
1853 latest_url
= GURL();
1854 Send(new ViewHostMsg_UpdateTargetURL(routing_id_
, latest_url
));
1855 target_url_
= latest_url
;
1856 target_url_status_
= TARGET_INFLIGHT
;
1860 gfx::RectF
RenderViewImpl::ClientRectToPhysicalWindowRect(
1861 const gfx::RectF
& rect
) const {
1862 gfx::RectF window_rect
= rect
;
1863 window_rect
.Scale(device_scale_factor_
* webview()->pageScaleFactor());
1867 void RenderViewImpl::StartNavStateSyncTimerIfNecessary() {
1869 if (send_content_state_immediately_
)
1871 else if (is_hidden())
1872 delay
= kDelaySecondsForContentStateSyncHidden
;
1874 delay
= kDelaySecondsForContentStateSync
;
1876 if (nav_state_sync_timer_
.IsRunning()) {
1877 // The timer is already running. If the delay of the timer maches the amount
1878 // we want to delay by, then return. Otherwise stop the timer so that it
1879 // gets started with the right delay.
1880 if (nav_state_sync_timer_
.GetCurrentDelay().InSeconds() == delay
)
1882 nav_state_sync_timer_
.Stop();
1885 nav_state_sync_timer_
.Start(FROM_HERE
, TimeDelta::FromSeconds(delay
), this,
1886 &RenderViewImpl::SendUpdateState
);
1889 void RenderViewImpl::setMouseOverURL(const WebURL
& url
) {
1890 mouse_over_url_
= GURL(url
);
1891 UpdateTargetURL(mouse_over_url_
, focus_url_
);
1894 void RenderViewImpl::setKeyboardFocusURL(const WebURL
& url
) {
1895 focus_url_
= GURL(url
);
1896 UpdateTargetURL(focus_url_
, mouse_over_url_
);
1899 void RenderViewImpl::startDragging(WebLocalFrame
* frame
,
1900 const WebDragData
& data
,
1901 WebDragOperationsMask mask
,
1902 const WebImage
& image
,
1903 const WebPoint
& webImageOffset
) {
1904 DropData
drop_data(DropDataBuilder::Build(data
));
1905 drop_data
.referrer_policy
= frame
->document().referrerPolicy();
1906 gfx::Vector2d
imageOffset(webImageOffset
.x
, webImageOffset
.y
);
1907 Send(new DragHostMsg_StartDragging(routing_id_
,
1910 image
.getSkBitmap(),
1912 possible_drag_event_info_
));
1915 bool RenderViewImpl::acceptsLoadDrops() {
1916 return renderer_preferences_
.can_accept_load_drops
;
1919 void RenderViewImpl::focusNext() {
1920 Send(new ViewHostMsg_TakeFocus(routing_id_
, false));
1923 void RenderViewImpl::focusPrevious() {
1924 Send(new ViewHostMsg_TakeFocus(routing_id_
, true));
1927 // TODO(esprehn): Blink only ever passes Elements, this should take WebElement.
1928 void RenderViewImpl::focusedNodeChanged(const WebNode
& fromNode
,
1929 const WebNode
& toNode
) {
1930 has_scrolled_focused_editable_node_into_rect_
= false;
1932 gfx::Rect node_bounds
;
1933 bool is_editable
= false;
1934 if (!toNode
.isNull() && toNode
.isElementNode()) {
1935 WebElement element
= const_cast<WebNode
&>(toNode
).to
<WebElement
>();
1936 node_bounds
= gfx::Rect(element
.boundsInViewportSpace());
1937 is_editable
= element
.isEditable();
1939 Send(new ViewHostMsg_FocusedNodeChanged(routing_id_
, is_editable
,
1942 // TODO(estade): remove.
1943 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, FocusedNodeChanged(toNode
));
1945 RenderFrameImpl
* previous_frame
= nullptr;
1946 if (!fromNode
.isNull())
1947 previous_frame
= RenderFrameImpl::FromWebFrame(fromNode
.document().frame());
1948 RenderFrameImpl
* new_frame
= nullptr;
1949 if (!toNode
.isNull())
1950 new_frame
= RenderFrameImpl::FromWebFrame(toNode
.document().frame());
1952 if (previous_frame
&& previous_frame
!= new_frame
)
1953 previous_frame
->FocusedNodeChanged(WebNode());
1955 new_frame
->FocusedNodeChanged(toNode
);
1957 // TODO(dmazzoni): remove once there's a separate a11y tree per frame.
1958 if (main_render_frame_
)
1959 main_render_frame_
->FocusedNodeChangedForAccessibility(toNode
);
1962 void RenderViewImpl::didUpdateLayout() {
1963 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, DidUpdateLayout());
1965 // We don't always want to set up a timer, only if we've been put in that
1966 // mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
1968 if (!send_preferred_size_changes_
|| !webview())
1971 if (check_preferred_size_timer_
.IsRunning())
1973 check_preferred_size_timer_
.Start(FROM_HERE
,
1974 TimeDelta::FromMilliseconds(0), this,
1975 &RenderViewImpl::CheckPreferredSize
);
1978 void RenderViewImpl::navigateBackForwardSoon(int offset
) {
1979 Send(new ViewHostMsg_GoToEntryAtOffset(routing_id_
, offset
));
1982 int RenderViewImpl::historyBackListCount() {
1983 return history_list_offset_
< 0 ? 0 : history_list_offset_
;
1986 int RenderViewImpl::historyForwardListCount() {
1987 return history_list_length_
- historyBackListCount() - 1;
1990 // blink::WebWidgetClient ----------------------------------------------------
1992 void RenderViewImpl::didFocus() {
1993 // TODO(jcivelli): when https://bugs.webkit.org/show_bug.cgi?id=33389 is fixed
1994 // we won't have to test for user gesture anymore and we can
1995 // move that code back to render_widget.cc
1996 if (WebUserGestureIndicator::isProcessingUserGesture() &&
1997 !RenderThreadImpl::current()->layout_test_mode()) {
1998 Send(new ViewHostMsg_Focus(routing_id_
));
2002 void RenderViewImpl::didBlur() {
2003 // TODO(jcivelli): see TODO above in didFocus().
2004 if (WebUserGestureIndicator::isProcessingUserGesture() &&
2005 !RenderThreadImpl::current()->layout_test_mode()) {
2006 Send(new ViewHostMsg_Blur(routing_id_
));
2010 // We are supposed to get a single call to Show for a newly created RenderView
2011 // that was created via RenderViewImpl::CreateWebView. So, we wait until this
2012 // point to dispatch the ShowView message.
2014 // This method provides us with the information about how to display the newly
2015 // created RenderView (i.e., as a blocked popup or as a new tab).
2017 void RenderViewImpl::show(WebNavigationPolicy policy
) {
2019 // When supports_multiple_windows is disabled, popups are reusing
2020 // the same view. In some scenarios, this makes WebKit to call show() twice.
2021 if (webkit_preferences_
.supports_multiple_windows
)
2022 NOTREACHED() << "received extraneous Show call";
2027 DCHECK(opener_id_
!= MSG_ROUTING_NONE
);
2029 // NOTE: initial_rect_ may still have its default values at this point, but
2030 // that's okay. It'll be ignored if disposition is not NEW_POPUP, or the
2031 // browser process will impose a default position otherwise.
2032 Send(new ViewHostMsg_ShowView(opener_id_
, routing_id_
,
2033 NavigationPolicyToDisposition(policy
), initial_rect_
,
2034 opened_by_user_gesture_
));
2035 SetPendingWindowRect(initial_rect_
);
2038 bool RenderViewImpl::requestPointerLock() {
2039 return mouse_lock_dispatcher_
->LockMouse(webwidget_mouse_lock_target_
.get());
2042 void RenderViewImpl::requestPointerUnlock() {
2043 mouse_lock_dispatcher_
->UnlockMouse(webwidget_mouse_lock_target_
.get());
2046 bool RenderViewImpl::isPointerLocked() {
2047 return mouse_lock_dispatcher_
->IsMouseLockedTo(
2048 webwidget_mouse_lock_target_
.get());
2051 void RenderViewImpl::onMouseDown(const WebNode
& mouse_down_node
) {
2053 RenderViewObserver
, observers_
, OnMouseDown(mouse_down_node
));
2056 void RenderViewImpl::didHandleGestureEvent(
2057 const WebGestureEvent
& event
,
2058 bool event_cancelled
) {
2059 RenderWidget::didHandleGestureEvent(event
, event_cancelled
);
2061 if (!event_cancelled
) {
2063 RenderViewObserver
, observers_
, DidHandleGestureEvent(event
));
2066 // TODO(ananta): Piggyback off existing IPCs to communicate this information,
2069 if (event
.type
!= blink::WebGestureEvent::GestureTap
)
2072 // TODO(estade): hit test the event against focused node to make sure
2073 // the tap actually hit the focused node.
2074 blink::WebTextInputType text_input_type
=
2075 GetWebView()->textInputInfo().type
;
2077 Send(new ViewHostMsg_FocusedNodeTouched(
2078 routing_id(), text_input_type
!= blink::WebTextInputTypeNone
));
2082 void RenderViewImpl::initializeLayerTreeView() {
2083 RenderWidget::initializeLayerTreeView();
2084 RenderWidgetCompositor
* rwc
= compositor();
2088 bool use_threaded_event_handling
= true;
2089 #if defined(OS_MACOSX) && !defined(OS_IOS)
2090 // Disable threaded event handling if content is not handling the elastic
2091 // overscroll effect. This includes the cases where the elastic overscroll
2092 // effect is being handled by Blink (because of command line flags) and older
2093 // operating system versions which do not have an elastic overscroll effect
2094 // (SnowLeopard, which has Aqua scrollbars which need synchronous updates).
2095 use_threaded_event_handling
= compositor_deps_
->IsElasticOverscrollEnabled();
2097 if (use_threaded_event_handling
) {
2098 RenderThreadImpl
* render_thread
= RenderThreadImpl::current();
2099 // render_thread may be NULL in tests.
2100 InputHandlerManager
* input_handler_manager
=
2101 render_thread
? render_thread
->input_handler_manager() : NULL
;
2102 if (input_handler_manager
) {
2103 input_handler_manager
->AddInputHandler(
2104 routing_id_
, rwc
->GetInputHandler(), AsWeakPtr());
2109 // blink::WebFrameClient -----------------------------------------------------
2111 void RenderViewImpl::Repaint(const gfx::Size
& size
) {
2115 void RenderViewImpl::SetEditCommandForNextKeyEvent(const std::string
& name
,
2116 const std::string
& value
) {
2117 EditCommands edit_commands
;
2118 edit_commands
.push_back(EditCommand(name
, value
));
2119 OnSetEditCommandsForNextKeyEvent(edit_commands
);
2122 void RenderViewImpl::ClearEditCommands() {
2123 edit_commands_
.clear();
2126 SSLStatus
RenderViewImpl::GetSSLStatusOfFrame(blink::WebFrame
* frame
) const {
2127 std::string security_info
;
2128 if (frame
&& frame
->dataSource())
2129 security_info
= frame
->dataSource()->response().securityInfo();
2132 CHECK(DeserializeSecurityInfo(security_info
, &result
));
2136 const std::string
& RenderViewImpl::GetAcceptLanguages() const {
2137 return renderer_preferences_
.accept_languages
;
2140 void RenderViewImpl::didChangeIcon(WebLocalFrame
* frame
,
2141 WebIconURL::Type icon_type
) {
2142 if (frame
->parent())
2145 WebVector
<WebIconURL
> icon_urls
= frame
->iconURLs(icon_type
);
2146 std::vector
<FaviconURL
> urls
;
2147 for (size_t i
= 0; i
< icon_urls
.size(); i
++) {
2148 std::vector
<gfx::Size
> sizes
;
2149 ConvertToFaviconSizes(icon_urls
[i
].sizes(), &sizes
);
2150 urls
.push_back(FaviconURL(
2151 icon_urls
[i
].iconURL(), ToFaviconType(icon_urls
[i
].iconType()), sizes
));
2153 SendUpdateFaviconURL(urls
);
2156 void RenderViewImpl::didUpdateCurrentHistoryItem(WebLocalFrame
* frame
) {
2157 StartNavStateSyncTimerIfNecessary();
2160 void RenderViewImpl::CheckPreferredSize() {
2161 // We don't always want to send the change messages over IPC, only if we've
2162 // been put in that mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
2164 if (!send_preferred_size_changes_
|| !webview())
2167 gfx::Size size
= webview()->contentsPreferredMinimumSize();
2168 if (size
== preferred_size_
)
2171 preferred_size_
= size
;
2172 Send(new ViewHostMsg_DidContentsPreferredSizeChange(routing_id_
,
2176 void RenderViewImpl::didChangeScrollOffset(WebLocalFrame
* frame
) {
2177 StartNavStateSyncTimerIfNecessary();
2180 void RenderViewImpl::SendFindReply(int request_id
,
2183 const WebRect
& selection_rect
,
2184 bool final_status_update
) {
2185 Send(new ViewHostMsg_Find_Reply(routing_id_
,
2190 final_status_update
));
2193 blink::WebString
RenderViewImpl::acceptLanguages() {
2194 return WebString::fromUTF8(renderer_preferences_
.accept_languages
);
2197 // blink::WebPageSerializerClient implementation ------------------------------
2199 void RenderViewImpl::didSerializeDataForFrame(
2200 const WebURL
& frame_url
,
2201 const WebCString
& data
,
2202 WebPageSerializerClient::PageSerializationStatus status
) {
2203 Send(new ViewHostMsg_SendSerializedHtmlData(
2207 static_cast<int32
>(status
)));
2210 // RenderView implementation ---------------------------------------------------
2212 bool RenderViewImpl::Send(IPC::Message
* message
) {
2213 return RenderWidget::Send(message
);
2216 RenderFrameImpl
* RenderViewImpl::GetMainRenderFrame() {
2217 return main_render_frame_
;
2220 int RenderViewImpl::GetRoutingID() const {
2224 gfx::Size
RenderViewImpl::GetSize() const {
2228 WebPreferences
& RenderViewImpl::GetWebkitPreferences() {
2229 return webkit_preferences_
;
2232 void RenderViewImpl::SetWebkitPreferences(const WebPreferences
& preferences
) {
2233 OnUpdateWebPreferences(preferences
);
2236 blink::WebView
* RenderViewImpl::GetWebView() {
2240 bool RenderViewImpl::ShouldDisplayScrollbars(int width
, int height
) const {
2241 return (!send_preferred_size_changes_
||
2242 (disable_scrollbars_size_limit_
.width() <= width
||
2243 disable_scrollbars_size_limit_
.height() <= height
));
2246 int RenderViewImpl::GetEnabledBindings() const {
2247 return enabled_bindings_
;
2250 bool RenderViewImpl::GetContentStateImmediately() const {
2251 return send_content_state_immediately_
;
2254 blink::WebPageVisibilityState
RenderViewImpl::GetVisibilityState() const {
2255 return visibilityState();
2258 void RenderViewImpl::DidStartLoading() {
2259 main_render_frame_
->didStartLoading(true);
2262 void RenderViewImpl::DidStopLoading() {
2263 main_render_frame_
->didStopLoading();
2266 blink::WebElement
RenderViewImpl::GetFocusedElement() const {
2268 return WebElement();
2269 WebFrame
* focused_frame
= webview()->focusedFrame();
2270 if (focused_frame
) {
2271 WebDocument doc
= focused_frame
->document();
2273 return doc
.focusedElement();
2276 return WebElement();
2279 blink::WebPlugin
* RenderViewImpl::GetWebPluginForFind() {
2283 WebFrame
* main_frame
= webview()->mainFrame();
2284 if (main_frame
->isWebLocalFrame() &&
2285 main_frame
->document().isPluginDocument())
2286 return webview()->mainFrame()->document().to
<WebPluginDocument
>().plugin();
2288 #if defined(ENABLE_PLUGINS)
2289 if (plugin_find_handler_
)
2290 return plugin_find_handler_
->container()->plugin();
2296 void RenderViewImpl::OnFind(int request_id
,
2297 const base::string16
& search_text
,
2298 const WebFindOptions
& options
) {
2299 WebFrame
* main_frame
= webview()->mainFrame();
2300 blink::WebPlugin
* plugin
= GetWebPluginForFind();
2301 // Check if the plugin still exists in the document.
2303 if (options
.findNext
) {
2304 // Just navigate back/forward.
2305 plugin
->selectFindResult(options
.forward
);
2307 if (!plugin
->startFind(
2308 search_text
, options
.matchCase
, request_id
)) {
2309 // Send "no results".
2310 SendFindReply(request_id
, 0, 0, gfx::Rect(), true);
2316 WebFrame
* frame_after_main
= main_frame
->traverseNext(true);
2317 WebFrame
* focused_frame
= webview()->focusedFrame();
2318 WebFrame
* search_frame
= focused_frame
; // start searching focused frame.
2320 bool multi_frame
= (frame_after_main
!= main_frame
);
2322 // If we have multiple frames, we don't want to wrap the search within the
2323 // frame, so we check here if we only have main_frame in the chain.
2324 bool wrap_within_frame
= !multi_frame
;
2326 WebRect selection_rect
;
2327 bool result
= false;
2329 // If something is selected when we start searching it means we cannot just
2330 // increment the current match ordinal; we need to re-generate it.
2331 WebRange current_selection
= focused_frame
->selectionRange();
2334 result
= search_frame
->find(
2335 request_id
, search_text
, options
, wrap_within_frame
, &selection_rect
);
2338 // don't leave text selected as you move to the next frame.
2339 search_frame
->executeCommand(WebString::fromUTF8("Unselect"),
2340 GetFocusedElement());
2342 // Find the next frame, but skip the invisible ones.
2344 // What is the next frame to search? (we might be going backwards). Note
2345 // that we specify wrap=true so that search_frame never becomes NULL.
2346 search_frame
= options
.forward
?
2347 search_frame
->traverseNext(true) :
2348 search_frame
->traversePrevious(true);
2349 } while (!search_frame
->hasVisibleContent() &&
2350 search_frame
!= focused_frame
);
2352 // Make sure selection doesn't affect the search operation in new frame.
2353 search_frame
->executeCommand(WebString::fromUTF8("Unselect"),
2354 GetFocusedElement());
2356 // If we have multiple frames and we have wrapped back around to the
2357 // focused frame, we need to search it once more allowing wrap within
2358 // the frame, otherwise it will report 'no match' if the focused frame has
2359 // reported matches, but no frames after the focused_frame contain a
2360 // match for the search word(s).
2361 if (multi_frame
&& search_frame
== focused_frame
) {
2362 result
= search_frame
->find(
2363 request_id
, search_text
, options
, true, // Force wrapping.
2368 webview()->setFocusedFrame(search_frame
);
2369 } while (!result
&& search_frame
!= focused_frame
);
2371 if (options
.findNext
&& current_selection
.isNull()) {
2372 // Force the main_frame to report the actual count.
2373 main_frame
->increaseMatchCount(0, request_id
);
2375 // If nothing is found, set result to "0 of 0", otherwise, set it to
2376 // "-1 of 1" to indicate that we found at least one item, but we don't know
2377 // yet what is active.
2378 int ordinal
= result
? -1 : 0; // -1 here means, we might know more later.
2379 int match_count
= result
? 1 : 0; // 1 here means possibly more coming.
2381 // If we find no matches then this will be our last status update.
2382 // Otherwise the scoping effort will send more results.
2383 bool final_status_update
= !result
;
2385 SendFindReply(request_id
, match_count
, ordinal
, selection_rect
,
2386 final_status_update
);
2388 // Scoping effort begins, starting with the mainframe.
2389 search_frame
= main_frame
;
2391 main_frame
->resetMatchCount();
2394 // Cancel all old scoping requests before starting a new one.
2395 search_frame
->cancelPendingScopingEffort();
2397 // We don't start another scoping effort unless at least one match has
2400 // Start new scoping request. If the scoping function determines that it
2401 // needs to scope, it will defer until later.
2402 search_frame
->scopeStringMatches(request_id
,
2405 true); // reset the tickmarks
2408 // Iterate to the next frame. The frame will not necessarily scope, for
2409 // example if it is not visible.
2410 search_frame
= search_frame
->traverseNext(true);
2411 } while (search_frame
!= main_frame
);
2415 void RenderViewImpl::OnStopFinding(StopFindAction action
) {
2416 WebView
* view
= webview();
2420 blink::WebPlugin
* plugin
= GetWebPluginForFind();
2426 bool clear_selection
= action
== STOP_FIND_ACTION_CLEAR_SELECTION
;
2427 if (clear_selection
) {
2428 view
->focusedFrame()->executeCommand(WebString::fromUTF8("Unselect"),
2429 GetFocusedElement());
2432 WebFrame
* frame
= view
->mainFrame();
2434 frame
->stopFinding(clear_selection
);
2435 frame
= frame
->traverseNext(false);
2438 if (action
== STOP_FIND_ACTION_ACTIVATE_SELECTION
) {
2439 WebFrame
* focused_frame
= view
->focusedFrame();
2440 if (focused_frame
) {
2441 WebDocument doc
= focused_frame
->document();
2442 if (!doc
.isNull()) {
2443 WebElement element
= doc
.focusedElement();
2444 if (!element
.isNull())
2445 element
.simulateClick();
2451 #if defined(OS_ANDROID)
2452 void RenderViewImpl::OnActivateNearestFindResult(int request_id
,
2457 WebFrame
* main_frame
= webview()->mainFrame();
2458 WebRect selection_rect
;
2459 int ordinal
= main_frame
->selectNearestFindMatch(WebFloatPoint(x
, y
),
2461 if (ordinal
== -1) {
2462 // Something went wrong, so send a no-op reply (force the main_frame to
2463 // report the current match count) in case the host is waiting for a
2464 // response due to rate-limiting).
2465 main_frame
->increaseMatchCount(0, request_id
);
2469 SendFindReply(request_id
,
2470 -1 /* number_of_matches */,
2473 true /* final_update */);
2476 void RenderViewImpl::OnFindMatchRects(int current_version
) {
2480 WebFrame
* main_frame
= webview()->mainFrame();
2481 std::vector
<gfx::RectF
> match_rects
;
2483 int rects_version
= main_frame
->findMatchMarkersVersion();
2484 if (current_version
!= rects_version
) {
2485 WebVector
<WebFloatRect
> web_match_rects
;
2486 main_frame
->findMatchRects(web_match_rects
);
2487 match_rects
.reserve(web_match_rects
.size());
2488 for (size_t i
= 0; i
< web_match_rects
.size(); ++i
)
2489 match_rects
.push_back(gfx::RectF(web_match_rects
[i
]));
2492 gfx::RectF active_rect
= main_frame
->activeFindMatchRect();
2493 Send(new ViewHostMsg_FindMatchRects_Reply(routing_id_
,
2500 void RenderViewImpl::OnResetPageScale() {
2503 webview()->setPageScaleFactor(1);
2506 void RenderViewImpl::OnZoom(PageZoom zoom
) {
2507 if (!webview()) // Not sure if this can happen, but no harm in being safe.
2510 webview()->hidePopups();
2512 double old_zoom_level
= webview()->zoomLevel();
2514 if (zoom
== PAGE_ZOOM_RESET
) {
2516 } else if (static_cast<int>(old_zoom_level
) == old_zoom_level
) {
2517 // Previous zoom level is a whole number, so just increment/decrement.
2518 zoom_level
= old_zoom_level
+ zoom
;
2520 // Either the user hit the zoom factor limit and thus the zoom level is now
2521 // not a whole number, or a plugin changed it to a custom value. We want
2522 // to go to the next whole number so that the user can always get back to
2523 // 100% with the keyboard/menu.
2524 if ((old_zoom_level
> 1 && zoom
> 0) ||
2525 (old_zoom_level
< 1 && zoom
< 0)) {
2526 zoom_level
= static_cast<int>(old_zoom_level
+ zoom
);
2528 // We're going towards 100%, so first go to the next whole number.
2529 zoom_level
= static_cast<int>(old_zoom_level
);
2532 SetZoomLevel(zoom_level
);
2536 void RenderViewImpl::OnSetZoomLevelForLoadingURL(const GURL
& url
,
2537 double zoom_level
) {
2538 #if !defined(OS_ANDROID)
2539 // On Android, page zoom isn't used, and in case of WebView, text zoom is used
2540 // for legacy WebView text scaling emulation. Thus, the code that resets
2541 // the zoom level from this map will be effectively resetting text zoom level.
2542 host_zoom_levels_
[url
] = zoom_level
;
2546 void RenderViewImpl::OnSetZoomLevelForView(bool uses_temporary_zoom_level
,
2548 uses_temporary_zoom_level_
= uses_temporary_zoom_level
;
2550 webview()->hidePopups();
2551 SetZoomLevel(level
);
2554 void RenderViewImpl::OnSetPageEncoding(const std::string
& encoding_name
) {
2555 webview()->setPageEncoding(WebString::fromUTF8(encoding_name
));
2558 void RenderViewImpl::OnResetPageEncodingToDefault() {
2559 WebString no_encoding
;
2560 webview()->setPageEncoding(no_encoding
);
2563 void RenderViewImpl::OnAllowBindings(int enabled_bindings_flags
) {
2564 if ((enabled_bindings_flags
& BINDINGS_POLICY_WEB_UI
) &&
2565 !(enabled_bindings_
& BINDINGS_POLICY_WEB_UI
)) {
2566 // WebUIExtensionData deletes itself when we're destroyed.
2567 new WebUIExtensionData(this);
2568 // WebUIMojo deletes itself when we're destroyed.
2569 new WebUIMojo(this);
2572 enabled_bindings_
|= enabled_bindings_flags
;
2574 // Keep track of the total bindings accumulated in this process.
2575 RenderProcess::current()->AddBindings(enabled_bindings_flags
);
2578 void RenderViewImpl::OnDragTargetDragEnter(const DropData
& drop_data
,
2579 const gfx::Point
& client_point
,
2580 const gfx::Point
& screen_point
,
2581 WebDragOperationsMask ops
,
2582 int key_modifiers
) {
2583 WebDragOperation operation
= webview()->dragTargetDragEnter(
2584 DropDataToWebDragData(drop_data
),
2590 Send(new DragHostMsg_UpdateDragCursor(routing_id_
, operation
));
2593 void RenderViewImpl::OnDragTargetDragOver(const gfx::Point
& client_point
,
2594 const gfx::Point
& screen_point
,
2595 WebDragOperationsMask ops
,
2596 int key_modifiers
) {
2597 WebDragOperation operation
= webview()->dragTargetDragOver(
2603 Send(new DragHostMsg_UpdateDragCursor(routing_id_
, operation
));
2606 void RenderViewImpl::OnDragTargetDragLeave() {
2607 webview()->dragTargetDragLeave();
2610 void RenderViewImpl::OnDragTargetDrop(const gfx::Point
& client_point
,
2611 const gfx::Point
& screen_point
,
2612 int key_modifiers
) {
2613 webview()->dragTargetDrop(client_point
, screen_point
, key_modifiers
);
2616 void RenderViewImpl::OnDragSourceEnded(const gfx::Point
& client_point
,
2617 const gfx::Point
& screen_point
,
2618 WebDragOperation op
) {
2619 webview()->dragSourceEndedAt(client_point
, screen_point
, op
);
2622 void RenderViewImpl::OnDragSourceSystemDragEnded() {
2623 webview()->dragSourceSystemDragEnded();
2626 void RenderViewImpl::OnUpdateWebPreferences(const WebPreferences
& prefs
) {
2627 webkit_preferences_
= prefs
;
2628 ApplyWebPreferencesInternal(webkit_preferences_
, webview(), compositor_deps_
);
2631 void RenderViewImpl::OnEnumerateDirectoryResponse(
2633 const std::vector
<base::FilePath
>& paths
) {
2634 if (!enumeration_completions_
[id
])
2637 WebVector
<WebString
> ws_file_names(paths
.size());
2638 for (size_t i
= 0; i
< paths
.size(); ++i
)
2639 ws_file_names
[i
] = paths
[i
].AsUTF16Unsafe();
2641 enumeration_completions_
[id
]->didChooseFile(ws_file_names
);
2642 enumeration_completions_
.erase(id
);
2645 void RenderViewImpl::OnFileChooserResponse(
2646 const std::vector
<content::FileChooserFileInfo
>& files
) {
2647 // This could happen if we navigated to a different page before the user
2648 // closed the chooser.
2649 if (file_chooser_completions_
.empty())
2652 // Convert Chrome's SelectedFileInfo list to WebKit's.
2653 WebVector
<WebFileChooserCompletion::SelectedFileInfo
> selected_files(
2655 for (size_t i
= 0; i
< files
.size(); ++i
) {
2656 WebFileChooserCompletion::SelectedFileInfo selected_file
;
2657 selected_file
.path
= files
[i
].file_path
.AsUTF16Unsafe();
2658 selected_file
.displayName
=
2659 base::FilePath(files
[i
].display_name
).AsUTF16Unsafe();
2660 if (files
[i
].file_system_url
.is_valid()) {
2661 selected_file
.fileSystemURL
= files
[i
].file_system_url
;
2662 selected_file
.length
= files
[i
].length
;
2663 selected_file
.modificationTime
= files
[i
].modification_time
.ToDoubleT();
2664 selected_file
.isDirectory
= files
[i
].is_directory
;
2666 selected_files
[i
] = selected_file
;
2669 if (file_chooser_completions_
.front()->completion
)
2670 file_chooser_completions_
.front()->completion
->didChooseFile(
2672 file_chooser_completions_
.pop_front();
2674 // If there are more pending file chooser requests, schedule one now.
2675 if (!file_chooser_completions_
.empty()) {
2676 Send(new ViewHostMsg_RunFileChooser(routing_id_
,
2677 file_chooser_completions_
.front()->params
));
2681 void RenderViewImpl::OnEnableAutoResize(const gfx::Size
& min_size
,
2682 const gfx::Size
& max_size
) {
2683 DCHECK(disable_scrollbars_size_limit_
.IsEmpty());
2686 auto_resize_mode_
= true;
2687 webview()->enableAutoResizeMode(min_size
, max_size
);
2690 void RenderViewImpl::OnDisableAutoResize(const gfx::Size
& new_size
) {
2691 DCHECK(disable_scrollbars_size_limit_
.IsEmpty());
2694 auto_resize_mode_
= false;
2695 webview()->disableAutoResizeMode();
2697 if (!new_size
.IsEmpty()) {
2699 physical_backing_size_
,
2700 top_controls_shrink_blink_size_
,
2701 top_controls_height_
,
2702 visible_viewport_size_
,
2704 is_fullscreen_granted_
,
2710 void RenderViewImpl::OnEnablePreferredSizeChangedMode() {
2711 if (send_preferred_size_changes_
)
2713 send_preferred_size_changes_
= true;
2715 // Start off with an initial preferred size notification (in case
2716 // |didUpdateLayout| was already called).
2720 void RenderViewImpl::OnDisableScrollbarsForSmallWindows(
2721 const gfx::Size
& disable_scrollbar_size_limit
) {
2722 disable_scrollbars_size_limit_
= disable_scrollbar_size_limit
;
2725 void RenderViewImpl::OnSetRendererPrefs(
2726 const RendererPreferences
& renderer_prefs
) {
2727 double old_zoom_level
= renderer_preferences_
.default_zoom_level
;
2728 std::string old_accept_languages
= renderer_preferences_
.accept_languages
;
2730 renderer_preferences_
= renderer_prefs
;
2732 UpdateFontRenderingFromRendererPrefs();
2735 #if defined(USE_DEFAULT_RENDER_THEME)
2736 if (renderer_prefs
.use_custom_colors
) {
2737 WebColorName name
= blink::WebColorWebkitFocusRingColor
;
2738 blink::setNamedColors(&name
, &renderer_prefs
.focus_ring_color
, 1);
2739 blink::setCaretBlinkInterval(renderer_prefs
.caret_blink_interval
);
2742 webview()->setSelectionColors(
2743 renderer_prefs
.active_selection_bg_color
,
2744 renderer_prefs
.active_selection_fg_color
,
2745 renderer_prefs
.inactive_selection_bg_color
,
2746 renderer_prefs
.inactive_selection_fg_color
);
2747 webview()->themeChanged();
2750 #endif // defined(USE_DEFAULT_RENDER_THEME)
2752 // If the zoom level for this page matches the old zoom default, and this
2753 // is not a plugin, update the zoom level to match the new default.
2754 if (webview() && webview()->mainFrame()->isWebLocalFrame() &&
2755 !webview()->mainFrame()->document().isPluginDocument() &&
2756 !ZoomValuesEqual(old_zoom_level
,
2757 renderer_preferences_
.default_zoom_level
) &&
2758 ZoomValuesEqual(webview()->zoomLevel(), old_zoom_level
)) {
2759 SetZoomLevel(renderer_preferences_
.default_zoom_level
);
2764 old_accept_languages
!= renderer_preferences_
.accept_languages
) {
2765 webview()->acceptLanguagesChanged();
2769 void RenderViewImpl::OnMediaPlayerActionAt(const gfx::Point
& location
,
2770 const WebMediaPlayerAction
& action
) {
2772 webview()->performMediaPlayerAction(action
, location
);
2775 void RenderViewImpl::OnOrientationChange() {
2776 if (webview() && webview()->mainFrame()->isWebLocalFrame())
2777 webview()->mainFrame()->toWebLocalFrame()->sendOrientationChangeEvent();
2780 void RenderViewImpl::OnPluginActionAt(const gfx::Point
& location
,
2781 const WebPluginAction
& action
) {
2783 webview()->performPluginAction(action
, location
);
2786 void RenderViewImpl::OnGetAllSavableResourceLinksForCurrentPage(
2787 const GURL
& page_url
) {
2788 // Prepare list to storage all savable resource links.
2789 std::vector
<GURL
> resources_list
;
2790 std::vector
<GURL
> referrer_urls_list
;
2791 std::vector
<blink::WebReferrerPolicy
> referrer_policies_list
;
2792 std::vector
<GURL
> frames_list
;
2793 SavableResourcesResult
result(&resources_list
,
2794 &referrer_urls_list
,
2795 &referrer_policies_list
,
2798 // webkit/ doesn't know about Referrer.
2799 if (!GetAllSavableResourceLinksForCurrentPage(
2803 const_cast<const char**>(GetSavableSchemes()))) {
2804 // If something is wrong when collecting all savable resource links,
2805 // send empty list to embedder(browser) to tell it failed.
2806 referrer_urls_list
.clear();
2807 referrer_policies_list
.clear();
2808 resources_list
.clear();
2809 frames_list
.clear();
2812 std::vector
<Referrer
> referrers_list
;
2813 CHECK_EQ(referrer_urls_list
.size(), referrer_policies_list
.size());
2814 for (unsigned i
= 0; i
< referrer_urls_list
.size(); ++i
) {
2815 referrers_list
.push_back(
2816 Referrer(referrer_urls_list
[i
], referrer_policies_list
[i
]));
2819 // Send result of all savable resource links to embedder.
2820 Send(new ViewHostMsg_SendCurrentPageAllSavableResourceLinks(routing_id(),
2826 void RenderViewImpl::OnGetSerializedHtmlDataForCurrentPageWithLocalLinks(
2827 const std::vector
<GURL
>& links
,
2828 const std::vector
<base::FilePath
>& local_paths
,
2829 const base::FilePath
& local_directory_name
) {
2831 // Convert std::vector of GURLs to WebVector<WebURL>
2832 WebVector
<WebURL
> weburl_links(links
);
2834 // Convert std::vector of base::FilePath to WebVector<WebString>
2835 WebVector
<WebString
> webstring_paths(local_paths
.size());
2836 for (size_t i
= 0; i
< local_paths
.size(); i
++)
2837 webstring_paths
[i
] = local_paths
[i
].AsUTF16Unsafe();
2839 WebPageSerializer::serialize(webview()->mainFrame()->toWebLocalFrame(),
2844 local_directory_name
.AsUTF16Unsafe());
2847 void RenderViewImpl::OnSuppressDialogsUntilSwapOut() {
2848 // Don't show any more dialogs until we finish OnSwapOut.
2849 suppress_dialogs_until_swap_out_
= true;
2852 void RenderViewImpl::OnClosePage() {
2853 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, ClosePage());
2854 // TODO(creis): We'd rather use webview()->Close() here, but that currently
2855 // sets the WebView's delegate_ to NULL, preventing any JavaScript dialogs
2856 // in the onunload handler from appearing. For now, we're bypassing that and
2857 // calling the FrameLoader's CloseURL method directly. This should be
2858 // revisited to avoid having two ways to close a page. Having a single way
2859 // to close that can run onunload is also useful for fixing
2860 // http://b/issue?id=753080.
2861 webview()->mainFrame()->dispatchUnloadEvent();
2863 Send(new ViewHostMsg_ClosePage_ACK(routing_id_
));
2866 void RenderViewImpl::OnClose() {
2868 RenderThread::Get()->Send(new ViewHostMsg_Close_ACK(routing_id_
));
2869 RenderWidget::OnClose();
2872 void RenderViewImpl::OnThemeChanged() {
2873 #if defined(USE_AURA)
2874 // Aura doesn't care if we switch themes.
2875 #elif defined(OS_WIN)
2876 ui::NativeThemeWin::instance()->CloseHandles();
2878 webview()->themeChanged();
2879 #else // defined(OS_WIN)
2880 // TODO(port): we don't support theming on non-Windows platforms yet
2885 void RenderViewImpl::OnMoveOrResizeStarted() {
2887 webview()->hidePopups();
2890 void RenderViewImpl::OnResize(const ViewMsg_Resize_Params
& params
) {
2891 TRACE_EVENT0("renderer", "RenderViewImpl::OnResize");
2893 webview()->hidePopups();
2894 if (send_preferred_size_changes_
) {
2895 webview()->mainFrame()->setCanHaveScrollbars(
2896 ShouldDisplayScrollbars(params
.new_size
.width(),
2897 params
.new_size
.height()));
2899 if (display_mode_
!= params
.display_mode
) {
2900 display_mode_
= params
.display_mode
;
2901 webview()->setDisplayMode(display_mode_
);
2905 gfx::Size old_visible_viewport_size
= visible_viewport_size_
;
2907 RenderWidget::OnResize(params
);
2909 if (old_visible_viewport_size
!= visible_viewport_size_
)
2910 has_scrolled_focused_editable_node_into_rect_
= false;
2913 void RenderViewImpl::DidInitiatePaint() {
2914 #if defined(ENABLE_PLUGINS)
2915 // Notify all instances that we painted. The same caveats apply as for
2916 // ViewFlushedPaint regarding instances closing themselves, so we take
2917 // similar precautions.
2918 PepperPluginSet plugins
= active_pepper_instances_
;
2919 for (PepperPluginSet::iterator i
= plugins
.begin(); i
!= plugins
.end(); ++i
) {
2920 if (active_pepper_instances_
.find(*i
) != active_pepper_instances_
.end())
2921 (*i
)->ViewInitiatedPaint();
2926 void RenderViewImpl::DidFlushPaint() {
2927 // If the RenderWidget is closing down then early-exit, otherwise we'll crash.
2928 // See crbug.com/112921.
2932 WebFrame
* main_frame
= webview()->mainFrame();
2933 for (WebFrame
* frame
= main_frame
; frame
;
2934 frame
= frame
->traverseNext(false)) {
2935 // TODO(nasko): This is a hack for the case in which the top-level
2936 // frame is being rendered in another process. It will not
2937 // behave correctly for out of process iframes.
2938 if (frame
->isWebLocalFrame()) {
2944 // There's nothing to do if there are no local frames in this RenderView's
2945 // frame tree. This can happen if DidFlushPaint is called after the
2946 // RenderView's local main frame is swapped to a remote frame. See
2947 // http://crbug.com/513552.
2948 if (main_frame
->isWebRemoteFrame())
2951 // If we have a provisional frame we are between the start and commit stages
2952 // of loading and we don't want to save stats.
2953 if (!main_frame
->provisionalDataSource()) {
2954 WebDataSource
* ds
= main_frame
->dataSource();
2958 DocumentState
* document_state
= DocumentState::FromDataSource(ds
);
2960 // TODO(jar): The following code should all be inside a method, probably in
2962 Time now
= Time::Now();
2963 if (document_state
->first_paint_time().is_null()) {
2964 document_state
->set_first_paint_time(now
);
2966 if (document_state
->first_paint_after_load_time().is_null() &&
2967 !document_state
->finish_load_time().is_null()) {
2968 document_state
->set_first_paint_after_load_time(now
);
2973 gfx::Vector2d
RenderViewImpl::GetScrollOffset() {
2974 WebFrame
* main_frame
= webview()->mainFrame();
2975 for (WebFrame
* frame
= main_frame
; frame
;
2976 frame
= frame
->traverseNext(false)) {
2977 // TODO(nasko): This is a hack for the case in which the top-level
2978 // frame is being rendered in another process. It will not
2979 // behave correctly for out of process iframes.
2980 if (frame
->isWebLocalFrame()) {
2986 WebSize scroll_offset
= main_frame
->scrollOffset();
2987 return gfx::Vector2d(scroll_offset
.width
, scroll_offset
.height
);
2990 void RenderViewImpl::OnClearFocusedElement() {
2992 webview()->clearFocusedElement();
2995 void RenderViewImpl::OnSetBackgroundOpaque(bool opaque
) {
2997 webview()->setIsTransparent(!opaque
);
2999 compositor_
->setHasTransparentBackground(!opaque
);
3002 void RenderViewImpl::OnSetActive(bool active
) {
3004 webview()->setIsActive(active
);
3006 #if defined(ENABLE_PLUGINS) && defined(OS_MACOSX)
3007 std::set
<WebPluginDelegateProxy
*>::iterator plugin_it
;
3008 for (plugin_it
= plugin_delegates_
.begin();
3009 plugin_it
!= plugin_delegates_
.end(); ++plugin_it
) {
3010 (*plugin_it
)->SetWindowFocus(active
);
3015 #if defined(OS_MACOSX)
3016 void RenderViewImpl::OnSetWindowVisibility(bool visible
) {
3017 #if defined(ENABLE_PLUGINS)
3018 // Inform plugins that their container has changed visibility.
3019 std::set
<WebPluginDelegateProxy
*>::iterator plugin_it
;
3020 for (plugin_it
= plugin_delegates_
.begin();
3021 plugin_it
!= plugin_delegates_
.end(); ++plugin_it
) {
3022 (*plugin_it
)->SetContainerVisibility(visible
);
3027 void RenderViewImpl::OnWindowFrameChanged(const gfx::Rect
& window_frame
,
3028 const gfx::Rect
& view_frame
) {
3029 #if defined(ENABLE_PLUGINS)
3030 // Inform plugins that their window's frame has changed.
3031 std::set
<WebPluginDelegateProxy
*>::iterator plugin_it
;
3032 for (plugin_it
= plugin_delegates_
.begin();
3033 plugin_it
!= plugin_delegates_
.end(); ++plugin_it
) {
3034 (*plugin_it
)->WindowFrameChanged(window_frame
, view_frame
);
3039 void RenderViewImpl::OnPluginImeCompositionCompleted(const base::string16
& text
,
3041 // WebPluginDelegateProxy is responsible for figuring out if this event
3042 // applies to it or not, so inform all the delegates.
3043 std::set
<WebPluginDelegateProxy
*>::iterator plugin_it
;
3044 for (plugin_it
= plugin_delegates_
.begin();
3045 plugin_it
!= plugin_delegates_
.end(); ++plugin_it
) {
3046 (*plugin_it
)->ImeCompositionCompleted(text
, plugin_id
);
3051 void RenderViewImpl::Close() {
3052 // We need to grab a pointer to the doomed WebView before we destroy it.
3053 WebView
* doomed
= webview();
3054 RenderWidget::Close();
3055 g_view_map
.Get().erase(doomed
);
3056 g_routing_id_view_map
.Get().erase(routing_id_
);
3057 RenderThread::Get()->Send(new ViewHostMsg_Close_ACK(routing_id_
));
3060 void RenderViewImpl::DidHandleKeyEvent() {
3061 ClearEditCommands();
3064 bool RenderViewImpl::WillHandleMouseEvent(const blink::WebMouseEvent
& event
) {
3065 possible_drag_event_info_
.event_source
=
3066 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE
;
3067 possible_drag_event_info_
.event_location
=
3068 gfx::Point(event
.globalX
, event
.globalY
);
3070 #if defined(ENABLE_PLUGINS)
3071 // This method is called for every mouse event that the render view receives.
3072 // And then the mouse event is forwarded to WebKit, which dispatches it to the
3073 // event target. Potentially a Pepper plugin will receive the event.
3074 // In order to tell whether a plugin gets the last mouse event and which it
3075 // is, we set |pepper_last_mouse_event_target_| to NULL here. If a plugin gets
3076 // the event, it will notify us via DidReceiveMouseEvent() and set itself as
3077 // |pepper_last_mouse_event_target_|.
3078 pepper_last_mouse_event_target_
= NULL
;
3081 // If the mouse is locked, only the current owner of the mouse lock can
3082 // process mouse events.
3083 return mouse_lock_dispatcher_
->WillHandleMouseEvent(event
);
3086 bool RenderViewImpl::WillHandleGestureEvent(
3087 const blink::WebGestureEvent
& event
) {
3088 possible_drag_event_info_
.event_source
=
3089 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH
;
3090 possible_drag_event_info_
.event_location
=
3091 gfx::Point(event
.globalX
, event
.globalY
);
3095 bool RenderViewImpl::HasTouchEventHandlersAt(const gfx::Point
& point
) const {
3098 return webview()->hasTouchEventHandlersAt(point
);
3101 void RenderViewImpl::OnWasHidden() {
3102 RenderWidget::OnWasHidden();
3104 #if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
3105 RenderThreadImpl::current()->video_capture_impl_manager()->
3106 SuspendDevices(true);
3107 if (speech_recognition_dispatcher_
)
3108 speech_recognition_dispatcher_
->AbortAllRecognitions();
3112 webview()->setVisibilityState(visibilityState(), false);
3114 #if defined(ENABLE_PLUGINS)
3115 for (PepperPluginSet::iterator i
= active_pepper_instances_
.begin();
3116 i
!= active_pepper_instances_
.end(); ++i
)
3117 (*i
)->PageVisibilityChanged(false);
3119 #if defined(OS_MACOSX)
3120 // Inform NPAPI plugins that their container is no longer visible.
3121 std::set
<WebPluginDelegateProxy
*>::iterator plugin_it
;
3122 for (plugin_it
= plugin_delegates_
.begin();
3123 plugin_it
!= plugin_delegates_
.end(); ++plugin_it
) {
3124 (*plugin_it
)->SetContainerVisibility(false);
3127 #endif // ENABLE_PLUGINS
3130 void RenderViewImpl::OnWasShown(bool needs_repainting
,
3131 const ui::LatencyInfo
& latency_info
) {
3132 RenderWidget::OnWasShown(needs_repainting
, latency_info
);
3134 #if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
3135 RenderThreadImpl::current()->video_capture_impl_manager()->
3136 SuspendDevices(false);
3140 webview()->setVisibilityState(visibilityState(), false);
3142 #if defined(ENABLE_PLUGINS)
3143 for (PepperPluginSet::iterator i
= active_pepper_instances_
.begin();
3144 i
!= active_pepper_instances_
.end(); ++i
)
3145 (*i
)->PageVisibilityChanged(true);
3147 #if defined(OS_MACOSX)
3148 // Inform NPAPI plugins that their container is now visible.
3149 std::set
<WebPluginDelegateProxy
*>::iterator plugin_it
;
3150 for (plugin_it
= plugin_delegates_
.begin();
3151 plugin_it
!= plugin_delegates_
.end(); ++plugin_it
) {
3152 (*plugin_it
)->SetContainerVisibility(true);
3155 #endif // ENABLE_PLUGINS
3158 GURL
RenderViewImpl::GetURLForGraphicsContext3D() {
3160 if (webview()->mainFrame()->isWebLocalFrame())
3161 return GURL(webview()->mainFrame()->document().url());
3163 return GURL("chrome://gpu/RenderViewImpl::CreateGraphicsContext3D");
3166 void RenderViewImpl::OnSetFocus(bool enable
) {
3167 RenderWidget::OnSetFocus(enable
);
3169 #if defined(ENABLE_PLUGINS)
3170 if (webview() && webview()->isActive()) {
3171 // Notify all NPAPI plugins.
3172 std::set
<WebPluginDelegateProxy
*>::iterator plugin_it
;
3173 for (plugin_it
= plugin_delegates_
.begin();
3174 plugin_it
!= plugin_delegates_
.end(); ++plugin_it
) {
3175 #if defined(OS_MACOSX)
3176 // RenderWidget's call to setFocus can cause the underlying webview's
3177 // activation state to change just like a call to setIsActive.
3179 (*plugin_it
)->SetWindowFocus(true);
3181 (*plugin_it
)->SetContentAreaFocus(enable
);
3184 // Notify all Pepper plugins.
3185 for (PepperPluginSet::iterator i
= active_pepper_instances_
.begin();
3186 i
!= active_pepper_instances_
.end(); ++i
)
3187 (*i
)->SetContentAreaFocus(enable
);
3189 // Notify all BrowserPlugins of the RenderView's focus state.
3190 if (BrowserPluginManager::Get())
3191 BrowserPluginManager::Get()->UpdateFocusState();
3194 void RenderViewImpl::OnImeSetComposition(
3195 const base::string16
& text
,
3196 const std::vector
<blink::WebCompositionUnderline
>& underlines
,
3197 int selection_start
,
3198 int selection_end
) {
3199 #if defined(ENABLE_PLUGINS)
3200 if (focused_pepper_plugin_
) {
3201 focused_pepper_plugin_
->render_frame()->OnImeSetComposition(
3202 text
, underlines
, selection_start
, selection_end
);
3207 // When a plugin has focus, we create platform-specific IME data used by
3208 // our IME emulator and send it directly to the focused plugin, i.e. we
3209 // bypass WebKit. (WebPluginDelegate dispatches this IME data only when its
3210 // instance ID is the same one as the specified ID.)
3211 if (focused_plugin_id_
>= 0) {
3212 std::vector
<int> clauses
;
3213 std::vector
<int> target
;
3214 for (size_t i
= 0; i
< underlines
.size(); ++i
) {
3215 clauses
.push_back(underlines
[i
].startOffset
);
3216 clauses
.push_back(underlines
[i
].endOffset
);
3217 if (underlines
[i
].thick
) {
3219 target
.push_back(underlines
[i
].startOffset
);
3220 target
.push_back(underlines
[i
].endOffset
);
3223 std::set
<WebPluginDelegateProxy
*>::iterator it
;
3224 for (it
= plugin_delegates_
.begin(); it
!= plugin_delegates_
.end(); ++it
) {
3225 (*it
)->ImeCompositionUpdated(text
, clauses
, target
, selection_end
,
3226 focused_plugin_id_
);
3231 #endif // ENABLE_PLUGINS
3232 RenderWidget::OnImeSetComposition(text
,
3238 void RenderViewImpl::OnImeConfirmComposition(
3239 const base::string16
& text
,
3240 const gfx::Range
& replacement_range
,
3241 bool keep_selection
) {
3242 #if defined(ENABLE_PLUGINS)
3243 if (focused_pepper_plugin_
) {
3244 focused_pepper_plugin_
->render_frame()->OnImeConfirmComposition(
3245 text
, replacement_range
, keep_selection
);
3249 // Same as OnImeSetComposition(), we send the text from IMEs directly to
3250 // plugins. When we send IME text directly to plugins, we should not send
3251 // it to WebKit to prevent WebKit from controlling IMEs.
3252 // TODO(thakis): Honor |replacement_range| for plugins?
3253 if (focused_plugin_id_
>= 0) {
3254 std::set
<WebPluginDelegateProxy
*>::iterator it
;
3255 for (it
= plugin_delegates_
.begin();
3256 it
!= plugin_delegates_
.end(); ++it
) {
3257 (*it
)->ImeCompositionCompleted(text
, focused_plugin_id_
);
3262 #endif // ENABLE_PLUGINS
3263 if (replacement_range
.IsValid() && webview()) {
3264 // Select the text in |replacement_range|, it will then be replaced by
3265 // text added by the call to RenderWidget::OnImeConfirmComposition().
3266 if (WebLocalFrame
* frame
= webview()->focusedFrame()->toWebLocalFrame()) {
3267 WebRange webrange
= WebRange::fromDocumentRange(
3268 frame
, replacement_range
.start(), replacement_range
.length());
3269 if (!webrange
.isNull())
3270 frame
->selectRange(webrange
);
3273 RenderWidget::OnImeConfirmComposition(text
,
3278 void RenderViewImpl::SetDeviceScaleFactor(float device_scale_factor
) {
3279 RenderWidget::SetDeviceScaleFactor(device_scale_factor
);
3281 webview()->setDeviceScaleFactor(device_scale_factor
);
3282 webview()->settings()->setPreferCompositingToLCDTextEnabled(
3283 PreferCompositingToLCDText(compositor_deps_
, device_scale_factor_
));
3285 if (auto_resize_mode_
)
3286 AutoResizeCompositor();
3289 bool RenderViewImpl::SetDeviceColorProfile(
3290 const std::vector
<char>& profile
) {
3291 bool changed
= RenderWidget::SetDeviceColorProfile(profile
);
3292 if (changed
&& webview()) {
3293 WebVector
<char> colorProfile
= profile
;
3294 webview()->setDeviceColorProfile(colorProfile
);
3299 void RenderViewImpl::ResetDeviceColorProfileForTesting() {
3300 RenderWidget::ResetDeviceColorProfileForTesting();
3302 webview()->resetDeviceColorProfile();
3305 ui::TextInputType
RenderViewImpl::GetTextInputType() {
3306 #if defined(ENABLE_PLUGINS)
3307 if (focused_pepper_plugin_
)
3308 return focused_pepper_plugin_
->text_input_type();
3310 return RenderWidget::GetTextInputType();
3313 void RenderViewImpl::GetSelectionBounds(gfx::Rect
* start
, gfx::Rect
* end
) {
3314 #if defined(ENABLE_PLUGINS)
3315 if (focused_pepper_plugin_
) {
3316 // TODO(kinaba) http://crbug.com/101101
3317 // Current Pepper IME API does not handle selection bounds. So we simply
3318 // use the caret position as an empty range for now. It will be updated
3319 // after Pepper API equips features related to surrounding text retrieval.
3320 gfx::Rect caret
= focused_pepper_plugin_
->GetCaretBounds();
3326 RenderWidget::GetSelectionBounds(start
, end
);
3329 void RenderViewImpl::FocusChangeComplete() {
3330 RenderWidget::FocusChangeComplete();
3331 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, FocusChangeComplete());
3334 void RenderViewImpl::GetCompositionCharacterBounds(
3335 std::vector
<gfx::Rect
>* bounds
) {
3339 #if defined(ENABLE_PLUGINS)
3340 if (focused_pepper_plugin_
) {
3347 size_t start_offset
= 0;
3348 size_t character_count
= 0;
3349 if (!webview()->compositionRange(&start_offset
, &character_count
))
3351 if (character_count
== 0)
3354 blink::WebFrame
* frame
= webview()->focusedFrame();
3358 bounds
->reserve(character_count
);
3359 blink::WebRect webrect
;
3360 for (size_t i
= 0; i
< character_count
; ++i
) {
3361 if (!frame
->firstRectForCharacterRange(start_offset
+ i
, 1, webrect
)) {
3362 DLOG(ERROR
) << "Could not retrieve character rectangle at " << i
;
3366 bounds
->push_back(webrect
);
3370 void RenderViewImpl::GetCompositionRange(gfx::Range
* range
) {
3371 #if defined(ENABLE_PLUGINS)
3372 if (focused_pepper_plugin_
) {
3376 RenderWidget::GetCompositionRange(range
);
3379 bool RenderViewImpl::CanComposeInline() {
3380 #if defined(ENABLE_PLUGINS)
3381 if (focused_pepper_plugin_
)
3382 return focused_pepper_plugin_
->IsPluginAcceptingCompositionEvents();
3387 void RenderViewImpl::DidCompletePageScaleAnimation() {
3388 FocusChangeComplete();
3391 #if defined(OS_ANDROID)
3392 bool RenderViewImpl::DoesRecordFullLayer() const {
3393 return webkit_preferences_
.record_whole_document
;
3397 void RenderViewImpl::SetScreenMetricsEmulationParameters(
3399 const blink::WebDeviceEmulationParams
& params
) {
3400 if (webview() && compositor()) {
3402 webview()->enableDeviceEmulation(params
);
3404 webview()->disableDeviceEmulation();
3408 bool RenderViewImpl::ScheduleFileChooser(
3409 const FileChooserParams
& params
,
3410 WebFileChooserCompletion
* completion
) {
3411 static const size_t kMaximumPendingFileChooseRequests
= 4;
3412 if (file_chooser_completions_
.size() > kMaximumPendingFileChooseRequests
) {
3413 // This sanity check prevents too many file choose requests from getting
3414 // queued which could DoS the user. Getting these is most likely a
3415 // programming error (there are many ways to DoS the user so it's not
3416 // considered a "real" security check), either in JS requesting many file
3417 // choosers to pop up, or in a plugin.
3419 // TODO(brettw) we might possibly want to require a user gesture to open
3420 // a file picker, which will address this issue in a better way.
3424 file_chooser_completions_
.push_back(linked_ptr
<PendingFileChooser
>(
3425 new PendingFileChooser(params
, completion
)));
3426 if (file_chooser_completions_
.size() == 1) {
3427 // Actually show the browse dialog when this is the first request.
3428 Send(new ViewHostMsg_RunFileChooser(routing_id_
, params
));
3433 blink::WebSpeechRecognizer
* RenderViewImpl::speechRecognizer() {
3434 if (!speech_recognition_dispatcher_
)
3435 speech_recognition_dispatcher_
= new SpeechRecognitionDispatcher(this);
3436 return speech_recognition_dispatcher_
;
3439 void RenderViewImpl::zoomLimitsChanged(double minimum_level
,
3440 double maximum_level
) {
3441 // Round the double to avoid returning incorrect minimum/maximum zoom
3443 int minimum_percent
= round(
3444 ZoomLevelToZoomFactor(minimum_level
) * 100);
3445 int maximum_percent
= round(
3446 ZoomLevelToZoomFactor(maximum_level
) * 100);
3448 Send(new ViewHostMsg_UpdateZoomLimits(
3449 routing_id_
, minimum_percent
, maximum_percent
));
3452 void RenderViewImpl::zoomLevelChanged() {
3453 double zoom_level
= webview()->zoomLevel();
3455 // Do not send empty URLs to the browser when we are just setting the default
3456 // zoom level (from RendererPreferences) before the first navigation.
3457 if (!webview()->mainFrame()->document().url().isEmpty()) {
3458 // Tell the browser which url got zoomed so it can update the menu and the
3459 // saved values if necessary
3460 Send(new ViewHostMsg_DidZoomURL(
3461 routing_id_
, zoom_level
,
3462 GURL(webview()->mainFrame()->document().url())));
3466 void RenderViewImpl::pageScaleFactorChanged() {
3469 bool page_scale_factor_is_one
= webview()->pageScaleFactor() == 1;
3470 if (page_scale_factor_is_one
== page_scale_factor_is_one_
)
3472 page_scale_factor_is_one_
= page_scale_factor_is_one
;
3473 Send(new ViewHostMsg_PageScaleFactorIsOneChanged(routing_id_
,
3474 page_scale_factor_is_one_
));
3477 double RenderViewImpl::zoomLevelToZoomFactor(double zoom_level
) const {
3478 return ZoomLevelToZoomFactor(zoom_level
);
3481 double RenderViewImpl::zoomFactorToZoomLevel(double factor
) const {
3482 return ZoomFactorToZoomLevel(factor
);
3485 blink::WebPageVisibilityState
RenderViewImpl::visibilityState() const {
3486 blink::WebPageVisibilityState current_state
= is_hidden() ?
3487 blink::WebPageVisibilityStateHidden
:
3488 blink::WebPageVisibilityStateVisible
;
3489 blink::WebPageVisibilityState override_state
= current_state
;
3490 // TODO(jam): move this method to WebFrameClient.
3491 if (GetContentClient()->renderer()->
3492 ShouldOverridePageVisibilityState(main_render_frame_
,
3494 return override_state
;
3495 return current_state
;
3498 void RenderViewImpl::draggableRegionsChanged() {
3502 DraggableRegionsChanged(webview()->mainFrame()));
3505 #if defined(OS_ANDROID)
3506 WebContentDetectionResult
RenderViewImpl::detectContentAround(
3507 const WebHitTestResult
& touch_hit
) {
3508 DCHECK(touch_hit
.node().isTextNode());
3510 // Process the position with all the registered content detectors until
3511 // a match is found. Priority is provided by their relative order.
3512 for (ContentDetectorList::const_iterator it
= content_detectors_
.begin();
3513 it
!= content_detectors_
.end(); ++it
) {
3514 ContentDetector::Result content
= (*it
)->FindTappedContent(touch_hit
);
3515 if (content
.valid
) {
3516 return WebContentDetectionResult(content
.content_boundaries
,
3517 base::UTF8ToUTF16(content
.text
), content
.intent_url
);
3520 return WebContentDetectionResult();
3523 void RenderViewImpl::scheduleContentIntent(const WebURL
& intent
) {
3524 // Introduce a short delay so that the user can notice the content.
3525 base::MessageLoop::current()->PostDelayedTask(
3527 base::Bind(&RenderViewImpl::LaunchAndroidContentIntent
,
3530 expected_content_intent_id_
),
3531 base::TimeDelta::FromMilliseconds(kContentIntentDelayMilliseconds
));
3534 void RenderViewImpl::cancelScheduledContentIntents() {
3535 ++expected_content_intent_id_
;
3538 void RenderViewImpl::LaunchAndroidContentIntent(const GURL
& intent
,
3539 size_t request_id
) {
3540 if (request_id
!= expected_content_intent_id_
)
3543 // Remove the content highlighting if any.
3544 ScheduleComposite();
3546 if (!intent
.is_empty())
3547 Send(new ViewHostMsg_StartContentIntent(routing_id_
, intent
));
3550 bool RenderViewImpl::openDateTimeChooser(
3551 const blink::WebDateTimeChooserParams
& params
,
3552 blink::WebDateTimeChooserCompletion
* completion
) {
3553 // JavaScript may try to open a date time chooser while one is already open.
3554 if (date_time_picker_client_
)
3556 date_time_picker_client_
.reset(
3557 new RendererDateTimePicker(this, params
, completion
));
3558 return date_time_picker_client_
->Open();
3561 void RenderViewImpl::DismissDateTimeDialog() {
3562 DCHECK(date_time_picker_client_
);
3563 date_time_picker_client_
.reset(NULL
);
3566 #endif // defined(OS_ANDROID)
3568 void RenderViewImpl::OnShowContextMenu(
3569 ui::MenuSourceType source_type
, const gfx::Point
& location
) {
3570 context_menu_source_type_
= source_type
;
3571 has_host_context_menu_location_
= true;
3572 host_context_menu_location_
= location
;
3574 webview()->showContextMenu();
3575 has_host_context_menu_location_
= false;
3578 void RenderViewImpl::OnEnableViewSourceMode() {
3581 WebFrame
* main_frame
= webview()->mainFrame();
3584 main_frame
->enableViewSourceMode(true);
3587 #if defined(OS_ANDROID) || defined(USE_AURA)
3588 bool RenderViewImpl::didTapMultipleTargets(
3589 const WebSize
& inner_viewport_offset
,
3590 const WebRect
& touch_rect
,
3591 const WebVector
<WebRect
>& target_rects
) {
3592 DCHECK(switches::IsLinkDisambiguationPopupEnabled());
3594 // Never show a disambiguation popup when accessibility is enabled,
3595 // as this interferes with "touch exploration".
3596 AccessibilityMode accessibility_mode
=
3597 GetMainRenderFrame()->accessibility_mode();
3598 bool matches_accessibility_mode_complete
=
3599 (accessibility_mode
& AccessibilityModeComplete
) ==
3600 AccessibilityModeComplete
;
3601 if (matches_accessibility_mode_complete
)
3604 // The touch_rect, target_rects and zoom_rect are in the outer viewport
3606 gfx::Rect zoom_rect
;
3607 float new_total_scale
=
3608 DisambiguationPopupHelper::ComputeZoomAreaAndScaleFactor(
3609 touch_rect
, target_rects
, GetSize(),
3610 gfx::Rect(webview()->mainFrame()->visibleContentRect()).size(),
3611 device_scale_factor_
* webview()->pageScaleFactor(), &zoom_rect
);
3612 if (!new_total_scale
|| zoom_rect
.IsEmpty())
3615 bool handled
= false;
3616 switch (renderer_preferences_
.tap_multiple_targets_strategy
) {
3617 case TAP_MULTIPLE_TARGETS_STRATEGY_ZOOM
:
3618 handled
= webview()->zoomToMultipleTargetsRect(zoom_rect
);
3620 case TAP_MULTIPLE_TARGETS_STRATEGY_POPUP
: {
3621 gfx::Size canvas_size
=
3622 gfx::ToCeiledSize(gfx::ScaleSize(zoom_rect
.size(), new_total_scale
));
3623 cc::SharedBitmapManager
* manager
=
3624 RenderThreadImpl::current()->shared_bitmap_manager();
3625 scoped_ptr
<cc::SharedBitmap
> shared_bitmap
=
3626 manager
->AllocateSharedBitmap(canvas_size
);
3627 CHECK(!!shared_bitmap
);
3630 SkImageInfo info
= SkImageInfo::MakeN32Premul(canvas_size
.width(),
3631 canvas_size
.height());
3632 bitmap
.installPixels(info
, shared_bitmap
->pixels(), info
.minRowBytes());
3633 SkCanvas
canvas(bitmap
);
3635 // TODO(trchen): Cleanup the device scale factor mess.
3636 // device scale will be applied in WebKit
3637 // --> zoom_rect doesn't include device scale,
3638 // but WebKit will still draw on zoom_rect * device_scale_factor_
3639 canvas
.scale(new_total_scale
/ device_scale_factor_
,
3640 new_total_scale
/ device_scale_factor_
);
3641 canvas
.translate(-zoom_rect
.x() * device_scale_factor_
,
3642 -zoom_rect
.y() * device_scale_factor_
);
3644 DCHECK(webwidget_
->isAcceleratedCompositingActive());
3645 // TODO(aelias): The disambiguation popup should be composited so we
3646 // don't have to call this method.
3647 webwidget_
->paintCompositedDeprecated(&canvas
, zoom_rect
);
3650 gfx::Rect zoom_rect_in_screen
=
3651 zoom_rect
- gfx::Vector2d(inner_viewport_offset
.width
,
3652 inner_viewport_offset
.height
);
3654 gfx::Rect physical_window_zoom_rect
= gfx::ToEnclosingRect(
3655 ClientRectToPhysicalWindowRect(gfx::RectF(zoom_rect_in_screen
)));
3657 Send(new ViewHostMsg_ShowDisambiguationPopup(routing_id_
,
3658 physical_window_zoom_rect
,
3660 shared_bitmap
->id()));
3661 cc::SharedBitmapId id
= shared_bitmap
->id();
3662 disambiguation_bitmaps_
[id
] = shared_bitmap
.release();
3666 case TAP_MULTIPLE_TARGETS_STRATEGY_NONE
:
3673 #endif // defined(OS_ANDROID) || defined(USE_AURA)
3675 unsigned RenderViewImpl::GetLocalSessionHistoryLengthForTesting() const {
3676 return history_list_length_
;
3679 void RenderViewImpl::SetFocusAndActivateForTesting(bool enable
) {
3693 void RenderViewImpl::SetDeviceScaleFactorForTesting(float factor
) {
3694 ViewMsg_Resize_Params params
;
3695 params
.screen_info
= screen_info_
;
3696 params
.screen_info
.deviceScaleFactor
= factor
;
3697 params
.new_size
= size();
3698 params
.visible_viewport_size
= visible_viewport_size_
;
3699 params
.physical_backing_size
=
3700 gfx::ToCeiledSize(gfx::ScaleSize(size(), factor
));
3701 params
.top_controls_shrink_blink_size
= false;
3702 params
.top_controls_height
= 0.f
;
3703 params
.resizer_rect
= WebRect();
3704 params
.is_fullscreen_granted
= is_fullscreen_granted();
3705 params
.display_mode
= display_mode_
;
3709 void RenderViewImpl::SetDeviceColorProfileForTesting(
3710 const std::vector
<char>& color_profile
) {
3711 SetDeviceColorProfile(color_profile
);
3714 void RenderViewImpl::ForceResizeForTesting(const gfx::Size
& new_size
) {
3715 gfx::Rect
new_window_rect(rootWindowRect().x
,
3719 SetWindowRectSynchronously(new_window_rect
);
3722 void RenderViewImpl::UseSynchronousResizeModeForTesting(bool enable
) {
3723 resizing_mode_selector_
->set_is_synchronous_mode(enable
);
3726 void RenderViewImpl::EnableAutoResizeForTesting(const gfx::Size
& min_size
,
3727 const gfx::Size
& max_size
) {
3728 OnEnableAutoResize(min_size
, max_size
);
3731 void RenderViewImpl::DisableAutoResizeForTesting(const gfx::Size
& new_size
) {
3732 OnDisableAutoResize(new_size
);
3735 void RenderViewImpl::OnReleaseDisambiguationPopupBitmap(
3736 const cc::SharedBitmapId
& id
) {
3737 BitmapMap::iterator it
= disambiguation_bitmaps_
.find(id
);
3738 DCHECK(it
!= disambiguation_bitmaps_
.end());
3740 disambiguation_bitmaps_
.erase(it
);
3743 void RenderViewImpl::DidCommitCompositorFrame() {
3744 RenderWidget::DidCommitCompositorFrame();
3745 FOR_EACH_OBSERVER(RenderViewObserver
, observers_
, DidCommitCompositorFrame());
3748 void RenderViewImpl::SendUpdateFaviconURL(const std::vector
<FaviconURL
>& urls
) {
3750 Send(new ViewHostMsg_UpdateFaviconURL(routing_id_
, urls
));
3753 void RenderViewImpl::DidStopLoadingIcons() {
3754 int icon_types
= WebIconURL::TypeFavicon
| WebIconURL::TypeTouchPrecomposed
|
3755 WebIconURL::TypeTouch
;
3757 // Favicons matter only for the top-level frame. If it is a WebRemoteFrame,
3758 // just return early.
3759 if (webview()->mainFrame()->isWebRemoteFrame())
3762 WebVector
<WebIconURL
> icon_urls
=
3763 webview()->mainFrame()->iconURLs(icon_types
);
3765 std::vector
<FaviconURL
> urls
;
3766 for (size_t i
= 0; i
< icon_urls
.size(); i
++) {
3767 WebURL url
= icon_urls
[i
].iconURL();
3768 std::vector
<gfx::Size
> sizes
;
3769 ConvertToFaviconSizes(icon_urls
[i
].sizes(), &sizes
);
3772 FaviconURL(url
, ToFaviconType(icon_urls
[i
].iconType()), sizes
));
3774 SendUpdateFaviconURL(urls
);
3777 } // namespace content