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.
4
5 #include "content/renderer/render_view_impl.h"
6
7 #include <algorithm>
8 #include <cmath>
9
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/debug/trace_event.h"
17 #include "base/files/file_path.h"
18 #include "base/i18n/rtl.h"
19 #include "base/json/json_writer.h"
20 #include "base/lazy_instance.h"
21 #include "base/memory/scoped_ptr.h"
22 #include "base/message_loop/message_loop_proxy.h"
23 #include "base/metrics/histogram.h"
24 #include "base/path_service.h"
25 #include "base/process/kill.h"
26 #include "base/process/process.h"
27 #include "base/strings/string_number_conversions.h"
28 #include "base/strings/string_piece.h"
29 #include "base/strings/string_split.h"
30 #include "base/strings/string_util.h"
31 #include "base/strings/sys_string_conversions.h"
32 #include "base/strings/utf_string_conversions.h"
33 #include "base/time/time.h"
34 #include "cc/base/switches.h"
35 #include "content/child/appcache/appcache_dispatcher.h"
36 #include "content/child/appcache/web_application_cache_host_impl.h"
37 #include "content/child/child_thread.h"
38 #include "content/child/npapi/webplugin_delegate_impl.h"
39 #include "content/child/request_extra_data.h"
40 #include "content/child/webmessageportchannel_impl.h"
41 #include "content/common/clipboard_messages.h"
42 #include "content/common/database_messages.h"
43 #include "content/common/dom_storage/dom_storage_types.h"
44 #include "content/common/drag_messages.h"
45 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
46 #include "content/common/input_messages.h"
47 #include "content/common/java_bridge_messages.h"
48 #include "content/common/pepper_messages.h"
49 #include "content/common/socket_stream_handle_data.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/context_menu_params.h"
57 #include "content/public/common/drop_data.h"
58 #include "content/public/common/favicon_url.h"
59 #include "content/public/common/file_chooser_params.h"
60 #include "content/public/common/page_zoom.h"
61 #include "content/public/common/ssl_status.h"
62 #include "content/public/common/three_d_api_types.h"
63 #include "content/public/common/url_constants.h"
64 #include "content/public/common/url_utils.h"
65 #include "content/public/renderer/content_renderer_client.h"
66 #include "content/public/renderer/context_menu_client.h"
67 #include "content/public/renderer/document_state.h"
68 #include "content/public/renderer/history_item_serialization.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/public/renderer/web_preferences.h"
73 #include "content/renderer/accessibility/renderer_accessibility.h"
74 #include "content/renderer/accessibility/renderer_accessibility_complete.h"
75 #include "content/renderer/accessibility/renderer_accessibility_focus_only.h"
76 #include "content/renderer/browser_plugin/browser_plugin.h"
77 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
78 #include "content/renderer/browser_plugin/browser_plugin_manager_impl.h"
79 #include "content/renderer/context_menu_params_builder.h"
80 #include "content/renderer/devtools/devtools_agent.h"
81 #include "content/renderer/disambiguation_popup_helper.h"
82 #include "content/renderer/dom_automation_controller.h"
83 #include "content/renderer/dom_storage/webstoragenamespace_impl.h"
84 #include "content/renderer/drop_data_builder.h"
85 #include "content/renderer/external_popup_menu.h"
86 #include "content/renderer/fetchers/alt_error_page_resource_fetcher.h"
87 #include "content/renderer/geolocation_dispatcher.h"
88 #include "content/renderer/gpu/render_widget_compositor.h"
89 #include "content/renderer/idle_user_detector.h"
90 #include "content/renderer/image_loading_helper.h"
91 #include "content/renderer/ime_event_guard.h"
92 #include "content/renderer/input/input_handler_manager.h"
93 #include "content/renderer/input_tag_speech_dispatcher.h"
94 #include "content/renderer/internal_document_state_data.h"
95 #include "content/renderer/java/java_bridge_dispatcher.h"
96 #include "content/renderer/load_progress_tracker.h"
97 #include "content/renderer/media/audio_device_factory.h"
98 #include "content/renderer/media/audio_renderer_mixer_manager.h"
99 #include "content/renderer/media/media_stream_dependency_factory.h"
100 #include "content/renderer/media/media_stream_dispatcher.h"
101 #include "content/renderer/media/media_stream_impl.h"
102 #include "content/renderer/media/midi_dispatcher.h"
103 #include "content/renderer/media/render_media_log.h"
104 #include "content/renderer/media/video_capture_impl_manager.h"
105 #include "content/renderer/media/webmediaplayer_impl.h"
106 #include "content/renderer/media/webmediaplayer_ms.h"
107 #include "content/renderer/media/webmediaplayer_params.h"
108 #include "content/renderer/mhtml_generator.h"
109 #include "content/renderer/notification_provider.h"
110 #include "content/renderer/render_frame_impl.h"
111 #include "content/renderer/render_process.h"
112 #include "content/renderer/render_thread_impl.h"
113 #include "content/renderer/render_view_impl_params.h"
114 #include "content/renderer/render_view_mouse_lock_dispatcher.h"
115 #include "content/renderer/render_widget_fullscreen_pepper.h"
116 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
117 #include "content/renderer/renderer_webcolorchooser_impl.h"
118 #include "content/renderer/resizing_mode_selector.h"
119 #include "content/renderer/savable_resources.h"
120 #include "content/renderer/shared_worker_repository.h"
121 #include "content/renderer/speech_recognition_dispatcher.h"
122 #include "content/renderer/stats_collection_controller.h"
123 #include "content/renderer/stats_collection_observer.h"
124 #include "content/renderer/text_input_client_observer.h"
125 #include "content/renderer/v8_value_converter_impl.h"
126 #include "content/renderer/web_ui_extension.h"
127 #include "content/renderer/web_ui_extension_data.h"
128 #include "content/renderer/websharedworker_proxy.h"
129 #include "media/audio/audio_output_device.h"
130 #include "media/base/audio_renderer_mixer_input.h"
131 #include "media/base/filter_collection.h"
132 #include "media/base/media_switches.h"
133 #include "media/filters/audio_renderer_impl.h"
134 #include "media/filters/gpu_video_accelerator_factories.h"
135 #include "net/base/data_url.h"
136 #include "net/base/escape.h"
137 #include "net/base/net_errors.h"
138 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
139 #include "net/http/http_util.h"
140 #include "third_party/WebKit/public/platform/WebCString.h"
141 #include "third_party/WebKit/public/platform/WebDragData.h"
142 #include "third_party/WebKit/public/platform/WebHTTPBody.h"
143 #include "third_party/WebKit/public/platform/WebImage.h"
144 #include "third_party/WebKit/public/platform/WebMessagePortChannel.h"
145 #include "third_party/WebKit/public/platform/WebPoint.h"
146 #include "third_party/WebKit/public/platform/WebRect.h"
147 #include "third_party/WebKit/public/platform/WebSize.h"
148 #include "third_party/WebKit/public/platform/WebSocketStreamHandle.h"
149 #include "third_party/WebKit/public/platform/WebStorageQuotaCallbacks.h"
150 #include "third_party/WebKit/public/platform/WebString.h"
151 #include "third_party/WebKit/public/platform/WebURL.h"
152 #include "third_party/WebKit/public/platform/WebURLError.h"
153 #include "third_party/WebKit/public/platform/WebURLRequest.h"
154 #include "third_party/WebKit/public/platform/WebURLResponse.h"
155 #include "third_party/WebKit/public/platform/WebVector.h"
156 #include "third_party/WebKit/public/web/WebAXObject.h"
157 #include "third_party/WebKit/public/web/WebColorName.h"
158 #include "third_party/WebKit/public/web/WebColorSuggestion.h"
159 #include "third_party/WebKit/public/web/WebDOMEvent.h"
160 #include "third_party/WebKit/public/web/WebDOMMessageEvent.h"
161 #include "third_party/WebKit/public/web/WebDataSource.h"
162 #include "third_party/WebKit/public/web/WebDateTimeChooserCompletion.h"
163 #include "third_party/WebKit/public/web/WebDateTimeChooserParams.h"
164 #include "third_party/WebKit/public/web/WebDevToolsAgent.h"
165 #include "third_party/WebKit/public/web/WebDocument.h"
166 #include "third_party/WebKit/public/web/WebElement.h"
167 #include "third_party/WebKit/public/web/WebFileChooserParams.h"
168 #include "third_party/WebKit/public/web/WebFindOptions.h"
169 #include "third_party/WebKit/public/web/WebFormControlElement.h"
170 #include "third_party/WebKit/public/web/WebFormElement.h"
171 #include "third_party/WebKit/public/web/WebFrame.h"
172 #include "third_party/WebKit/public/web/WebGlyphCache.h"
173 #include "third_party/WebKit/public/web/WebHelperPlugin.h"
174 #include "third_party/WebKit/public/web/WebHistoryItem.h"
175 #include "third_party/WebKit/public/web/WebInputElement.h"
176 #include "third_party/WebKit/public/web/WebInputEvent.h"
177 #include "third_party/WebKit/public/web/WebMediaPlayerAction.h"
178 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
179 #include "third_party/WebKit/public/web/WebNodeList.h"
180 #include "third_party/WebKit/public/web/WebPageSerializer.h"
181 #include "third_party/WebKit/public/web/WebPlugin.h"
182 #include "third_party/WebKit/public/web/WebPluginAction.h"
183 #include "third_party/WebKit/public/web/WebPluginContainer.h"
184 #include "third_party/WebKit/public/web/WebPluginDocument.h"
185 #include "third_party/WebKit/public/web/WebRange.h"
186 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
187 #include "third_party/WebKit/public/web/WebScriptSource.h"
188 #include "third_party/WebKit/public/web/WebSearchableFormData.h"
189 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
190 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
191 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
192 #include "third_party/WebKit/public/web/WebSettings.h"
193 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
194 #include "third_party/WebKit/public/web/WebUserMediaClient.h"
195 #include "third_party/WebKit/public/web/WebView.h"
196 #include "third_party/WebKit/public/web/WebWindowFeatures.h"
197 #include "third_party/WebKit/public/web/default/WebRenderTheme.h"
198 #include "ui/base/ui_base_switches_util.h"
199 #include "ui/events/latency_info.h"
200 #include "ui/gfx/native_widget_types.h"
201 #include "ui/gfx/point.h"
202 #include "ui/gfx/rect.h"
203 #include "ui/gfx/rect_conversions.h"
204 #include "ui/gfx/size_conversions.h"
205 #include "ui/shell_dialogs/selected_file_info.h"
206 #include "v8/include/v8.h"
207 #include "webkit/child/weburlresponse_extradata_impl.h"
208
209 #if defined(OS_ANDROID)
210 #include <cpu-features.h>
211
212 #include "content/common/android/device_telephony_info.h"
213 #include "content/common/gpu/client/context_provider_command_buffer.h"
214 #include "content/renderer/android/address_detector.h"
215 #include "content/renderer/android/content_detector.h"
216 #include "content/renderer/android/email_detector.h"
217 #include "content/renderer/android/phone_number_detector.h"
218 #include "content/renderer/android/synchronous_compositor_factory.h"
219 #include "content/renderer/media/android/renderer_media_player_manager.h"
220 #include "content/renderer/media/android/stream_texture_factory_android_impl.h"
221 #include "content/renderer/media/android/webmediaplayer_android.h"
222 #include "skia/ext/platform_canvas.h"
223 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
224 #include "third_party/WebKit/public/platform/WebFloatRect.h"
225 #include "third_party/WebKit/public/web/WebHitTestResult.h"
226 #include "ui/gfx/rect_f.h"
227
228 #if defined(GOOGLE_TV)
229 #include "content/renderer/media/rtc_video_decoder_bridge_tv.h"
230 #include "content/renderer/media/rtc_video_decoder_factory_tv.h"
231 #endif
232
233 #elif defined(OS_WIN)
234 // TODO(port): these files are currently Windows only because they concern:
235 // * theming
236 #include "ui/native_theme/native_theme_win.h"
237 #elif defined(USE_X11)
238 #include "ui/native_theme/native_theme.h"
239 #elif defined(OS_MACOSX)
240 #include "skia/ext/skia_utils_mac.h"
241 #endif
242
243 #if defined(ENABLE_PLUGINS)
244 #include "content/renderer/npapi/webplugin_delegate_proxy.h"
245 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
246 #include "content/renderer/pepper/pepper_plugin_registry.h"
247 #endif
248
249 #if defined(ENABLE_WEBRTC)
250 #include "content/renderer/media/rtc_peer_connection_handler.h"
251 #endif
252
253 using blink::WebAXObject;
254 using blink::WebApplicationCacheHost;
255 using blink::WebApplicationCacheHostClient;
256 using blink::WebCString;
257 using blink::WebColor;
258 using blink::WebColorName;
259 using blink::WebConsoleMessage;
260 using blink::WebContextMenuData;
261 using blink::WebCookieJar;
262 using blink::WebData;
263 using blink::WebDataSource;
264 using blink::WebDocument;
265 using blink::WebDOMEvent;
266 using blink::WebDOMMessageEvent;
267 using blink::WebDragData;
268 using blink::WebDragOperation;
269 using blink::WebDragOperationsMask;
270 using blink::WebElement;
271 using blink::WebExternalPopupMenu;
272 using blink::WebExternalPopupMenuClient;
273 using blink::WebFileChooserCompletion;
274 using blink::WebFindOptions;
275 using blink::WebFormControlElement;
276 using blink::WebFormElement;
277 using blink::WebFrame;
278 using blink::WebGestureEvent;
279 using blink::WebHistoryItem;
280 using blink::WebHTTPBody;
281 using blink::WebIconURL;
282 using blink::WebImage;
283 using blink::WebInputElement;
284 using blink::WebInputEvent;
285 using blink::WebMediaPlayer;
286 using blink::WebMediaPlayerAction;
287 using blink::WebMediaPlayerClient;
288 using blink::WebMouseEvent;
289 using blink::WebNavigationPolicy;
290 using blink::WebNavigationType;
291 using blink::WebNode;
292 using blink::WebPageSerializer;
293 using blink::WebPageSerializerClient;
294 using blink::WebPeerConnection00Handler;
295 using blink::WebPeerConnection00HandlerClient;
296 using blink::WebPeerConnectionHandler;
297 using blink::WebPeerConnectionHandlerClient;
298 using blink::WebPluginAction;
299 using blink::WebPluginContainer;
300 using blink::WebPluginDocument;
301 using blink::WebPoint;
302 using blink::WebPopupMenuInfo;
303 using blink::WebRange;
304 using blink::WebRect;
305 using blink::WebReferrerPolicy;
306 using blink::WebRuntimeFeatures;
307 using blink::WebScriptSource;
308 using blink::WebSearchableFormData;
309 using blink::WebSecurityOrigin;
310 using blink::WebSecurityPolicy;
311 using blink::WebSerializedScriptValue;
312 using blink::WebSettings;
313 using blink::WebSize;
314 using blink::WebSocketStreamHandle;
315 using blink::WebStorageNamespace;
316 using blink::WebStorageQuotaCallbacks;
317 using blink::WebStorageQuotaError;
318 using blink::WebStorageQuotaType;
319 using blink::WebString;
320 using blink::WebTextAffinity;
321 using blink::WebTextDirection;
322 using blink::WebTouchEvent;
323 using blink::WebURL;
324 using blink::WebURLError;
325 using blink::WebURLRequest;
326 using blink::WebURLResponse;
327 using blink::WebUserGestureIndicator;
328 using blink::WebVector;
329 using blink::WebView;
330 using blink::WebWidget;
331 using blink::WebWindowFeatures;
332 using base::Time;
333 using base::TimeDelta;
334 using webkit_glue::WebURLResponseExtraDataImpl;
335
336 #if defined(OS_ANDROID)
337 using blink::WebContentDetectionResult;
338 using blink::WebFloatPoint;
339 using blink::WebFloatRect;
340 using blink::WebHitTestResult;
341 #endif
342
343 namespace content {
344
345 //-----------------------------------------------------------------------------
346
347 typedef std::map<blink::WebView*, RenderViewImpl*> ViewMap;
348 static base::LazyInstance<ViewMap> g_view_map = LAZY_INSTANCE_INITIALIZER;
349 typedef std::map<int32, RenderViewImpl*> RoutingIDViewMap;
350 static base::LazyInstance<RoutingIDViewMap> g_routing_id_view_map =
351 LAZY_INSTANCE_INITIALIZER;
352
353 // Time, in seconds, we delay before sending content state changes (such as form
354 // state and scroll position) to the browser. We delay sending changes to avoid
355 // spamming the browser.
356 // To avoid having tab/session restore require sending a message to get the
357 // current content state during tab closing we use a shorter timeout for the
358 // foreground renderer. This means there is a small window of time from which
359 // content state is modified and not sent to session restore, but this is
360 // better than having to wake up all renderers during shutdown.
361 const int kDelaySecondsForContentStateSyncHidden = 5;
362 const int kDelaySecondsForContentStateSync = 1;
363
364 const size_t kExtraCharsBeforeAndAfterSelection = 100;
365
366 const float kScalingIncrementForGesture = 0.01f;
367
368 #if defined(OS_ANDROID)
369 // Delay between tapping in content and launching the associated android intent.
370 // Used to allow users see what has been recognized as content.
371 const size_t kContentIntentDelayMilliseconds = 700;
372 #endif
373
374 static RenderViewImpl* (*g_create_render_view_impl)(RenderViewImplParams*) =
375 NULL;
376
GetRedirectChain(WebDataSource * ds,std::vector<GURL> * result)377 static void GetRedirectChain(WebDataSource* ds, std::vector<GURL>* result) {
378 // Replace any occurrences of swappedout:// with about:blank.
379 const WebURL& blank_url = GURL(kAboutBlankURL);
380 WebVector<WebURL> urls;
381 ds->redirectChain(urls);
382 result->reserve(urls.size());
383 for (size_t i = 0; i < urls.size(); ++i) {
384 if (urls[i] != GURL(kSwappedOutURL))
385 result->push_back(urls[i]);
386 else
387 result->push_back(blank_url);
388 }
389 }
390
391 // If |data_source| is non-null and has an InternalDocumentStateData associated
392 // with it, the AltErrorPageResourceFetcher is reset.
StopAltErrorPageFetcher(WebDataSource * data_source)393 static void StopAltErrorPageFetcher(WebDataSource* data_source) {
394 if (data_source) {
395 InternalDocumentStateData* internal_data =
396 InternalDocumentStateData::FromDataSource(data_source);
397 if (internal_data)
398 internal_data->set_alt_error_page_fetcher(NULL);
399 }
400 }
401
IsReload(const ViewMsg_Navigate_Params & params)402 static bool IsReload(const ViewMsg_Navigate_Params& params) {
403 return
404 params.navigation_type == ViewMsg_Navigate_Type::RELOAD ||
405 params.navigation_type == ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE ||
406 params.navigation_type ==
407 ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL;
408 }
409
410 // static
GetReferrerPolicyFromRequest(WebFrame * frame,const WebURLRequest & request)411 WebReferrerPolicy RenderViewImpl::GetReferrerPolicyFromRequest(
412 WebFrame* frame,
413 const WebURLRequest& request) {
414 return request.extraData() ?
415 static_cast<RequestExtraData*>(request.extraData())->referrer_policy() :
416 frame->document().referrerPolicy();
417 }
418
419 // static
GetReferrerFromRequest(WebFrame * frame,const WebURLRequest & request)420 Referrer RenderViewImpl::GetReferrerFromRequest(
421 WebFrame* frame,
422 const WebURLRequest& request) {
423 return Referrer(GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
424 GetReferrerPolicyFromRequest(frame, request));
425 }
426
427 // static
GetExtraDataFromResponse(const WebURLResponse & response)428 WebURLResponseExtraDataImpl* RenderViewImpl::GetExtraDataFromResponse(
429 const WebURLResponse& response) {
430 return static_cast<WebURLResponseExtraDataImpl*>(
431 response.extraData());
432 }
433
CrashIntentionally()434 NOINLINE static void CrashIntentionally() {
435 // NOTE(shess): Crash directly rather than using NOTREACHED() so
436 // that the signature is easier to triage in crash reports.
437 volatile int* zero = NULL;
438 *zero = 0;
439 }
440
441 #if defined(ADDRESS_SANITIZER)
MaybeTriggerAsanError(const GURL & url)442 NOINLINE static void MaybeTriggerAsanError(const GURL& url) {
443 // NOTE(rogerm): We intentionally perform an invalid heap access here in
444 // order to trigger an Address Sanitizer (ASAN) error report.
445 static const char kCrashDomain[] = "crash";
446 static const char kHeapOverflow[] = "/heap-overflow";
447 static const char kHeapUnderflow[] = "/heap-underflow";
448 static const char kUseAfterFree[] = "/use-after-free";
449 static const int kArraySize = 5;
450
451 if (!url.DomainIs(kCrashDomain, sizeof(kCrashDomain) - 1))
452 return;
453
454 if (!url.has_path())
455 return;
456
457 scoped_ptr<int[]> array(new int[kArraySize]);
458 std::string crash_type(url.path());
459 int dummy = 0;
460 if (crash_type == kHeapOverflow) {
461 dummy = array[kArraySize];
462 } else if (crash_type == kHeapUnderflow ) {
463 dummy = array[-1];
464 } else if (crash_type == kUseAfterFree) {
465 int* dangling = array.get();
466 array.reset();
467 dummy = dangling[kArraySize / 2];
468 }
469
470 // Make sure the assignments to the dummy value aren't optimized away.
471 base::debug::Alias(&dummy);
472 }
473 #endif // ADDRESS_SANITIZER
474
MaybeHandleDebugURL(const GURL & url)475 static void MaybeHandleDebugURL(const GURL& url) {
476 if (!url.SchemeIs(chrome::kChromeUIScheme))
477 return;
478 if (url == GURL(kChromeUICrashURL)) {
479 CrashIntentionally();
480 } else if (url == GURL(kChromeUIKillURL)) {
481 base::KillProcess(base::GetCurrentProcessHandle(), 1, false);
482 } else if (url == GURL(kChromeUIHangURL)) {
483 for (;;) {
484 base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
485 }
486 } else if (url == GURL(kChromeUIShorthangURL)) {
487 base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
488 }
489
490 #if defined(ADDRESS_SANITIZER)
491 MaybeTriggerAsanError(url);
492 #endif // ADDRESS_SANITIZER
493 }
494
495 // Returns false unless this is a top-level navigation.
IsTopLevelNavigation(WebFrame * frame)496 static bool IsTopLevelNavigation(WebFrame* frame) {
497 return frame->parent() == NULL;
498 }
499
500 // Returns false unless this is a top-level navigation that crosses origins.
IsNonLocalTopLevelNavigation(const GURL & url,WebFrame * frame,WebNavigationType type,bool is_form_post)501 static bool IsNonLocalTopLevelNavigation(const GURL& url,
502 WebFrame* frame,
503 WebNavigationType type,
504 bool is_form_post) {
505 if (!IsTopLevelNavigation(frame))
506 return false;
507
508 // Navigations initiated within Webkit are not sent out to the external host
509 // in the following cases.
510 // 1. The url scheme is not http/https
511 // 2. The origin of the url and the opener is the same in which case the
512 // opener relationship is maintained.
513 // 3. Reloads/form submits/back forward navigations
514 if (!url.SchemeIs(kHttpScheme) && !url.SchemeIs(kHttpsScheme))
515 return false;
516
517 if (type != blink::WebNavigationTypeReload &&
518 type != blink::WebNavigationTypeBackForward && !is_form_post) {
519 // The opener relationship between the new window and the parent allows the
520 // new window to script the parent and vice versa. This is not allowed if
521 // the origins of the two domains are different. This can be treated as a
522 // top level navigation and routed back to the host.
523 blink::WebFrame* opener = frame->opener();
524 if (!opener)
525 return true;
526
527 if (url.GetOrigin() != GURL(opener->document().url()).GetOrigin())
528 return true;
529 }
530 return false;
531 }
532
NotifyTimezoneChange(blink::WebFrame * frame)533 static void NotifyTimezoneChange(blink::WebFrame* frame) {
534 v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
535 v8::Context::Scope context_scope(frame->mainWorldScriptContext());
536 v8::Date::DateTimeConfigurationChangeNotification(v8::Isolate::GetCurrent());
537 blink::WebFrame* child = frame->firstChild();
538 for (; child; child = child->nextSibling())
539 NotifyTimezoneChange(child);
540 }
541
NavigationPolicyToDisposition(WebNavigationPolicy policy)542 static WindowOpenDisposition NavigationPolicyToDisposition(
543 WebNavigationPolicy policy) {
544 switch (policy) {
545 case blink::WebNavigationPolicyIgnore:
546 return IGNORE_ACTION;
547 case blink::WebNavigationPolicyDownload:
548 return SAVE_TO_DISK;
549 case blink::WebNavigationPolicyCurrentTab:
550 return CURRENT_TAB;
551 case blink::WebNavigationPolicyNewBackgroundTab:
552 return NEW_BACKGROUND_TAB;
553 case blink::WebNavigationPolicyNewForegroundTab:
554 return NEW_FOREGROUND_TAB;
555 case blink::WebNavigationPolicyNewWindow:
556 return NEW_WINDOW;
557 case blink::WebNavigationPolicyNewPopup:
558 return NEW_POPUP;
559 default:
560 NOTREACHED() << "Unexpected WebNavigationPolicy";
561 return IGNORE_ACTION;
562 }
563 }
564
565 // Returns true if the device scale is high enough that losing subpixel
566 // antialiasing won't have a noticeable effect on text quality.
DeviceScaleEnsuresTextQuality(float device_scale_factor)567 static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
568 #if defined(OS_ANDROID)
569 // On Android, we never have subpixel antialiasing.
570 return true;
571 #else
572 return device_scale_factor > 1.5f;
573 #endif
574
575 }
576
ShouldUseFixedPositionCompositing(float device_scale_factor)577 static bool ShouldUseFixedPositionCompositing(float device_scale_factor) {
578 // Compositing for fixed-position elements is dependent on
579 // device_scale_factor if no flag is set. http://crbug.com/172738
580 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
581
582 if (command_line.HasSwitch(switches::kDisableCompositingForFixedPosition))
583 return false;
584
585 if (command_line.HasSwitch(switches::kEnableCompositingForFixedPosition))
586 return true;
587
588 return DeviceScaleEnsuresTextQuality(device_scale_factor);
589 }
590
ShouldUseAcceleratedCompositingForOverflowScroll(float device_scale_factor)591 static bool ShouldUseAcceleratedCompositingForOverflowScroll(
592 float device_scale_factor) {
593 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
594
595 if (command_line.HasSwitch(switches::kDisableAcceleratedOverflowScroll))
596 return false;
597
598 if (command_line.HasSwitch(switches::kEnableAcceleratedOverflowScroll))
599 return true;
600
601 return DeviceScaleEnsuresTextQuality(device_scale_factor);
602 }
603
ShouldUseAcceleratedCompositingForScrollableFrames(float device_scale_factor)604 static bool ShouldUseAcceleratedCompositingForScrollableFrames(
605 float device_scale_factor) {
606 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
607
608 if (command_line.HasSwitch(switches::kDisableAcceleratedScrollableFrames))
609 return false;
610
611 if (command_line.HasSwitch(switches::kEnableAcceleratedScrollableFrames))
612 return true;
613
614 if (!cc::switches::IsLCDTextEnabled())
615 return true;
616
617 return DeviceScaleEnsuresTextQuality(device_scale_factor);
618 }
619
ShouldUseCompositedScrollingForFrames(float device_scale_factor)620 static bool ShouldUseCompositedScrollingForFrames(
621 float device_scale_factor) {
622 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
623
624 if (command_line.HasSwitch(switches::kDisableCompositedScrollingForFrames))
625 return false;
626
627 if (command_line.HasSwitch(switches::kEnableCompositedScrollingForFrames))
628 return true;
629
630 if (!cc::switches::IsLCDTextEnabled())
631 return true;
632
633 return DeviceScaleEnsuresTextQuality(device_scale_factor);
634 }
635
ShouldUseUniversalAcceleratedCompositingForOverflowScroll()636 static bool ShouldUseUniversalAcceleratedCompositingForOverflowScroll() {
637 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
638
639 if (command_line.HasSwitch(
640 switches::kDisableUniversalAcceleratedOverflowScroll))
641 return false;
642
643 if (command_line.HasSwitch(
644 switches::kEnableUniversalAcceleratedOverflowScroll))
645 return true;
646
647 return false;
648 }
649
ShouldUseTransitionCompositing(float device_scale_factor)650 static bool ShouldUseTransitionCompositing(float device_scale_factor) {
651 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
652
653 if (command_line.HasSwitch(switches::kDisableCompositingForTransition))
654 return false;
655
656 if (command_line.HasSwitch(switches::kEnableCompositingForTransition))
657 return true;
658
659 // TODO(ajuma): Re-enable this by default for high-DPI once the problem
660 // of excessive layer promotion caused by overlap has been addressed.
661 // http://crbug.com/178119.
662 return false;
663 }
664
ShouldUseAcceleratedFixedRootBackground(float device_scale_factor)665 static bool ShouldUseAcceleratedFixedRootBackground(float device_scale_factor) {
666 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
667
668 if (command_line.HasSwitch(switches::kDisableAcceleratedFixedRootBackground))
669 return false;
670
671 if (command_line.HasSwitch(switches::kEnableAcceleratedFixedRootBackground))
672 return true;
673
674 return DeviceScaleEnsuresTextQuality(device_scale_factor);
675 }
676
ToFaviconType(blink::WebIconURL::Type type)677 static FaviconURL::IconType ToFaviconType(blink::WebIconURL::Type type) {
678 switch (type) {
679 case blink::WebIconURL::TypeFavicon:
680 return FaviconURL::FAVICON;
681 case blink::WebIconURL::TypeTouch:
682 return FaviconURL::TOUCH_ICON;
683 case blink::WebIconURL::TypeTouchPrecomposed:
684 return FaviconURL::TOUCH_PRECOMPOSED_ICON;
685 case blink::WebIconURL::TypeInvalid:
686 return FaviconURL::INVALID_ICON;
687 }
688 return FaviconURL::INVALID_ICON;
689 }
690
691 ///////////////////////////////////////////////////////////////////////////////
692
693 struct RenderViewImpl::PendingFileChooser {
PendingFileChoosercontent::RenderViewImpl::PendingFileChooser694 PendingFileChooser(const FileChooserParams& p, WebFileChooserCompletion* c)
695 : params(p),
696 completion(c) {
697 }
698 FileChooserParams params;
699 WebFileChooserCompletion* completion; // MAY BE NULL to skip callback.
700 };
701
702 namespace {
703
704 class WebWidgetLockTarget : public MouseLockDispatcher::LockTarget {
705 public:
WebWidgetLockTarget(blink::WebWidget * webwidget)706 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
707 : webwidget_(webwidget) {}
708
OnLockMouseACK(bool succeeded)709 virtual void OnLockMouseACK(bool succeeded) OVERRIDE {
710 if (succeeded)
711 webwidget_->didAcquirePointerLock();
712 else
713 webwidget_->didNotAcquirePointerLock();
714 }
715
OnMouseLockLost()716 virtual void OnMouseLockLost() OVERRIDE {
717 webwidget_->didLosePointerLock();
718 }
719
HandleMouseLockedInputEvent(const blink::WebMouseEvent & event)720 virtual bool HandleMouseLockedInputEvent(
721 const blink::WebMouseEvent &event) OVERRIDE {
722 // The WebWidget handles mouse lock in WebKit's handleInputEvent().
723 return false;
724 }
725
726 private:
727 blink::WebWidget* webwidget_;
728 };
729
ExtractPostId(const WebHistoryItem & item)730 int64 ExtractPostId(const WebHistoryItem& item) {
731 if (item.isNull())
732 return -1;
733
734 if (item.httpBody().isNull())
735 return -1;
736
737 return item.httpBody().identifier();
738 }
739
TouchEnabled()740 bool TouchEnabled() {
741 // Based on the definition of chrome::kEnableTouchIcon.
742 #if defined(OS_ANDROID)
743 return true;
744 #else
745 return false;
746 #endif
747 }
748
DropDataToWebDragData(const DropData & drop_data)749 WebDragData DropDataToWebDragData(const DropData& drop_data) {
750 std::vector<WebDragData::Item> item_list;
751
752 // These fields are currently unused when dragging into WebKit.
753 DCHECK(drop_data.download_metadata.empty());
754 DCHECK(drop_data.file_contents.empty());
755 DCHECK(drop_data.file_description_filename.empty());
756
757 if (!drop_data.text.is_null()) {
758 WebDragData::Item item;
759 item.storageType = WebDragData::Item::StorageTypeString;
760 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeText);
761 item.stringData = drop_data.text.string();
762 item_list.push_back(item);
763 }
764
765 // TODO(dcheng): Do we need to distinguish between null and empty URLs? Is it
766 // meaningful to write an empty URL to the clipboard?
767 if (!drop_data.url.is_empty()) {
768 WebDragData::Item item;
769 item.storageType = WebDragData::Item::StorageTypeString;
770 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeURIList);
771 item.stringData = WebString::fromUTF8(drop_data.url.spec());
772 item.title = drop_data.url_title;
773 item_list.push_back(item);
774 }
775
776 if (!drop_data.html.is_null()) {
777 WebDragData::Item item;
778 item.storageType = WebDragData::Item::StorageTypeString;
779 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeHTML);
780 item.stringData = drop_data.html.string();
781 item.baseURL = drop_data.html_base_url;
782 item_list.push_back(item);
783 }
784
785 for (std::vector<DropData::FileInfo>::const_iterator it =
786 drop_data.filenames.begin();
787 it != drop_data.filenames.end();
788 ++it) {
789 WebDragData::Item item;
790 item.storageType = WebDragData::Item::StorageTypeFilename;
791 item.filenameData = it->path;
792 item.displayNameData = it->display_name;
793 item_list.push_back(item);
794 }
795
796 for (std::map<base::string16, base::string16>::const_iterator it =
797 drop_data.custom_data.begin();
798 it != drop_data.custom_data.end();
799 ++it) {
800 WebDragData::Item item;
801 item.storageType = WebDragData::Item::StorageTypeString;
802 item.stringType = it->first;
803 item.stringData = it->second;
804 item_list.push_back(item);
805 }
806
807 WebDragData result;
808 result.initialize();
809 result.setItems(item_list);
810 result.setFilesystemId(drop_data.filesystem_id);
811 return result;
812 }
813
814 } // namespace
815
RenderViewImpl(RenderViewImplParams * params)816 RenderViewImpl::RenderViewImpl(RenderViewImplParams* params)
817 : RenderWidget(blink::WebPopupTypeNone,
818 params->screen_info,
819 params->swapped_out,
820 params->hidden),
821 webkit_preferences_(params->webkit_prefs),
822 send_content_state_immediately_(false),
823 enabled_bindings_(0),
824 send_preferred_size_changes_(false),
825 is_loading_(false),
826 navigation_gesture_(NavigationGestureUnknown),
827 opened_by_user_gesture_(true),
828 opener_suppressed_(false),
829 suppress_dialogs_until_swap_out_(false),
830 page_id_(-1),
831 last_page_id_sent_to_browser_(-1),
832 next_page_id_(params->next_page_id),
833 history_list_offset_(-1),
834 history_list_length_(0),
835 target_url_status_(TARGET_NONE),
836 selection_text_offset_(0),
837 selection_range_(gfx::Range::InvalidRange()),
838 #if defined(OS_ANDROID)
839 top_controls_constraints_(cc::BOTH),
840 #endif
841 cached_is_main_frame_pinned_to_left_(false),
842 cached_is_main_frame_pinned_to_right_(false),
843 cached_has_main_frame_horizontal_scrollbar_(false),
844 cached_has_main_frame_vertical_scrollbar_(false),
845 cookie_jar_(this),
846 notification_provider_(NULL),
847 geolocation_dispatcher_(NULL),
848 input_tag_speech_dispatcher_(NULL),
849 speech_recognition_dispatcher_(NULL),
850 media_stream_dispatcher_(NULL),
851 browser_plugin_manager_(NULL),
852 media_stream_client_(NULL),
853 web_user_media_client_(NULL),
854 midi_dispatcher_(NULL),
855 devtools_agent_(NULL),
856 accessibility_mode_(AccessibilityModeOff),
857 renderer_accessibility_(NULL),
858 mouse_lock_dispatcher_(NULL),
859 #if defined(OS_ANDROID)
860 body_background_color_(SK_ColorWHITE),
861 expected_content_intent_id_(0),
862 media_player_manager_(NULL),
863 #endif
864 #if defined(OS_WIN)
865 focused_plugin_id_(-1),
866 #endif
867 #if defined(ENABLE_PLUGINS)
868 focused_pepper_plugin_(NULL),
869 pepper_last_mouse_event_target_(NULL),
870 #endif
871 enumeration_completion_id_(0),
872 load_progress_tracker_(new LoadProgressTracker(this)),
873 session_storage_namespace_id_(params->session_storage_namespace_id),
874 handling_select_range_(false),
875 next_snapshot_id_(0),
876 allow_partial_swap_(params->allow_partial_swap),
877 context_menu_source_type_(ui::MENU_SOURCE_MOUSE) {
878 }
879
Initialize(RenderViewImplParams * params)880 void RenderViewImpl::Initialize(RenderViewImplParams* params) {
881 routing_id_ = params->routing_id;
882 surface_id_ = params->surface_id;
883 if (params->opener_id != MSG_ROUTING_NONE && params->is_renderer_created)
884 opener_id_ = params->opener_id;
885
886 // Ensure we start with a valid next_page_id_ from the browser.
887 DCHECK_GE(next_page_id_, 0);
888
889 #if defined(ENABLE_NOTIFICATIONS)
890 notification_provider_ = new NotificationProvider(this);
891 #else
892 notification_provider_ = NULL;
893 #endif
894
895 webwidget_ = WebView::create(this);
896 webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(webwidget_));
897
898 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
899
900 if (command_line.HasSwitch(switches::kStatsCollectionController))
901 stats_collection_observer_.reset(new StatsCollectionObserver(this));
902
903 #if defined(OS_ANDROID)
904 content::DeviceTelephonyInfo device_info;
905
906 const std::string region_code =
907 command_line.HasSwitch(switches::kNetworkCountryIso)
908 ? command_line.GetSwitchValueASCII(switches::kNetworkCountryIso)
909 : device_info.GetNetworkCountryIso();
910 content_detectors_.push_back(linked_ptr<ContentDetector>(
911 new AddressDetector()));
912 content_detectors_.push_back(linked_ptr<ContentDetector>(
913 new PhoneNumberDetector(region_code)));
914 content_detectors_.push_back(linked_ptr<ContentDetector>(
915 new EmailDetector()));
916 #endif
917
918 RenderThread::Get()->AddRoute(routing_id_, this);
919 // Take a reference on behalf of the RenderThread. This will be balanced
920 // when we receive ViewMsg_ClosePage.
921 AddRef();
922 if (is_hidden_)
923 RenderThread::Get()->WidgetHidden();
924
925 // If this is a popup, we must wait for the CreatingNew_ACK message before
926 // completing initialization. Otherwise, we can finish it now.
927 if (opener_id_ == MSG_ROUTING_NONE) {
928 did_show_ = true;
929 CompleteInit();
930 }
931
932 g_view_map.Get().insert(std::make_pair(webview(), this));
933 g_routing_id_view_map.Get().insert(std::make_pair(routing_id_, this));
934 webview()->setDeviceScaleFactor(device_scale_factor_);
935 webview()->settings()->setAcceleratedCompositingForFixedPositionEnabled(
936 ShouldUseFixedPositionCompositing(device_scale_factor_));
937 webview()->settings()->setAcceleratedCompositingForOverflowScrollEnabled(
938 ShouldUseAcceleratedCompositingForOverflowScroll(device_scale_factor_));
939 webview()->settings()->setCompositorDrivenAcceleratedScrollingEnabled(
940 ShouldUseUniversalAcceleratedCompositingForOverflowScroll());
941 webview()->settings()->setAcceleratedCompositingForTransitionEnabled(
942 ShouldUseTransitionCompositing(device_scale_factor_));
943 webview()->settings()->setAcceleratedCompositingForFixedRootBackgroundEnabled(
944 ShouldUseAcceleratedFixedRootBackground(device_scale_factor_));
945 webview()->settings()->setAcceleratedCompositingForScrollableFramesEnabled(
946 ShouldUseAcceleratedCompositingForScrollableFrames(device_scale_factor_));
947 webview()->settings()->setCompositedScrollingForFramesEnabled(
948 ShouldUseCompositedScrollingForFrames(device_scale_factor_));
949
950 ApplyWebPreferences(webkit_preferences_, webview());
951
952 main_render_frame_.reset(
953 RenderFrameImpl::Create(this, params->main_frame_routing_id));
954 // The main frame WebFrame object is closed by
955 // RenderViewImpl::frameDetached().
956 webview()->setMainFrame(WebFrame::create(main_render_frame_.get()));
957
958 if (switches::IsTouchDragDropEnabled())
959 webview()->settings()->setTouchDragDropEnabled(true);
960
961 if (switches::IsTouchEditingEnabled())
962 webview()->settings()->setTouchEditingEnabled(true);
963
964 if (!params->frame_name.empty())
965 webview()->mainFrame()->setName(params->frame_name);
966
967 OnSetRendererPrefs(params->renderer_prefs);
968
969 #if defined(ENABLE_WEBRTC)
970 if (!media_stream_dispatcher_)
971 media_stream_dispatcher_ = new MediaStreamDispatcher(this);
972 #endif
973
974 new MHTMLGenerator(this);
975 #if defined(OS_MACOSX)
976 new TextInputClientObserver(this);
977 #endif // defined(OS_MACOSX)
978
979 new SharedWorkerRepository(this);
980
981 #if defined(OS_ANDROID)
982 media_player_manager_ = new RendererMediaPlayerManager(this);
983 new JavaBridgeDispatcher(this);
984 #endif
985
986 // The next group of objects all implement RenderViewObserver, so are deleted
987 // along with the RenderView automatically.
988 devtools_agent_ = new DevToolsAgent(this);
989 if (RenderWidgetCompositor* rwc = compositor()) {
990 webview()->devToolsAgent()->setLayerTreeId(rwc->GetLayerTreeId());
991 }
992 mouse_lock_dispatcher_ = new RenderViewMouseLockDispatcher(this);
993 new ImageLoadingHelper(this);
994
995 // Create renderer_accessibility_ if needed.
996 OnSetAccessibilityMode(params->accessibility_mode);
997
998 new IdleUserDetector(this);
999
1000 if (command_line.HasSwitch(switches::kDomAutomationController))
1001 enabled_bindings_ |= BINDINGS_POLICY_DOM_AUTOMATION;
1002 if (command_line.HasSwitch(switches::kStatsCollectionController))
1003 enabled_bindings_ |= BINDINGS_POLICY_STATS_COLLECTION;
1004
1005 ProcessViewLayoutFlags(command_line);
1006
1007 GetContentClient()->renderer()->RenderViewCreated(this);
1008
1009 // If we have an opener_id but we weren't created by a renderer, then
1010 // it's the browser asking us to set our opener to another RenderView.
1011 if (params->opener_id != MSG_ROUTING_NONE && !params->is_renderer_created) {
1012 RenderViewImpl* opener_view = FromRoutingID(params->opener_id);
1013 if (opener_view)
1014 webview()->mainFrame()->setOpener(opener_view->webview()->mainFrame());
1015 }
1016
1017 // If we are initially swapped out, navigate to kSwappedOutURL.
1018 // This ensures we are in a unique origin that others cannot script.
1019 if (is_swapped_out_)
1020 NavigateToSwappedOutURL(webview()->mainFrame());
1021 }
1022
~RenderViewImpl()1023 RenderViewImpl::~RenderViewImpl() {
1024 history_page_ids_.clear();
1025
1026 base::debug::TraceLog::GetInstance()->RemoveProcessLabel(routing_id_);
1027
1028 // If file chooser is still waiting for answer, dispatch empty answer.
1029 while (!file_chooser_completions_.empty()) {
1030 if (file_chooser_completions_.front()->completion) {
1031 file_chooser_completions_.front()->completion->didChooseFile(
1032 WebVector<WebString>());
1033 }
1034 file_chooser_completions_.pop_front();
1035 }
1036
1037 #if defined(OS_ANDROID)
1038 // The date/time picker client is both a scoped_ptr member of this class and
1039 // a RenderViewObserver. Reset it to prevent double deletion.
1040 date_time_picker_client_.reset();
1041 #endif
1042
1043 #ifndef NDEBUG
1044 // Make sure we are no longer referenced by the ViewMap or RoutingIDViewMap.
1045 ViewMap* views = g_view_map.Pointer();
1046 for (ViewMap::iterator it = views->begin(); it != views->end(); ++it)
1047 DCHECK_NE(this, it->second) << "Failed to call Close?";
1048 RoutingIDViewMap* routing_id_views = g_routing_id_view_map.Pointer();
1049 for (RoutingIDViewMap::iterator it = routing_id_views->begin();
1050 it != routing_id_views->end(); ++it)
1051 DCHECK_NE(this, it->second) << "Failed to call Close?";
1052 #endif
1053
1054 FOR_EACH_OBSERVER(RenderViewObserver, observers_, RenderViewGone());
1055 FOR_EACH_OBSERVER(RenderViewObserver, observers_, OnDestruct());
1056 }
1057
1058 /*static*/
FromWebView(WebView * webview)1059 RenderViewImpl* RenderViewImpl::FromWebView(WebView* webview) {
1060 ViewMap* views = g_view_map.Pointer();
1061 ViewMap::iterator it = views->find(webview);
1062 return it == views->end() ? NULL : it->second;
1063 }
1064
1065 /*static*/
FromWebView(blink::WebView * webview)1066 RenderView* RenderView::FromWebView(blink::WebView* webview) {
1067 return RenderViewImpl::FromWebView(webview);
1068 }
1069
1070 /*static*/
FromRoutingID(int32 routing_id)1071 RenderViewImpl* RenderViewImpl::FromRoutingID(int32 routing_id) {
1072 RoutingIDViewMap* views = g_routing_id_view_map.Pointer();
1073 RoutingIDViewMap::iterator it = views->find(routing_id);
1074 return it == views->end() ? NULL : it->second;
1075 }
1076
1077 /*static*/
FromRoutingID(int routing_id)1078 RenderView* RenderView::FromRoutingID(int routing_id) {
1079 return RenderViewImpl::FromRoutingID(routing_id);
1080 }
1081
1082 /*static*/
ForEach(RenderViewVisitor * visitor)1083 void RenderView::ForEach(RenderViewVisitor* visitor) {
1084 ViewMap* views = g_view_map.Pointer();
1085 for (ViewMap::iterator it = views->begin(); it != views->end(); ++it) {
1086 if (!visitor->Visit(it->second))
1087 return;
1088 }
1089 }
1090
1091 /*static*/
Create(int32 opener_id,const RendererPreferences & renderer_prefs,const WebPreferences & webkit_prefs,int32 routing_id,int32 main_frame_routing_id,int32 surface_id,int64 session_storage_namespace_id,const base::string16 & frame_name,bool is_renderer_created,bool swapped_out,bool hidden,int32 next_page_id,const blink::WebScreenInfo & screen_info,AccessibilityMode accessibility_mode,bool allow_partial_swap)1092 RenderViewImpl* RenderViewImpl::Create(
1093 int32 opener_id,
1094 const RendererPreferences& renderer_prefs,
1095 const WebPreferences& webkit_prefs,
1096 int32 routing_id,
1097 int32 main_frame_routing_id,
1098 int32 surface_id,
1099 int64 session_storage_namespace_id,
1100 const base::string16& frame_name,
1101 bool is_renderer_created,
1102 bool swapped_out,
1103 bool hidden,
1104 int32 next_page_id,
1105 const blink::WebScreenInfo& screen_info,
1106 AccessibilityMode accessibility_mode,
1107 bool allow_partial_swap) {
1108 DCHECK(routing_id != MSG_ROUTING_NONE);
1109 RenderViewImplParams params(
1110 opener_id,
1111 renderer_prefs,
1112 webkit_prefs,
1113 routing_id,
1114 main_frame_routing_id,
1115 surface_id,
1116 session_storage_namespace_id,
1117 frame_name,
1118 is_renderer_created,
1119 swapped_out,
1120 hidden,
1121 next_page_id,
1122 screen_info,
1123 accessibility_mode,
1124 allow_partial_swap);
1125 RenderViewImpl* render_view = NULL;
1126 if (g_create_render_view_impl)
1127 render_view = g_create_render_view_impl(¶ms);
1128 else
1129 render_view = new RenderViewImpl(¶ms);
1130 render_view->Initialize(¶ms);
1131 return render_view;
1132 }
1133
1134 // static
InstallCreateHook(RenderViewImpl * (* create_render_view_impl)(RenderViewImplParams *))1135 void RenderViewImpl::InstallCreateHook(
1136 RenderViewImpl* (*create_render_view_impl)(RenderViewImplParams*)) {
1137 CHECK(!g_create_render_view_impl);
1138 g_create_render_view_impl = create_render_view_impl;
1139 }
1140
AddObserver(RenderViewObserver * observer)1141 void RenderViewImpl::AddObserver(RenderViewObserver* observer) {
1142 observers_.AddObserver(observer);
1143 }
1144
RemoveObserver(RenderViewObserver * observer)1145 void RenderViewImpl::RemoveObserver(RenderViewObserver* observer) {
1146 observer->RenderViewGone();
1147 observers_.RemoveObserver(observer);
1148 }
1149
webview() const1150 blink::WebView* RenderViewImpl::webview() const {
1151 return static_cast<blink::WebView*>(webwidget());
1152 }
1153
1154 #if defined(ENABLE_PLUGINS)
RegisterPluginDelegate(WebPluginDelegateProxy * delegate)1155 void RenderViewImpl::RegisterPluginDelegate(WebPluginDelegateProxy* delegate) {
1156 plugin_delegates_.insert(delegate);
1157 // If the renderer is visible, set initial visibility and focus state.
1158 if (!is_hidden()) {
1159 #if defined(OS_MACOSX)
1160 delegate->SetContainerVisibility(true);
1161 if (webview() && webview()->isActive())
1162 delegate->SetWindowFocus(true);
1163 #endif
1164 }
1165 // Plugins start assuming the content has focus (so that they work in
1166 // environments where RenderView isn't hosting them), so we always have to
1167 // set the initial state. See webplugin_delegate_impl.h for details.
1168 delegate->SetContentAreaFocus(has_focus());
1169 }
1170
UnregisterPluginDelegate(WebPluginDelegateProxy * delegate)1171 void RenderViewImpl::UnregisterPluginDelegate(
1172 WebPluginDelegateProxy* delegate) {
1173 plugin_delegates_.erase(delegate);
1174 }
1175
1176 #if defined(OS_WIN)
PluginFocusChanged(bool focused,int plugin_id)1177 void RenderViewImpl::PluginFocusChanged(bool focused, int plugin_id) {
1178 if (focused)
1179 focused_plugin_id_ = plugin_id;
1180 else
1181 focused_plugin_id_ = -1;
1182 }
1183 #endif
1184
1185 #if defined(OS_MACOSX)
PluginFocusChanged(bool focused,int plugin_id)1186 void RenderViewImpl::PluginFocusChanged(bool focused, int plugin_id) {
1187 Send(new ViewHostMsg_PluginFocusChanged(routing_id(), focused, plugin_id));
1188 }
1189
StartPluginIme()1190 void RenderViewImpl::StartPluginIme() {
1191 IPC::Message* msg = new ViewHostMsg_StartPluginIme(routing_id());
1192 // This message can be sent during event-handling, and needs to be delivered
1193 // within that context.
1194 msg->set_unblock(true);
1195 Send(msg);
1196 }
1197 #endif // defined(OS_MACOSX)
1198
1199 #endif // ENABLE_PLUGINS
1200
TransferActiveWheelFlingAnimation(const blink::WebActiveWheelFlingParameters & params)1201 void RenderViewImpl::TransferActiveWheelFlingAnimation(
1202 const blink::WebActiveWheelFlingParameters& params) {
1203 if (webview())
1204 webview()->transferActiveWheelFlingAnimation(params);
1205 }
1206
HasIMETextFocus()1207 bool RenderViewImpl::HasIMETextFocus() {
1208 return GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE;
1209 }
1210
OnMessageReceived(const IPC::Message & message)1211 bool RenderViewImpl::OnMessageReceived(const IPC::Message& message) {
1212 WebFrame* main_frame = webview() ? webview()->mainFrame() : NULL;
1213 if (main_frame)
1214 GetContentClient()->SetActiveURL(main_frame->document().url());
1215
1216 ObserverListBase<RenderViewObserver>::Iterator it(observers_);
1217 RenderViewObserver* observer;
1218 while ((observer = it.GetNext()) != NULL)
1219 if (observer->OnMessageReceived(message))
1220 return true;
1221
1222 bool handled = true;
1223 bool msg_is_ok = true;
1224 IPC_BEGIN_MESSAGE_MAP_EX(RenderViewImpl, message, msg_is_ok)
1225 IPC_MESSAGE_HANDLER(InputMsg_Copy, OnCopy)
1226 IPC_MESSAGE_HANDLER(InputMsg_Cut, OnCut)
1227 IPC_MESSAGE_HANDLER(InputMsg_Delete, OnDelete)
1228 IPC_MESSAGE_HANDLER(InputMsg_ExecuteEditCommand, OnExecuteEditCommand)
1229 IPC_MESSAGE_HANDLER(InputMsg_MoveCaret, OnMoveCaret)
1230 IPC_MESSAGE_HANDLER(InputMsg_Paste, OnPaste)
1231 IPC_MESSAGE_HANDLER(InputMsg_PasteAndMatchStyle, OnPasteAndMatchStyle)
1232 IPC_MESSAGE_HANDLER(InputMsg_Redo, OnRedo)
1233 IPC_MESSAGE_HANDLER(InputMsg_Replace, OnReplace)
1234 IPC_MESSAGE_HANDLER(InputMsg_ReplaceMisspelling, OnReplaceMisspelling)
1235 IPC_MESSAGE_HANDLER(InputMsg_ScrollFocusedEditableNodeIntoRect,
1236 OnScrollFocusedEditableNodeIntoRect)
1237 IPC_MESSAGE_HANDLER(InputMsg_SelectAll, OnSelectAll)
1238 IPC_MESSAGE_HANDLER(InputMsg_SelectRange, OnSelectRange)
1239 IPC_MESSAGE_HANDLER(InputMsg_SetEditCommandsForNextKeyEvent,
1240 OnSetEditCommandsForNextKeyEvent)
1241 IPC_MESSAGE_HANDLER(InputMsg_Undo, OnUndo)
1242 IPC_MESSAGE_HANDLER(InputMsg_Unselect, OnUnselect)
1243 IPC_MESSAGE_HANDLER(ViewMsg_Navigate, OnNavigate)
1244 IPC_MESSAGE_HANDLER(ViewMsg_Stop, OnStop)
1245 IPC_MESSAGE_HANDLER(ViewMsg_ReloadFrame, OnReloadFrame)
1246 IPC_MESSAGE_HANDLER(ViewMsg_SetName, OnSetName)
1247 IPC_MESSAGE_HANDLER(ViewMsg_SetEditableSelectionOffsets,
1248 OnSetEditableSelectionOffsets)
1249 IPC_MESSAGE_HANDLER(ViewMsg_SetCompositionFromExistingText,
1250 OnSetCompositionFromExistingText)
1251 IPC_MESSAGE_HANDLER(ViewMsg_ExtendSelectionAndDelete,
1252 OnExtendSelectionAndDelete)
1253 IPC_MESSAGE_HANDLER(ViewMsg_CopyImageAt, OnCopyImageAt)
1254 IPC_MESSAGE_HANDLER(ViewMsg_Find, OnFind)
1255 IPC_MESSAGE_HANDLER(ViewMsg_StopFinding, OnStopFinding)
1256 IPC_MESSAGE_HANDLER(ViewMsg_Zoom, OnZoom)
1257 IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevel, OnSetZoomLevel)
1258 IPC_MESSAGE_HANDLER(ViewMsg_ZoomFactor, OnZoomFactor)
1259 IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForLoadingURL,
1260 OnSetZoomLevelForLoadingURL)
1261 IPC_MESSAGE_HANDLER(ViewMsg_SetPageEncoding, OnSetPageEncoding)
1262 IPC_MESSAGE_HANDLER(ViewMsg_ResetPageEncodingToDefault,
1263 OnResetPageEncodingToDefault)
1264 IPC_MESSAGE_HANDLER(ViewMsg_ScriptEvalRequest, OnScriptEvalRequest)
1265 IPC_MESSAGE_HANDLER(ViewMsg_PostMessageEvent, OnPostMessageEvent)
1266 IPC_MESSAGE_HANDLER(ViewMsg_CSSInsertRequest, OnCSSInsertRequest)
1267 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
1268 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
1269 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
1270 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
1271 IPC_MESSAGE_HANDLER(DragMsg_SourceEndedOrMoved, OnDragSourceEndedOrMoved)
1272 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
1273 OnDragSourceSystemDragEnded)
1274 IPC_MESSAGE_HANDLER(ViewMsg_AllowBindings, OnAllowBindings)
1275 IPC_MESSAGE_HANDLER(ViewMsg_SetInitialFocus, OnSetInitialFocus)
1276 IPC_MESSAGE_HANDLER(ViewMsg_UpdateTargetURL_ACK, OnUpdateTargetURLAck)
1277 IPC_MESSAGE_HANDLER(ViewMsg_UpdateWebPreferences, OnUpdateWebPreferences)
1278 IPC_MESSAGE_HANDLER(ViewMsg_TimezoneChange, OnUpdateTimezone)
1279 IPC_MESSAGE_HANDLER(ViewMsg_SetAltErrorPageURL, OnSetAltErrorPageURL)
1280 IPC_MESSAGE_HANDLER(ViewMsg_EnumerateDirectoryResponse,
1281 OnEnumerateDirectoryResponse)
1282 IPC_MESSAGE_HANDLER(ViewMsg_RunFileChooserResponse, OnFileChooserResponse)
1283 IPC_MESSAGE_HANDLER(ViewMsg_ShouldClose, OnShouldClose)
1284 IPC_MESSAGE_HANDLER(ViewMsg_SuppressDialogsUntilSwapOut,
1285 OnSuppressDialogsUntilSwapOut)
1286 IPC_MESSAGE_HANDLER(ViewMsg_SwapOut, OnSwapOut)
1287 IPC_MESSAGE_HANDLER(ViewMsg_ClosePage, OnClosePage)
1288 IPC_MESSAGE_HANDLER(ViewMsg_ThemeChanged, OnThemeChanged)
1289 IPC_MESSAGE_HANDLER(ViewMsg_MoveOrResizeStarted, OnMoveOrResizeStarted)
1290 IPC_MESSAGE_HANDLER(ViewMsg_ClearFocusedNode, OnClearFocusedNode)
1291 IPC_MESSAGE_HANDLER(ViewMsg_SetBackground, OnSetBackground)
1292 IPC_MESSAGE_HANDLER(ViewMsg_EnablePreferredSizeChangedMode,
1293 OnEnablePreferredSizeChangedMode)
1294 IPC_MESSAGE_HANDLER(ViewMsg_EnableAutoResize, OnEnableAutoResize)
1295 IPC_MESSAGE_HANDLER(ViewMsg_DisableAutoResize, OnDisableAutoResize)
1296 IPC_MESSAGE_HANDLER(ViewMsg_DisableScrollbarsForSmallWindows,
1297 OnDisableScrollbarsForSmallWindows)
1298 IPC_MESSAGE_HANDLER(ViewMsg_SetRendererPrefs, OnSetRendererPrefs)
1299 IPC_MESSAGE_HANDLER(ViewMsg_MediaPlayerActionAt, OnMediaPlayerActionAt)
1300 IPC_MESSAGE_HANDLER(ViewMsg_OrientationChangeEvent,
1301 OnOrientationChangeEvent)
1302 IPC_MESSAGE_HANDLER(ViewMsg_PluginActionAt, OnPluginActionAt)
1303 IPC_MESSAGE_HANDLER(ViewMsg_SetActive, OnSetActive)
1304 IPC_MESSAGE_HANDLER(ViewMsg_CustomContextMenuAction,
1305 OnCustomContextMenuAction)
1306 IPC_MESSAGE_HANDLER(ViewMsg_GetAllSavableResourceLinksForCurrentPage,
1307 OnGetAllSavableResourceLinksForCurrentPage)
1308 IPC_MESSAGE_HANDLER(
1309 ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks,
1310 OnGetSerializedHtmlDataForCurrentPageWithLocalLinks)
1311 IPC_MESSAGE_HANDLER(ViewMsg_ContextMenuClosed, OnContextMenuClosed)
1312 IPC_MESSAGE_HANDLER(ViewMsg_ShowContextMenu, OnShowContextMenu)
1313 // TODO(viettrungluu): Move to a separate message filter.
1314 IPC_MESSAGE_HANDLER(ViewMsg_SetHistoryLengthAndPrune,
1315 OnSetHistoryLengthAndPrune)
1316 IPC_MESSAGE_HANDLER(ViewMsg_EnableViewSourceMode, OnEnableViewSourceMode)
1317 IPC_MESSAGE_HANDLER(ViewMsg_SetAccessibilityMode, OnSetAccessibilityMode)
1318 IPC_MESSAGE_HANDLER(ViewMsg_DisownOpener, OnDisownOpener)
1319 IPC_MESSAGE_HANDLER(ViewMsg_ReleaseDisambiguationPopupDIB,
1320 OnReleaseDisambiguationPopupDIB)
1321 IPC_MESSAGE_HANDLER(ViewMsg_WindowSnapshotCompleted,
1322 OnWindowSnapshotCompleted)
1323 #if defined(OS_ANDROID)
1324 IPC_MESSAGE_HANDLER(InputMsg_ActivateNearestFindResult,
1325 OnActivateNearestFindResult)
1326 IPC_MESSAGE_HANDLER(ViewMsg_FindMatchRects, OnFindMatchRects)
1327 IPC_MESSAGE_HANDLER(ViewMsg_SelectPopupMenuItems, OnSelectPopupMenuItems)
1328 IPC_MESSAGE_HANDLER(ViewMsg_UndoScrollFocusedEditableNodeIntoView,
1329 OnUndoScrollFocusedEditableNodeIntoRect)
1330 IPC_MESSAGE_HANDLER(ViewMsg_UpdateTopControlsState,
1331 OnUpdateTopControlsState)
1332 IPC_MESSAGE_HANDLER(ViewMsg_PauseVideo, OnPauseVideo)
1333 IPC_MESSAGE_HANDLER(ViewMsg_ExtractSmartClipData, OnExtractSmartClipData)
1334 #elif defined(OS_MACOSX)
1335 IPC_MESSAGE_HANDLER(InputMsg_CopyToFindPboard, OnCopyToFindPboard)
1336 IPC_MESSAGE_HANDLER(ViewMsg_PluginImeCompositionCompleted,
1337 OnPluginImeCompositionCompleted)
1338 IPC_MESSAGE_HANDLER(ViewMsg_SelectPopupMenuItem, OnSelectPopupMenuItem)
1339 IPC_MESSAGE_HANDLER(ViewMsg_SetInLiveResize, OnSetInLiveResize)
1340 IPC_MESSAGE_HANDLER(ViewMsg_SetWindowVisibility, OnSetWindowVisibility)
1341 IPC_MESSAGE_HANDLER(ViewMsg_WindowFrameChanged, OnWindowFrameChanged)
1342 #endif
1343 // Adding a new message? Add platform independent ones first, then put the
1344 // platform specific ones at the end.
1345
1346 // Have the super handle all other messages.
1347 IPC_MESSAGE_UNHANDLED(handled = RenderWidget::OnMessageReceived(message))
1348 IPC_END_MESSAGE_MAP()
1349
1350 if (!msg_is_ok) {
1351 // The message had a handler, but its deserialization failed.
1352 // Kill the renderer to avoid potential spoofing attacks.
1353 CHECK(false) << "Unable to deserialize message in RenderViewImpl.";
1354 }
1355
1356 return handled;
1357 }
1358
OnNavigate(const ViewMsg_Navigate_Params & params)1359 void RenderViewImpl::OnNavigate(const ViewMsg_Navigate_Params& params) {
1360 MaybeHandleDebugURL(params.url);
1361 if (!webview())
1362 return;
1363
1364 FOR_EACH_OBSERVER(RenderViewObserver, observers_, Navigate(params.url));
1365
1366 bool is_reload = IsReload(params);
1367
1368 // If this is a stale back/forward (due to a recent navigation the browser
1369 // didn't know about), ignore it.
1370 if (IsBackForwardToStaleEntry(params, is_reload))
1371 return;
1372
1373 // Swap this renderer back in if necessary.
1374 if (is_swapped_out_) {
1375 // We marked the view as hidden when swapping the view out, so be sure to
1376 // reset the visibility state before navigating to the new URL.
1377 webview()->setVisibilityState(visibilityState(), false);
1378
1379 // If this is an attempt to reload while we are swapped out, we should not
1380 // reload swappedout://, but the previous page, which is stored in
1381 // params.state. Setting is_reload to false will treat this like a back
1382 // navigation to accomplish that.
1383 is_reload = false;
1384
1385 // We refresh timezone when a view is swapped in since timezone
1386 // can get out of sync when the system timezone is updated while
1387 // the view is swapped out.
1388 NotifyTimezoneChange(webview()->mainFrame());
1389
1390 SetSwappedOut(false);
1391 }
1392
1393 if (params.should_clear_history_list) {
1394 CHECK_EQ(params.pending_history_list_offset, -1);
1395 CHECK_EQ(params.current_history_list_offset, -1);
1396 CHECK_EQ(params.current_history_list_length, 0);
1397 }
1398 history_list_offset_ = params.current_history_list_offset;
1399 history_list_length_ = params.current_history_list_length;
1400 if (history_list_length_ >= 0)
1401 history_page_ids_.resize(history_list_length_, -1);
1402 if (params.pending_history_list_offset >= 0 &&
1403 params.pending_history_list_offset < history_list_length_)
1404 history_page_ids_[params.pending_history_list_offset] = params.page_id;
1405
1406 GetContentClient()->SetActiveURL(params.url);
1407
1408 WebFrame* frame = webview()->mainFrame();
1409 if (!params.frame_to_navigate.empty()) {
1410 frame = webview()->findFrameByName(
1411 WebString::fromUTF8(params.frame_to_navigate));
1412 CHECK(frame) << "Invalid frame name passed: " << params.frame_to_navigate;
1413 }
1414
1415 if (is_reload && frame->currentHistoryItem().isNull()) {
1416 // We cannot reload if we do not have any history state. This happens, for
1417 // example, when recovering from a crash. Our workaround here is a bit of
1418 // a hack since it means that reload after a crashed tab does not cause an
1419 // end-to-end cache validation.
1420 is_reload = false;
1421 }
1422
1423 pending_navigation_params_.reset(new ViewMsg_Navigate_Params(params));
1424
1425 // If we are reloading, then WebKit will use the history state of the current
1426 // page, so we should just ignore any given history state. Otherwise, if we
1427 // have history state, then we need to navigate to it, which corresponds to a
1428 // back/forward navigation event.
1429 if (is_reload) {
1430 bool reload_original_url =
1431 (params.navigation_type ==
1432 ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL);
1433 bool ignore_cache = (params.navigation_type ==
1434 ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE);
1435
1436 if (reload_original_url)
1437 frame->reloadWithOverrideURL(params.url, true);
1438 else
1439 frame->reload(ignore_cache);
1440 } else if (params.page_state.IsValid()) {
1441 // We must know the page ID of the page we are navigating back to.
1442 DCHECK_NE(params.page_id, -1);
1443 WebHistoryItem item = PageStateToHistoryItem(params.page_state);
1444 if (!item.isNull()) {
1445 // Ensure we didn't save the swapped out URL in UpdateState, since the
1446 // browser should never be telling us to navigate to swappedout://.
1447 CHECK(item.urlString() != WebString::fromUTF8(kSwappedOutURL));
1448 frame->loadHistoryItem(item);
1449 }
1450 } else if (!params.base_url_for_data_url.is_empty()) {
1451 // A loadData request with a specified base URL.
1452 std::string mime_type, charset, data;
1453 if (net::DataURL::Parse(params.url, &mime_type, &charset, &data)) {
1454 frame->loadData(
1455 WebData(data.c_str(), data.length()),
1456 WebString::fromUTF8(mime_type),
1457 WebString::fromUTF8(charset),
1458 params.base_url_for_data_url,
1459 params.history_url_for_data_url,
1460 false);
1461 } else {
1462 CHECK(false) <<
1463 "Invalid URL passed: " << params.url.possibly_invalid_spec();
1464 }
1465 } else {
1466 // Navigate to the given URL.
1467 WebURLRequest request(params.url);
1468
1469 // A session history navigation should have been accompanied by state.
1470 CHECK_EQ(params.page_id, -1);
1471
1472 if (frame->isViewSourceModeEnabled())
1473 request.setCachePolicy(WebURLRequest::ReturnCacheDataElseLoad);
1474
1475 if (params.referrer.url.is_valid()) {
1476 WebString referrer = WebSecurityPolicy::generateReferrerHeader(
1477 params.referrer.policy,
1478 params.url,
1479 WebString::fromUTF8(params.referrer.url.spec()));
1480 if (!referrer.isEmpty())
1481 request.setHTTPHeaderField(WebString::fromUTF8("Referer"), referrer);
1482 }
1483
1484 if (!params.extra_headers.empty()) {
1485 for (net::HttpUtil::HeadersIterator i(params.extra_headers.begin(),
1486 params.extra_headers.end(), "\n");
1487 i.GetNext(); ) {
1488 request.addHTTPHeaderField(WebString::fromUTF8(i.name()),
1489 WebString::fromUTF8(i.values()));
1490 }
1491 }
1492
1493 if (params.is_post) {
1494 request.setHTTPMethod(WebString::fromUTF8("POST"));
1495
1496 // Set post data.
1497 WebHTTPBody http_body;
1498 http_body.initialize();
1499 const char* data = NULL;
1500 if (params.browser_initiated_post_data.size()) {
1501 data = reinterpret_cast<const char*>(
1502 ¶ms.browser_initiated_post_data.front());
1503 }
1504 http_body.appendData(
1505 WebData(data, params.browser_initiated_post_data.size()));
1506 request.setHTTPBody(http_body);
1507 }
1508
1509 frame->loadRequest(request);
1510
1511 // If this is a cross-process navigation, the browser process will send
1512 // along the proper navigation start value.
1513 if (!params.browser_navigation_start.is_null() &&
1514 frame->provisionalDataSource()) {
1515 // browser_navigation_start is likely before this process existed, so we
1516 // can't use InterProcessTimeTicksConverter. Instead, the best we can do
1517 // is just ensure we don't report a bogus value in the future.
1518 base::TimeTicks navigation_start = std::min(
1519 base::TimeTicks::Now(), params.browser_navigation_start);
1520 double navigation_start_seconds =
1521 (navigation_start - base::TimeTicks()).InSecondsF();
1522 frame->provisionalDataSource()->setNavigationStartTime(
1523 navigation_start_seconds);
1524 }
1525 }
1526
1527 // In case LoadRequest failed before DidCreateDataSource was called.
1528 pending_navigation_params_.reset();
1529 }
1530
IsBackForwardToStaleEntry(const ViewMsg_Navigate_Params & params,bool is_reload)1531 bool RenderViewImpl::IsBackForwardToStaleEntry(
1532 const ViewMsg_Navigate_Params& params,
1533 bool is_reload) {
1534 // Make sure this isn't a back/forward to an entry we have already cropped
1535 // or replaced from our history, before the browser knew about it. If so,
1536 // a new navigation has committed in the mean time, and we can ignore this.
1537 bool is_back_forward = !is_reload && params.page_state.IsValid();
1538
1539 // Note: if the history_list_length_ is 0 for a back/forward, we must be
1540 // restoring from a previous session. We'll update our state in OnNavigate.
1541 if (!is_back_forward || history_list_length_ <= 0)
1542 return false;
1543
1544 DCHECK_EQ(static_cast<int>(history_page_ids_.size()), history_list_length_);
1545
1546 // Check for whether the forward history has been cropped due to a recent
1547 // navigation the browser didn't know about.
1548 if (params.pending_history_list_offset >= history_list_length_)
1549 return true;
1550
1551 // Check for whether this entry has been replaced with a new one.
1552 int expected_page_id =
1553 history_page_ids_[params.pending_history_list_offset];
1554 if (expected_page_id > 0 && params.page_id != expected_page_id) {
1555 if (params.page_id < expected_page_id)
1556 return true;
1557
1558 // Otherwise we've removed an earlier entry and should have shifted all
1559 // entries left. For now, it's ok to lazily update the list.
1560 // TODO(creis): Notify all live renderers when we remove entries from
1561 // the front of the list, so that we don't hit this case.
1562 history_page_ids_[params.pending_history_list_offset] = params.page_id;
1563 }
1564
1565 return false;
1566 }
1567
1568 // Stop loading the current page
OnStop()1569 void RenderViewImpl::OnStop() {
1570 if (webview()) {
1571 WebFrame* main_frame = webview()->mainFrame();
1572 // Stop the alt error page fetcher. If we let it continue it may complete
1573 // and cause RenderFrameHostManager to swap to this RenderView, even though
1574 // it may no longer be active.
1575 StopAltErrorPageFetcher(main_frame->provisionalDataSource());
1576 StopAltErrorPageFetcher(main_frame->dataSource());
1577 main_frame->stopLoading();
1578 }
1579 }
1580
1581 // Reload current focused frame.
1582 // E.g. called by right-clicking on the frame and picking "reload this frame".
OnReloadFrame()1583 void RenderViewImpl::OnReloadFrame() {
1584 if (webview() && webview()->focusedFrame()) {
1585 // We always obey the cache (ignore_cache=false) here.
1586 // TODO(evanm): perhaps we could allow shift-clicking the menu item to do
1587 // a cache-ignoring reload of the frame.
1588 webview()->focusedFrame()->reload(false);
1589 }
1590 }
1591
OnCopyImageAt(int x,int y)1592 void RenderViewImpl::OnCopyImageAt(int x, int y) {
1593 webview()->copyImageAt(WebPoint(x, y));
1594 }
1595
OnUpdateTargetURLAck()1596 void RenderViewImpl::OnUpdateTargetURLAck() {
1597 // Check if there is a targeturl waiting to be sent.
1598 if (target_url_status_ == TARGET_PENDING) {
1599 Send(new ViewHostMsg_UpdateTargetURL(routing_id_, page_id_,
1600 pending_target_url_));
1601 }
1602
1603 target_url_status_ = TARGET_NONE;
1604 }
1605
OnCopy()1606 void RenderViewImpl::OnCopy() {
1607 if (!webview())
1608 return;
1609
1610 base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
1611 WebNode current_node = context_menu_node_.isNull() ?
1612 GetFocusedNode() : context_menu_node_;
1613 webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Copy"),
1614 current_node);
1615 }
1616
OnCut()1617 void RenderViewImpl::OnCut() {
1618 if (!webview())
1619 return;
1620
1621 base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
1622 webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Cut"),
1623 GetFocusedNode());
1624 }
1625
OnDelete()1626 void RenderViewImpl::OnDelete() {
1627 if (!webview())
1628 return;
1629
1630 webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Delete"),
1631 GetFocusedNode());
1632 }
1633
OnExecuteEditCommand(const std::string & name,const std::string & value)1634 void RenderViewImpl::OnExecuteEditCommand(const std::string& name,
1635 const std::string& value) {
1636 if (!webview() || !webview()->focusedFrame())
1637 return;
1638
1639 webview()->focusedFrame()->executeCommand(
1640 WebString::fromUTF8(name), WebString::fromUTF8(value));
1641 }
1642
OnMoveCaret(const gfx::Point & point)1643 void RenderViewImpl::OnMoveCaret(const gfx::Point& point) {
1644 if (!webview())
1645 return;
1646
1647 Send(new ViewHostMsg_MoveCaret_ACK(routing_id_));
1648
1649 webview()->focusedFrame()->moveCaretSelection(point);
1650 }
1651
OnPaste()1652 void RenderViewImpl::OnPaste() {
1653 if (!webview())
1654 return;
1655
1656 base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
1657 webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Paste"),
1658 GetFocusedNode());
1659 }
1660
OnPasteAndMatchStyle()1661 void RenderViewImpl::OnPasteAndMatchStyle() {
1662 if (!webview())
1663 return;
1664
1665 base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
1666 webview()->focusedFrame()->executeCommand(
1667 WebString::fromUTF8("PasteAndMatchStyle"), GetFocusedNode());
1668 }
1669
OnRedo()1670 void RenderViewImpl::OnRedo() {
1671 if (!webview())
1672 return;
1673
1674 webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Redo"),
1675 GetFocusedNode());
1676 }
1677
OnReplace(const base::string16 & text)1678 void RenderViewImpl::OnReplace(const base::string16& text) {
1679 if (!webview())
1680 return;
1681
1682 WebFrame* frame = webview()->focusedFrame();
1683 if (!frame->hasSelection())
1684 frame->selectWordAroundCaret();
1685
1686 frame->replaceSelection(text);
1687 }
1688
OnReplaceMisspelling(const base::string16 & text)1689 void RenderViewImpl::OnReplaceMisspelling(const base::string16& text) {
1690 if (!webview())
1691 return;
1692
1693 WebFrame* frame = webview()->focusedFrame();
1694 if (!frame->hasSelection())
1695 return;
1696
1697 frame->replaceMisspelledRange(text);
1698 }
1699
OnScrollFocusedEditableNodeIntoRect(const gfx::Rect & rect)1700 void RenderViewImpl::OnScrollFocusedEditableNodeIntoRect(
1701 const gfx::Rect& rect) {
1702 blink::WebNode node = GetFocusedNode();
1703 if (!node.isNull()) {
1704 if (IsEditableNode(node)) {
1705 webview()->saveScrollAndScaleState();
1706 webview()->scrollFocusedNodeIntoRect(rect);
1707 }
1708 }
1709 }
1710
OnSelectAll()1711 void RenderViewImpl::OnSelectAll() {
1712 if (!webview())
1713 return;
1714
1715 base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
1716 webview()->focusedFrame()->executeCommand(
1717 WebString::fromUTF8("SelectAll"), GetFocusedNode());
1718 }
1719
OnSelectRange(const gfx::Point & start,const gfx::Point & end)1720 void RenderViewImpl::OnSelectRange(const gfx::Point& start,
1721 const gfx::Point& end) {
1722 if (!webview())
1723 return;
1724
1725 Send(new ViewHostMsg_SelectRange_ACK(routing_id_));
1726
1727 base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
1728 webview()->focusedFrame()->selectRange(start, end);
1729 }
1730
OnSetEditCommandsForNextKeyEvent(const EditCommands & edit_commands)1731 void RenderViewImpl::OnSetEditCommandsForNextKeyEvent(
1732 const EditCommands& edit_commands) {
1733 edit_commands_ = edit_commands;
1734 }
1735
OnUndo()1736 void RenderViewImpl::OnUndo() {
1737 if (!webview())
1738 return;
1739
1740 webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Undo"),
1741 GetFocusedNode());
1742 }
1743
OnUnselect()1744 void RenderViewImpl::OnUnselect() {
1745 if (!webview())
1746 return;
1747
1748 base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
1749 webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Unselect"),
1750 GetFocusedNode());
1751 }
1752
1753 #if defined(OS_MACOSX)
OnCopyToFindPboard()1754 void RenderViewImpl::OnCopyToFindPboard() {
1755 if (!webview())
1756 return;
1757
1758 // Since the find pasteboard supports only plain text, this can be simpler
1759 // than the |OnCopy()| case.
1760 WebFrame* frame = webview()->focusedFrame();
1761 if (frame->hasSelection()) {
1762 base::string16 selection = frame->selectionAsText();
1763 RenderThread::Get()->Send(
1764 new ClipboardHostMsg_FindPboardWriteStringAsync(selection));
1765 }
1766 }
1767 #endif
1768
OnSetName(const std::string & name)1769 void RenderViewImpl::OnSetName(const std::string& name) {
1770 if (!webview())
1771 return;
1772
1773 webview()->mainFrame()->setName(WebString::fromUTF8(name));
1774 }
1775
OnSetEditableSelectionOffsets(int start,int end)1776 void RenderViewImpl::OnSetEditableSelectionOffsets(int start, int end) {
1777 base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
1778 if (!ShouldHandleImeEvent())
1779 return;
1780 ImeEventGuard guard(this);
1781 webview()->setEditableSelectionOffsets(start, end);
1782 }
1783
OnSetCompositionFromExistingText(int start,int end,const std::vector<blink::WebCompositionUnderline> & underlines)1784 void RenderViewImpl::OnSetCompositionFromExistingText(
1785 int start, int end,
1786 const std::vector<blink::WebCompositionUnderline>& underlines) {
1787 if (!ShouldHandleImeEvent())
1788 return;
1789 ImeEventGuard guard(this);
1790 webview()->setCompositionFromExistingText(start, end, underlines);
1791 }
1792
OnExtendSelectionAndDelete(int before,int after)1793 void RenderViewImpl::OnExtendSelectionAndDelete(int before, int after) {
1794 if (!ShouldHandleImeEvent())
1795 return;
1796 ImeEventGuard guard(this);
1797 webview()->extendSelectionAndDelete(before, after);
1798 }
1799
OnSetHistoryLengthAndPrune(int history_length,int32 minimum_page_id)1800 void RenderViewImpl::OnSetHistoryLengthAndPrune(int history_length,
1801 int32 minimum_page_id) {
1802 DCHECK_GE(history_length, 0);
1803 DCHECK(history_list_offset_ == history_list_length_ - 1);
1804 DCHECK_GE(minimum_page_id, -1);
1805
1806 // Generate the new list.
1807 std::vector<int32> new_history_page_ids(history_length, -1);
1808 for (size_t i = 0; i < history_page_ids_.size(); ++i) {
1809 if (minimum_page_id >= 0 && history_page_ids_[i] < minimum_page_id)
1810 continue;
1811 new_history_page_ids.push_back(history_page_ids_[i]);
1812 }
1813 new_history_page_ids.swap(history_page_ids_);
1814
1815 // Update indexes.
1816 history_list_length_ = history_page_ids_.size();
1817 history_list_offset_ = history_list_length_ - 1;
1818 }
1819
1820
OnSetInitialFocus(bool reverse)1821 void RenderViewImpl::OnSetInitialFocus(bool reverse) {
1822 if (!webview())
1823 return;
1824 webview()->setInitialFocus(reverse);
1825 }
1826
1827 #if defined(OS_MACOSX)
OnSetInLiveResize(bool in_live_resize)1828 void RenderViewImpl::OnSetInLiveResize(bool in_live_resize) {
1829 if (!webview())
1830 return;
1831 if (in_live_resize)
1832 webview()->willStartLiveResize();
1833 else
1834 webview()->willEndLiveResize();
1835 }
1836 #endif
1837
1838 #if defined(OS_ANDROID)
OnUndoScrollFocusedEditableNodeIntoRect()1839 void RenderViewImpl::OnUndoScrollFocusedEditableNodeIntoRect() {
1840 const WebNode node = GetFocusedNode();
1841 if (!node.isNull() && IsEditableNode(node))
1842 webview()->restoreScrollAndScaleState();
1843 }
1844
OnPauseVideo()1845 void RenderViewImpl::OnPauseVideo() {
1846 // Inform RendererMediaPlayerManager to release all video player resources.
1847 // If something is in progress the resource will not be freed, it will
1848 // only be freed once the tab is destroyed or if the user navigates away
1849 // via WebMediaPlayerAndroid::Destroy.
1850 media_player_manager_->ReleaseVideoResources();
1851 }
1852 #endif
1853
1854 ///////////////////////////////////////////////////////////////////////////////
1855
1856 // Tell the embedding application that the URL of the active page has changed
UpdateURL(WebFrame * frame)1857 void RenderViewImpl::UpdateURL(WebFrame* frame) {
1858 WebDataSource* ds = frame->dataSource();
1859 DCHECK(ds);
1860
1861 const WebURLRequest& request = ds->request();
1862 const WebURLRequest& original_request = ds->originalRequest();
1863 const WebURLResponse& response = ds->response();
1864
1865 DocumentState* document_state = DocumentState::FromDataSource(ds);
1866 NavigationState* navigation_state = document_state->navigation_state();
1867 InternalDocumentStateData* internal_data =
1868 InternalDocumentStateData::FromDocumentState(document_state);
1869
1870 ViewHostMsg_FrameNavigate_Params params;
1871 params.http_status_code = response.httpStatusCode();
1872 params.is_post = false;
1873 params.post_id = -1;
1874 params.page_id = page_id_;
1875 params.frame_id = frame->identifier();
1876 params.frame_unique_name = frame->uniqueName();
1877 params.socket_address.set_host(response.remoteIPAddress().utf8());
1878 params.socket_address.set_port(response.remotePort());
1879 WebURLResponseExtraDataImpl* extra_data = GetExtraDataFromResponse(response);
1880 if (extra_data) {
1881 params.was_fetched_via_proxy = extra_data->was_fetched_via_proxy();
1882 }
1883 params.was_within_same_page = navigation_state->was_within_same_page();
1884 params.security_info = response.securityInfo();
1885
1886 // Set the URL to be displayed in the browser UI to the user.
1887 params.url = GetLoadingUrl(frame);
1888 DCHECK(!is_swapped_out_ || params.url == GURL(kSwappedOutURL));
1889
1890 if (frame->document().baseURL() != params.url)
1891 params.base_url = frame->document().baseURL();
1892
1893 GetRedirectChain(ds, ¶ms.redirects);
1894 params.should_update_history = !ds->hasUnreachableURL() &&
1895 !response.isMultipartPayload() && (response.httpStatusCode() != 404);
1896
1897 params.searchable_form_url = internal_data->searchable_form_url();
1898 params.searchable_form_encoding = internal_data->searchable_form_encoding();
1899
1900 params.gesture = navigation_gesture_;
1901 navigation_gesture_ = NavigationGestureUnknown;
1902
1903 // Make navigation state a part of the FrameNavigate message so that commited
1904 // entry had it at all times.
1905 WebHistoryItem item = frame->currentHistoryItem();
1906 if (item.isNull()) {
1907 item.initialize();
1908 item.setURLString(request.url().spec().utf16());
1909 }
1910 params.page_state = HistoryItemToPageState(item);
1911
1912 if (!frame->parent()) {
1913 // Top-level navigation.
1914
1915 // Reset the zoom limits in case a plugin had changed them previously. This
1916 // will also call us back which will cause us to send a message to
1917 // update WebContentsImpl.
1918 webview()->zoomLimitsChanged(ZoomFactorToZoomLevel(kMinimumZoomFactor),
1919 ZoomFactorToZoomLevel(kMaximumZoomFactor));
1920
1921 // Set zoom level, but don't do it for full-page plugin since they don't use
1922 // the same zoom settings.
1923 HostZoomLevels::iterator host_zoom =
1924 host_zoom_levels_.find(GURL(request.url()));
1925 if (webview()->mainFrame()->document().isPluginDocument()) {
1926 // Reset the zoom levels for plugins.
1927 webview()->setZoomLevel(0);
1928 } else {
1929 if (host_zoom != host_zoom_levels_.end())
1930 webview()->setZoomLevel(host_zoom->second);
1931 }
1932
1933 if (host_zoom != host_zoom_levels_.end()) {
1934 // This zoom level was merely recorded transiently for this load. We can
1935 // erase it now. If at some point we reload this page, the browser will
1936 // send us a new, up-to-date zoom level.
1937 host_zoom_levels_.erase(host_zoom);
1938 }
1939
1940 // Update contents MIME type for main frame.
1941 params.contents_mime_type = ds->response().mimeType().utf8();
1942
1943 params.transition = navigation_state->transition_type();
1944 if (!PageTransitionIsMainFrame(params.transition)) {
1945 // If the main frame does a load, it should not be reported as a subframe
1946 // navigation. This can occur in the following case:
1947 // 1. You're on a site with frames.
1948 // 2. You do a subframe navigation. This is stored with transition type
1949 // MANUAL_SUBFRAME.
1950 // 3. You navigate to some non-frame site, say, google.com.
1951 // 4. You navigate back to the page from step 2. Since it was initially
1952 // MANUAL_SUBFRAME, it will be that same transition type here.
1953 // We don't want that, because any navigation that changes the toplevel
1954 // frame should be tracked as a toplevel navigation (this allows us to
1955 // update the URL bar, etc).
1956 params.transition = PAGE_TRANSITION_LINK;
1957 }
1958
1959 // If the page contained a client redirect (meta refresh, document.loc...),
1960 // set the referrer and transition appropriately.
1961 if (ds->isClientRedirect()) {
1962 params.referrer = Referrer(params.redirects[0],
1963 GetReferrerPolicyFromRequest(frame, ds->request()));
1964 params.transition = static_cast<PageTransition>(
1965 params.transition | PAGE_TRANSITION_CLIENT_REDIRECT);
1966 } else {
1967 // Bug 654101: the referrer will be empty on https->http transitions. It
1968 // would be nice if we could get the real referrer from somewhere.
1969 params.referrer = GetReferrerFromRequest(frame, original_request);
1970 }
1971
1972 base::string16 method = request.httpMethod();
1973 if (EqualsASCII(method, "POST")) {
1974 params.is_post = true;
1975 params.post_id = ExtractPostId(item);
1976 }
1977
1978 // Send the user agent override back.
1979 params.is_overriding_user_agent = internal_data->is_overriding_user_agent();
1980
1981 // Track the URL of the original request. We use the first entry of the
1982 // redirect chain if it exists because the chain may have started in another
1983 // process.
1984 params.original_request_url = GetOriginalRequestURL(ds);
1985
1986 params.history_list_was_cleared =
1987 navigation_state->history_list_was_cleared();
1988
1989 // Save some histogram data so we can compute the average memory used per
1990 // page load of the glyphs.
1991 UMA_HISTOGRAM_COUNTS_10000("Memory.GlyphPagesPerLoad",
1992 blink::WebGlyphCache::pageCount());
1993
1994 // This message needs to be sent before any of allowScripts(),
1995 // allowImages(), allowPlugins() is called for the new page, so that when
1996 // these functions send a ViewHostMsg_ContentBlocked message, it arrives
1997 // after the ViewHostMsg_FrameNavigate message.
1998 Send(new ViewHostMsg_FrameNavigate(routing_id_, params));
1999 } else {
2000 // Subframe navigation: the type depends on whether this navigation
2001 // generated a new session history entry. When they do generate a session
2002 // history entry, it means the user initiated the navigation and we should
2003 // mark it as such. This test checks if this is the first time UpdateURL
2004 // has been called since WillNavigateToURL was called to initiate the load.
2005 if (page_id_ > last_page_id_sent_to_browser_)
2006 params.transition = PAGE_TRANSITION_MANUAL_SUBFRAME;
2007 else
2008 params.transition = PAGE_TRANSITION_AUTO_SUBFRAME;
2009
2010 DCHECK(!navigation_state->history_list_was_cleared());
2011 params.history_list_was_cleared = false;
2012
2013 Send(new ViewHostMsg_FrameNavigate(routing_id_, params));
2014 }
2015
2016 last_page_id_sent_to_browser_ =
2017 std::max(last_page_id_sent_to_browser_, page_id_);
2018
2019 // If we end up reusing this WebRequest (for example, due to a #ref click),
2020 // we don't want the transition type to persist. Just clear it.
2021 navigation_state->set_transition_type(PAGE_TRANSITION_LINK);
2022 }
2023
2024 // Tell the embedding application that the title of the active page has changed
UpdateTitle(WebFrame * frame,const base::string16 & title,WebTextDirection title_direction)2025 void RenderViewImpl::UpdateTitle(WebFrame* frame,
2026 const base::string16& title,
2027 WebTextDirection title_direction) {
2028 // Ignore all but top level navigations.
2029 if (frame->parent())
2030 return;
2031
2032 base::debug::TraceLog::GetInstance()->UpdateProcessLabel(
2033 routing_id_, UTF16ToUTF8(title));
2034
2035 base::string16 shortened_title = title.substr(0, kMaxTitleChars);
2036 Send(new ViewHostMsg_UpdateTitle(routing_id_, page_id_, shortened_title,
2037 title_direction));
2038 }
2039
UpdateEncoding(WebFrame * frame,const std::string & encoding_name)2040 void RenderViewImpl::UpdateEncoding(WebFrame* frame,
2041 const std::string& encoding_name) {
2042 // Only update main frame's encoding_name.
2043 if (webview()->mainFrame() == frame &&
2044 last_encoding_name_ != encoding_name) {
2045 // Save the encoding name for later comparing.
2046 last_encoding_name_ = encoding_name;
2047
2048 Send(new ViewHostMsg_UpdateEncoding(routing_id_, last_encoding_name_));
2049 }
2050 }
2051
2052 // Sends the last committed session history state to the browser so it will be
2053 // saved before we navigate to a new page. This must be called *before* the
2054 // page ID has been updated so we know what it was.
UpdateSessionHistory(WebFrame * frame)2055 void RenderViewImpl::UpdateSessionHistory(WebFrame* frame) {
2056 // If we have a valid page ID at this point, then it corresponds to the page
2057 // we are navigating away from. Otherwise, this is the first navigation, so
2058 // there is no past session history to record.
2059 if (page_id_ == -1)
2060 return;
2061
2062 const WebHistoryItem& item =
2063 webview()->mainFrame()->previousHistoryItem();
2064 SendUpdateState(item);
2065 }
2066
SendUpdateState(const WebHistoryItem & item)2067 void RenderViewImpl::SendUpdateState(const WebHistoryItem& item) {
2068 if (item.isNull())
2069 return;
2070
2071 // Don't send state updates for kSwappedOutURL.
2072 if (item.urlString() == WebString::fromUTF8(kSwappedOutURL))
2073 return;
2074
2075 Send(new ViewHostMsg_UpdateState(
2076 routing_id_, page_id_, HistoryItemToPageState(item)));
2077 }
2078
OpenURL(WebFrame * frame,const GURL & url,const Referrer & referrer,WebNavigationPolicy policy)2079 void RenderViewImpl::OpenURL(WebFrame* frame,
2080 const GURL& url,
2081 const Referrer& referrer,
2082 WebNavigationPolicy policy) {
2083 ViewHostMsg_OpenURL_Params params;
2084 params.url = url;
2085 params.referrer = referrer;
2086 params.disposition = NavigationPolicyToDisposition(policy);
2087 params.frame_id = frame->identifier();
2088 WebDataSource* ds = frame->provisionalDataSource();
2089 if (ds) {
2090 DocumentState* document_state = DocumentState::FromDataSource(ds);
2091 NavigationState* navigation_state = document_state->navigation_state();
2092 if (navigation_state->is_content_initiated()) {
2093 params.should_replace_current_entry = ds->replacesCurrentHistoryItem();
2094 } else {
2095 // This is necessary to preserve the should_replace_current_entry value on
2096 // cross-process redirects, in the event it was set by a previous process.
2097 //
2098 // TODO(davidben): Avoid this awkward duplication of state. See comment on
2099 // NavigationState::should_replace_current_entry().
2100 params.should_replace_current_entry =
2101 navigation_state->should_replace_current_entry();
2102 }
2103 } else {
2104 params.should_replace_current_entry = false;
2105 }
2106 params.user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
2107 if (GetContentClient()->renderer()->AllowPopup())
2108 params.user_gesture = true;
2109
2110 if (policy == blink::WebNavigationPolicyNewBackgroundTab ||
2111 policy == blink::WebNavigationPolicyNewForegroundTab ||
2112 policy == blink::WebNavigationPolicyNewWindow ||
2113 policy == blink::WebNavigationPolicyNewPopup) {
2114 WebUserGestureIndicator::consumeUserGesture();
2115 }
2116
2117 Send(new ViewHostMsg_OpenURL(routing_id_, params));
2118 }
2119
2120 // WebViewDelegate ------------------------------------------------------------
2121
LoadNavigationErrorPage(WebFrame * frame,const WebURLRequest & failed_request,const WebURLError & error,const std::string & html,bool replace)2122 void RenderViewImpl::LoadNavigationErrorPage(
2123 WebFrame* frame,
2124 const WebURLRequest& failed_request,
2125 const WebURLError& error,
2126 const std::string& html,
2127 bool replace) {
2128 std::string alt_html;
2129 const std::string* error_html;
2130
2131 if (!html.empty()) {
2132 error_html = &html;
2133 } else {
2134 GetContentClient()->renderer()->GetNavigationErrorStrings(
2135 frame, failed_request, error, renderer_preferences_.accept_languages,
2136 &alt_html, NULL);
2137 error_html = &alt_html;
2138 }
2139
2140 frame->loadHTMLString(*error_html,
2141 GURL(kUnreachableWebDataURL),
2142 error.unreachableURL,
2143 replace);
2144 }
2145
RunJavaScriptMessage(JavaScriptMessageType type,const base::string16 & message,const base::string16 & default_value,const GURL & frame_url,base::string16 * result)2146 bool RenderViewImpl::RunJavaScriptMessage(JavaScriptMessageType type,
2147 const base::string16& message,
2148 const base::string16& default_value,
2149 const GURL& frame_url,
2150 base::string16* result) {
2151 // Don't allow further dialogs if we are waiting to swap out, since the
2152 // PageGroupLoadDeferrer in our stack prevents it.
2153 if (suppress_dialogs_until_swap_out_)
2154 return false;
2155
2156 bool success = false;
2157 base::string16 result_temp;
2158 if (!result)
2159 result = &result_temp;
2160
2161 SendAndRunNestedMessageLoop(new ViewHostMsg_RunJavaScriptMessage(
2162 routing_id_, message, default_value, frame_url, type, &success, result));
2163 return success;
2164 }
2165
SendAndRunNestedMessageLoop(IPC::SyncMessage * message)2166 bool RenderViewImpl::SendAndRunNestedMessageLoop(IPC::SyncMessage* message) {
2167 // Before WebKit asks us to show an alert (etc.), it takes care of doing the
2168 // equivalent of WebView::willEnterModalLoop. In the case of showModalDialog
2169 // it is particularly important that we do not call willEnterModalLoop as
2170 // that would defer resource loads for the dialog itself.
2171 if (RenderThreadImpl::current()) // Will be NULL during unit tests.
2172 RenderThreadImpl::current()->DoNotNotifyWebKitOfModalLoop();
2173
2174 message->EnableMessagePumping(); // Runs a nested message loop.
2175 return Send(message);
2176 }
2177
GetWindowSnapshot(const WindowSnapshotCallback & callback)2178 void RenderViewImpl::GetWindowSnapshot(const WindowSnapshotCallback& callback) {
2179 int id = next_snapshot_id_++;
2180 pending_snapshots_.insert(std::make_pair(id, callback));
2181 ui::LatencyInfo latency_info;
2182 latency_info.AddLatencyNumber(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
2183 GetLatencyComponentId(),
2184 id);
2185 scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
2186 if (RenderWidgetCompositor* rwc = compositor()) {
2187 latency_info_swap_promise_monitor =
2188 rwc->CreateLatencyInfoSwapPromiseMonitor(&latency_info).Pass();
2189 } else {
2190 latency_info_.MergeWith(latency_info);
2191 }
2192 ScheduleCompositeWithForcedRedraw();
2193 }
2194
OnWindowSnapshotCompleted(const int snapshot_id,const gfx::Size & size,const std::vector<unsigned char> & png)2195 void RenderViewImpl::OnWindowSnapshotCompleted(const int snapshot_id,
2196 const gfx::Size& size, const std::vector<unsigned char>& png) {
2197
2198 // Any pending snapshots with a lower ID than the one received are considered
2199 // to be implicitly complete, and returned the same snapshot data.
2200 PendingSnapshotMap::iterator it = pending_snapshots_.begin();
2201 while(it != pending_snapshots_.end()) {
2202 if (it->first <= snapshot_id) {
2203 it->second.Run(size, png);
2204 pending_snapshots_.erase(it++);
2205 } else {
2206 ++it;
2207 }
2208 }
2209 }
2210
2211 // blink::WebViewClient ------------------------------------------------------
2212
createView(WebFrame * creator,const WebURLRequest & request,const WebWindowFeatures & features,const WebString & frame_name,WebNavigationPolicy policy,bool suppress_opener)2213 WebView* RenderViewImpl::createView(
2214 WebFrame* creator,
2215 const WebURLRequest& request,
2216 const WebWindowFeatures& features,
2217 const WebString& frame_name,
2218 WebNavigationPolicy policy,
2219 bool suppress_opener) {
2220 ViewHostMsg_CreateWindow_Params params;
2221 params.opener_id = routing_id_;
2222 params.user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
2223 if (GetContentClient()->renderer()->AllowPopup())
2224 params.user_gesture = true;
2225 params.window_container_type = WindowFeaturesToContainerType(features);
2226 params.session_storage_namespace_id = session_storage_namespace_id_;
2227 if (frame_name != "_blank")
2228 params.frame_name = frame_name;
2229 params.opener_frame_id = creator->identifier();
2230 params.opener_url = creator->document().url();
2231 params.opener_top_level_frame_url = creator->top()->document().url();
2232 GURL security_url(creator->document().securityOrigin().toString().utf8());
2233 if (!security_url.is_valid())
2234 security_url = GURL();
2235 params.opener_security_origin = security_url;
2236 params.opener_suppressed = suppress_opener;
2237 params.disposition = NavigationPolicyToDisposition(policy);
2238 if (!request.isNull()) {
2239 params.target_url = request.url();
2240 params.referrer = GetReferrerFromRequest(creator, request);
2241 }
2242 params.features = features;
2243
2244 for (size_t i = 0; i < features.additionalFeatures.size(); ++i)
2245 params.additional_features.push_back(features.additionalFeatures[i]);
2246
2247 int32 routing_id = MSG_ROUTING_NONE;
2248 int32 main_frame_routing_id = MSG_ROUTING_NONE;
2249 int32 surface_id = 0;
2250 int64 cloned_session_storage_namespace_id;
2251
2252 RenderThread::Get()->Send(
2253 new ViewHostMsg_CreateWindow(params,
2254 &routing_id,
2255 &main_frame_routing_id,
2256 &surface_id,
2257 &cloned_session_storage_namespace_id));
2258 if (routing_id == MSG_ROUTING_NONE)
2259 return NULL;
2260
2261 WebUserGestureIndicator::consumeUserGesture();
2262
2263 WebPreferences transferred_preferences = webkit_preferences_;
2264
2265 // Unless accelerated compositing has been explicitly disabled from the
2266 // command line (e.g. via the blacklist or about:flags) re-enable it for
2267 // new views that get spawned by this view. This gets around the issue that
2268 // background extension pages disable accelerated compositing via web prefs
2269 // but can themselves spawn a visible render view which should be allowed
2270 // use gpu acceleration.
2271 if (!webkit_preferences_.accelerated_compositing_enabled) {
2272 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
2273 if (!command_line.HasSwitch(switches::kDisableAcceleratedCompositing))
2274 transferred_preferences.accelerated_compositing_enabled = true;
2275 }
2276
2277 // The initial hidden state for the RenderViewImpl here has to match what the
2278 // browser will eventually decide for the given disposition. Since we have to
2279 // return from this call synchronously, we just have to make our best guess
2280 // and rely on the browser sending a WasHidden / WasShown message if it
2281 // disagrees.
2282 RenderViewImpl* view = RenderViewImpl::Create(
2283 routing_id_,
2284 renderer_preferences_,
2285 transferred_preferences,
2286 routing_id,
2287 main_frame_routing_id,
2288 surface_id,
2289 cloned_session_storage_namespace_id,
2290 base::string16(), // WebCore will take care of setting the correct name.
2291 true, // is_renderer_created
2292 false, // swapped_out
2293 params.disposition == NEW_BACKGROUND_TAB, // hidden
2294 1, // next_page_id
2295 screen_info_,
2296 accessibility_mode_,
2297 allow_partial_swap_);
2298 view->opened_by_user_gesture_ = params.user_gesture;
2299
2300 // Record whether the creator frame is trying to suppress the opener field.
2301 view->opener_suppressed_ = params.opener_suppressed;
2302
2303 // Copy over the alternate error page URL so we can have alt error pages in
2304 // the new render view (we don't need the browser to send the URL back down).
2305 view->alternate_error_page_url_ = alternate_error_page_url_;
2306
2307 return view->webview();
2308 }
2309
createPopupMenu(blink::WebPopupType popup_type)2310 WebWidget* RenderViewImpl::createPopupMenu(blink::WebPopupType popup_type) {
2311 RenderWidget* widget =
2312 RenderWidget::Create(routing_id_, popup_type, screen_info_);
2313 if (screen_metrics_emulator_) {
2314 widget->SetPopupOriginAdjustmentsForEmulation(
2315 screen_metrics_emulator_.get());
2316 }
2317 return widget->webwidget();
2318 }
2319
createExternalPopupMenu(const WebPopupMenuInfo & popup_menu_info,WebExternalPopupMenuClient * popup_menu_client)2320 WebExternalPopupMenu* RenderViewImpl::createExternalPopupMenu(
2321 const WebPopupMenuInfo& popup_menu_info,
2322 WebExternalPopupMenuClient* popup_menu_client) {
2323 // An IPC message is sent to the browser to build and display the actual
2324 // popup. The user could have time to click a different select by the time
2325 // the popup is shown. In that case external_popup_menu_ is non NULL.
2326 // By returning NULL in that case, we instruct WebKit to cancel that new
2327 // popup. So from the user perspective, only the first one will show, and
2328 // will have to close the first one before another one can be shown.
2329 if (external_popup_menu_)
2330 return NULL;
2331 external_popup_menu_.reset(
2332 new ExternalPopupMenu(this, popup_menu_info, popup_menu_client));
2333 if (screen_metrics_emulator_) {
2334 SetExternalPopupOriginAdjustmentsForEmulation(
2335 external_popup_menu_.get(), screen_metrics_emulator_.get());
2336 }
2337 return external_popup_menu_.get();
2338 }
2339
createSessionStorageNamespace()2340 WebStorageNamespace* RenderViewImpl::createSessionStorageNamespace() {
2341 CHECK(session_storage_namespace_id_ != kInvalidSessionStorageNamespaceId);
2342 return new WebStorageNamespaceImpl(session_storage_namespace_id_);
2343 }
2344
shouldReportDetailedMessageForSource(const WebString & source)2345 bool RenderViewImpl::shouldReportDetailedMessageForSource(
2346 const WebString& source) {
2347 return GetContentClient()->renderer()->ShouldReportDetailedMessageForSource(
2348 source);
2349 }
2350
didAddMessageToConsole(const WebConsoleMessage & message,const WebString & source_name,unsigned source_line,const WebString & stack_trace)2351 void RenderViewImpl::didAddMessageToConsole(
2352 const WebConsoleMessage& message, const WebString& source_name,
2353 unsigned source_line, const WebString& stack_trace) {
2354 logging::LogSeverity log_severity = logging::LOG_VERBOSE;
2355 switch (message.level) {
2356 case WebConsoleMessage::LevelDebug:
2357 log_severity = logging::LOG_VERBOSE;
2358 break;
2359 case WebConsoleMessage::LevelLog:
2360 case WebConsoleMessage::LevelInfo:
2361 log_severity = logging::LOG_INFO;
2362 break;
2363 case WebConsoleMessage::LevelWarning:
2364 log_severity = logging::LOG_WARNING;
2365 break;
2366 case WebConsoleMessage::LevelError:
2367 log_severity = logging::LOG_ERROR;
2368 break;
2369 default:
2370 NOTREACHED();
2371 }
2372
2373 if (shouldReportDetailedMessageForSource(source_name)) {
2374 FOR_EACH_OBSERVER(
2375 RenderViewObserver,
2376 observers_,
2377 DetailedConsoleMessageAdded(message.text,
2378 source_name,
2379 stack_trace,
2380 source_line,
2381 static_cast<int32>(log_severity)));
2382 }
2383
2384 Send(new ViewHostMsg_AddMessageToConsole(routing_id_,
2385 static_cast<int32>(log_severity),
2386 message.text,
2387 static_cast<int32>(source_line),
2388 source_name));
2389 }
2390
printPage(WebFrame * frame)2391 void RenderViewImpl::printPage(WebFrame* frame) {
2392 FOR_EACH_OBSERVER(RenderViewObserver, observers_,
2393 PrintPage(frame, handling_input_event_));
2394 }
2395
notificationPresenter()2396 blink::WebNotificationPresenter* RenderViewImpl::notificationPresenter() {
2397 return notification_provider_;
2398 }
2399
enumerateChosenDirectory(const WebString & path,WebFileChooserCompletion * chooser_completion)2400 bool RenderViewImpl::enumerateChosenDirectory(
2401 const WebString& path,
2402 WebFileChooserCompletion* chooser_completion) {
2403 int id = enumeration_completion_id_++;
2404 enumeration_completions_[id] = chooser_completion;
2405 return Send(new ViewHostMsg_EnumerateDirectory(
2406 routing_id_,
2407 id,
2408 base::FilePath::FromUTF16Unsafe(path)));
2409 }
2410
initializeHelperPluginWebFrame(blink::WebHelperPlugin * plugin)2411 void RenderViewImpl::initializeHelperPluginWebFrame(
2412 blink::WebHelperPlugin* plugin) {
2413 plugin->initializeFrame(main_render_frame_.get());
2414 }
2415
didStartLoading()2416 void RenderViewImpl::didStartLoading() {
2417 if (is_loading_) {
2418 DVLOG(1) << "didStartLoading called while loading";
2419 return;
2420 }
2421
2422 is_loading_ = true;
2423
2424 Send(new ViewHostMsg_DidStartLoading(routing_id_));
2425
2426 FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidStartLoading());
2427 }
2428
didStopLoading()2429 void RenderViewImpl::didStopLoading() {
2430 if (!is_loading_) {
2431 DVLOG(1) << "DidStopLoading called while not loading";
2432 return;
2433 }
2434
2435 is_loading_ = false;
2436
2437 // NOTE: For now we're doing the safest thing, and sending out notification
2438 // when done loading. This currently isn't an issue as the favicon is only
2439 // displayed when done loading. Ideally we would send notification when
2440 // finished parsing the head, but webkit doesn't support that yet.
2441 // The feed discovery code would also benefit from access to the head.
2442 Send(new ViewHostMsg_DidStopLoading(routing_id_));
2443
2444 if (load_progress_tracker_ != NULL)
2445 load_progress_tracker_->DidStopLoading();
2446
2447 DidStopLoadingIcons();
2448
2449 FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidStopLoading());
2450 }
2451
didChangeLoadProgress(WebFrame * frame,double load_progress)2452 void RenderViewImpl::didChangeLoadProgress(WebFrame* frame,
2453 double load_progress) {
2454 if (load_progress_tracker_ != NULL)
2455 load_progress_tracker_->DidChangeLoadProgress(frame, load_progress);
2456 }
2457
didCancelCompositionOnSelectionChange()2458 void RenderViewImpl::didCancelCompositionOnSelectionChange() {
2459 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
2460 }
2461
didChangeSelection(bool is_empty_selection)2462 void RenderViewImpl::didChangeSelection(bool is_empty_selection) {
2463 if (!handling_input_event_ && !handling_select_range_)
2464 return;
2465
2466 if (is_empty_selection)
2467 selection_text_.clear();
2468
2469 // UpdateTextInputType should be called before SyncSelectionIfRequired.
2470 // UpdateTextInputType may send TextInputTypeChanged to notify the focus
2471 // was changed, and SyncSelectionIfRequired may send SelectionChanged
2472 // to notify the selection was changed. Focus change should be notified
2473 // before selection change.
2474 UpdateTextInputType();
2475 SyncSelectionIfRequired();
2476 #if defined(OS_ANDROID)
2477 UpdateTextInputState(false, true);
2478 #endif
2479 }
2480
didExecuteCommand(const WebString & command_name)2481 void RenderViewImpl::didExecuteCommand(const WebString& command_name) {
2482 const std::string& name = UTF16ToUTF8(command_name);
2483 if (StartsWithASCII(name, "Move", true) ||
2484 StartsWithASCII(name, "Insert", true) ||
2485 StartsWithASCII(name, "Delete", true))
2486 return;
2487 RenderThreadImpl::current()->RecordComputedAction(name);
2488 }
2489
handleCurrentKeyboardEvent()2490 bool RenderViewImpl::handleCurrentKeyboardEvent() {
2491 if (edit_commands_.empty())
2492 return false;
2493
2494 WebFrame* frame = webview()->focusedFrame();
2495 if (!frame)
2496 return false;
2497
2498 EditCommands::iterator it = edit_commands_.begin();
2499 EditCommands::iterator end = edit_commands_.end();
2500
2501 bool did_execute_command = false;
2502 for (; it != end; ++it) {
2503 // In gtk and cocoa, it's possible to bind multiple edit commands to one
2504 // key (but it's the exception). Once one edit command is not executed, it
2505 // seems safest to not execute the rest.
2506 if (!frame->executeCommand(WebString::fromUTF8(it->name),
2507 WebString::fromUTF8(it->value),
2508 GetFocusedNode()))
2509 break;
2510 did_execute_command = true;
2511 }
2512
2513 return did_execute_command;
2514 }
2515
createColorChooser(blink::WebColorChooserClient * client,const blink::WebColor & initial_color,const blink::WebVector<blink::WebColorSuggestion> & suggestions)2516 blink::WebColorChooser* RenderViewImpl::createColorChooser(
2517 blink::WebColorChooserClient* client,
2518 const blink::WebColor& initial_color,
2519 const blink::WebVector<blink::WebColorSuggestion>& suggestions) {
2520 RendererWebColorChooserImpl* color_chooser =
2521 new RendererWebColorChooserImpl(this, client);
2522 std::vector<content::ColorSuggestion> color_suggestions;
2523 for (size_t i = 0; i < suggestions.size(); i++) {
2524 color_suggestions.push_back(content::ColorSuggestion(suggestions[i]));
2525 }
2526 color_chooser->Open(static_cast<SkColor>(initial_color), color_suggestions);
2527 return color_chooser;
2528 }
2529
runFileChooser(const blink::WebFileChooserParams & params,WebFileChooserCompletion * chooser_completion)2530 bool RenderViewImpl::runFileChooser(
2531 const blink::WebFileChooserParams& params,
2532 WebFileChooserCompletion* chooser_completion) {
2533 // Do not open the file dialog in a hidden RenderView.
2534 if (is_hidden())
2535 return false;
2536 FileChooserParams ipc_params;
2537 if (params.directory)
2538 ipc_params.mode = FileChooserParams::UploadFolder;
2539 else if (params.multiSelect)
2540 ipc_params.mode = FileChooserParams::OpenMultiple;
2541 else if (params.saveAs)
2542 ipc_params.mode = FileChooserParams::Save;
2543 else
2544 ipc_params.mode = FileChooserParams::Open;
2545 ipc_params.title = params.title;
2546 ipc_params.default_file_name =
2547 base::FilePath::FromUTF16Unsafe(params.initialValue);
2548 ipc_params.accept_types.reserve(params.acceptTypes.size());
2549 for (size_t i = 0; i < params.acceptTypes.size(); ++i)
2550 ipc_params.accept_types.push_back(params.acceptTypes[i]);
2551 #if defined(OS_ANDROID)
2552 ipc_params.capture = params.useMediaCapture;
2553 #endif
2554
2555 return ScheduleFileChooser(ipc_params, chooser_completion);
2556 }
2557
runModalAlertDialog(WebFrame * frame,const WebString & message)2558 void RenderViewImpl::runModalAlertDialog(WebFrame* frame,
2559 const WebString& message) {
2560 RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_ALERT,
2561 message,
2562 base::string16(),
2563 frame->document().url(),
2564 NULL);
2565 }
2566
runModalConfirmDialog(WebFrame * frame,const WebString & message)2567 bool RenderViewImpl::runModalConfirmDialog(WebFrame* frame,
2568 const WebString& message) {
2569 return RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_CONFIRM,
2570 message,
2571 base::string16(),
2572 frame->document().url(),
2573 NULL);
2574 }
2575
runModalPromptDialog(WebFrame * frame,const WebString & message,const WebString & default_value,WebString * actual_value)2576 bool RenderViewImpl::runModalPromptDialog(WebFrame* frame,
2577 const WebString& message,
2578 const WebString& default_value,
2579 WebString* actual_value) {
2580 base::string16 result;
2581 bool ok = RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_PROMPT,
2582 message,
2583 default_value,
2584 frame->document().url(),
2585 &result);
2586 if (ok)
2587 actual_value->assign(result);
2588 return ok;
2589 }
2590
runModalBeforeUnloadDialog(WebFrame * frame,const WebString & message)2591 bool RenderViewImpl::runModalBeforeUnloadDialog(
2592 WebFrame* frame, const WebString& message) {
2593 bool is_reload = false;
2594 WebDataSource* ds = frame->provisionalDataSource();
2595 if (ds)
2596 is_reload = (ds->navigationType() == blink::WebNavigationTypeReload);
2597 return runModalBeforeUnloadDialog(frame, is_reload, message);
2598 }
2599
runModalBeforeUnloadDialog(WebFrame * frame,bool is_reload,const WebString & message)2600 bool RenderViewImpl::runModalBeforeUnloadDialog(
2601 WebFrame* frame, bool is_reload, const WebString& message) {
2602 // If we are swapping out, we have already run the beforeunload handler.
2603 // TODO(creis): Fix OnSwapOut to clear the frame without running beforeunload
2604 // at all, to avoid running it twice.
2605 if (is_swapped_out_)
2606 return true;
2607
2608 // Don't allow further dialogs if we are waiting to swap out, since the
2609 // PageGroupLoadDeferrer in our stack prevents it.
2610 if (suppress_dialogs_until_swap_out_)
2611 return false;
2612
2613 bool success = false;
2614 // This is an ignored return value, but is included so we can accept the same
2615 // response as RunJavaScriptMessage.
2616 base::string16 ignored_result;
2617 SendAndRunNestedMessageLoop(new ViewHostMsg_RunBeforeUnloadConfirm(
2618 routing_id_, frame->document().url(), message, is_reload,
2619 &success, &ignored_result));
2620 return success;
2621 }
2622
showValidationMessage(const blink::WebRect & anchor_in_root_view,const blink::WebString & main_text,const blink::WebString & sub_text,blink::WebTextDirection hint)2623 void RenderViewImpl::showValidationMessage(
2624 const blink::WebRect& anchor_in_root_view,
2625 const blink::WebString& main_text,
2626 const blink::WebString& sub_text,
2627 blink::WebTextDirection hint) {
2628 base::string16 wrapped_main_text = main_text;
2629 base::string16 wrapped_sub_text = sub_text;
2630 if (hint == blink::WebTextDirectionLeftToRight) {
2631 wrapped_main_text =
2632 base::i18n::GetDisplayStringInLTRDirectionality(wrapped_main_text);
2633 if (!wrapped_sub_text.empty()) {
2634 wrapped_sub_text =
2635 base::i18n::GetDisplayStringInLTRDirectionality(wrapped_sub_text);
2636 }
2637 } else if (hint == blink::WebTextDirectionRightToLeft
2638 && !base::i18n::IsRTL()) {
2639 base::i18n::WrapStringWithRTLFormatting(&wrapped_main_text);
2640 if (!wrapped_sub_text.empty()) {
2641 base::i18n::WrapStringWithRTLFormatting(&wrapped_sub_text);
2642 }
2643 }
2644 Send(new ViewHostMsg_ShowValidationMessage(
2645 routing_id(), anchor_in_root_view, wrapped_main_text, wrapped_sub_text));
2646 }
2647
hideValidationMessage()2648 void RenderViewImpl::hideValidationMessage() {
2649 Send(new ViewHostMsg_HideValidationMessage(routing_id()));
2650 }
2651
moveValidationMessage(const blink::WebRect & anchor_in_root_view)2652 void RenderViewImpl::moveValidationMessage(
2653 const blink::WebRect& anchor_in_root_view) {
2654 Send(new ViewHostMsg_MoveValidationMessage(routing_id(),
2655 anchor_in_root_view));
2656 }
2657
showContextMenu(WebFrame * frame,const WebContextMenuData & data)2658 void RenderViewImpl::showContextMenu(
2659 WebFrame* frame, const WebContextMenuData& data) {
2660 ContextMenuParams params = ContextMenuParamsBuilder::Build(data);
2661 params.source_type = context_menu_source_type_;
2662 if (context_menu_source_type_ == ui::MENU_SOURCE_TOUCH_EDIT_MENU) {
2663 params.x = touch_editing_context_menu_location_.x();
2664 params.y = touch_editing_context_menu_location_.y();
2665 }
2666 OnShowHostContextMenu(¶ms);
2667
2668 // Plugins, e.g. PDF, don't currently update the render view when their
2669 // selected text changes, but the context menu params do contain the updated
2670 // selection. If that's the case, update the render view's state just prior
2671 // to showing the context menu.
2672 // TODO(asvitkine): http://crbug.com/152432
2673 if (ShouldUpdateSelectionTextFromContextMenuParams(selection_text_,
2674 selection_text_offset_,
2675 selection_range_,
2676 params)) {
2677 selection_text_ = params.selection_text;
2678 // TODO(asvitkine): Text offset and range is not available in this case.
2679 selection_text_offset_ = 0;
2680 selection_range_ = gfx::Range(0, selection_text_.length());
2681 Send(new ViewHostMsg_SelectionChanged(routing_id_,
2682 selection_text_,
2683 selection_text_offset_,
2684 selection_range_));
2685 }
2686
2687 // frame is NULL if invoked by BlockedPlugin.
2688 if (frame)
2689 params.frame_id = frame->identifier();
2690
2691 // Serializing a GURL longer than kMaxURLChars will fail, so don't do
2692 // it. We replace it with an empty GURL so the appropriate items are disabled
2693 // in the context menu.
2694 // TODO(jcivelli): http://crbug.com/45160 This prevents us from saving large
2695 // data encoded images. We should have a way to save them.
2696 if (params.src_url.spec().size() > GetMaxURLChars())
2697 params.src_url = GURL();
2698 context_menu_node_ = data.node;
2699
2700 #if defined(OS_ANDROID)
2701 gfx::Rect start_rect;
2702 gfx::Rect end_rect;
2703 GetSelectionBounds(&start_rect, &end_rect);
2704 params.selection_start = gfx::Point(start_rect.x(), start_rect.bottom());
2705 params.selection_end = gfx::Point(end_rect.right(), end_rect.bottom());
2706 #endif
2707
2708 Send(new ViewHostMsg_ContextMenu(routing_id_, params));
2709
2710 FOR_EACH_OBSERVER(
2711 RenderViewObserver, observers_, DidRequestShowContextMenu(frame, data));
2712 }
2713
clearContextMenu()2714 void RenderViewImpl::clearContextMenu() {
2715 context_menu_node_.reset();
2716 }
2717
setStatusText(const WebString & text)2718 void RenderViewImpl::setStatusText(const WebString& text) {
2719 }
2720
UpdateTargetURL(const GURL & url,const GURL & fallback_url)2721 void RenderViewImpl::UpdateTargetURL(const GURL& url,
2722 const GURL& fallback_url) {
2723 GURL latest_url = url.is_empty() ? fallback_url : url;
2724 if (latest_url == target_url_)
2725 return;
2726
2727 // Tell the browser to display a destination link.
2728 if (target_url_status_ == TARGET_INFLIGHT ||
2729 target_url_status_ == TARGET_PENDING) {
2730 // If we have a request in-flight, save the URL to be sent when we
2731 // receive an ACK to the in-flight request. We can happily overwrite
2732 // any existing pending sends.
2733 pending_target_url_ = latest_url;
2734 target_url_status_ = TARGET_PENDING;
2735 } else {
2736 // URLs larger than |MaxURLChars()| cannot be sent through IPC -
2737 // see |ParamTraits<GURL>|.
2738 if (latest_url.possibly_invalid_spec().size() > GetMaxURLChars())
2739 latest_url = GURL();
2740 Send(new ViewHostMsg_UpdateTargetURL(routing_id_, page_id_, latest_url));
2741 target_url_ = latest_url;
2742 target_url_status_ = TARGET_INFLIGHT;
2743 }
2744 }
2745
ClientRectToPhysicalWindowRect(const gfx::RectF & rect) const2746 gfx::RectF RenderViewImpl::ClientRectToPhysicalWindowRect(
2747 const gfx::RectF& rect) const {
2748 gfx::RectF window_rect = rect;
2749 window_rect.Scale(device_scale_factor_ * webview()->pageScaleFactor());
2750 return window_rect;
2751 }
2752
GetLatencyComponentId()2753 int64 RenderViewImpl::GetLatencyComponentId() {
2754 // Note: this must match the logic in RenderWidgetHostImpl.
2755 return GetRoutingID() | (static_cast<int64>(
2756 RenderThreadImpl::current()->renderer_process_id()) << 32);
2757 }
2758
StartNavStateSyncTimerIfNecessary()2759 void RenderViewImpl::StartNavStateSyncTimerIfNecessary() {
2760 // No need to update state if no page has committed yet.
2761 if (page_id_ == -1)
2762 return;
2763
2764 int delay;
2765 if (send_content_state_immediately_)
2766 delay = 0;
2767 else if (is_hidden())
2768 delay = kDelaySecondsForContentStateSyncHidden;
2769 else
2770 delay = kDelaySecondsForContentStateSync;
2771
2772 if (nav_state_sync_timer_.IsRunning()) {
2773 // The timer is already running. If the delay of the timer maches the amount
2774 // we want to delay by, then return. Otherwise stop the timer so that it
2775 // gets started with the right delay.
2776 if (nav_state_sync_timer_.GetCurrentDelay().InSeconds() == delay)
2777 return;
2778 nav_state_sync_timer_.Stop();
2779 }
2780
2781 nav_state_sync_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(delay), this,
2782 &RenderViewImpl::SyncNavigationState);
2783 }
2784
setMouseOverURL(const WebURL & url)2785 void RenderViewImpl::setMouseOverURL(const WebURL& url) {
2786 mouse_over_url_ = GURL(url);
2787 UpdateTargetURL(mouse_over_url_, focus_url_);
2788 }
2789
setKeyboardFocusURL(const WebURL & url)2790 void RenderViewImpl::setKeyboardFocusURL(const WebURL& url) {
2791 focus_url_ = GURL(url);
2792 UpdateTargetURL(focus_url_, mouse_over_url_);
2793 }
2794
startDragging(WebFrame * frame,const WebDragData & data,WebDragOperationsMask mask,const WebImage & image,const WebPoint & webImageOffset)2795 void RenderViewImpl::startDragging(WebFrame* frame,
2796 const WebDragData& data,
2797 WebDragOperationsMask mask,
2798 const WebImage& image,
2799 const WebPoint& webImageOffset) {
2800 DropData drop_data(DropDataBuilder::Build(data));
2801 drop_data.referrer_policy = frame->document().referrerPolicy();
2802 gfx::Vector2d imageOffset(webImageOffset.x, webImageOffset.y);
2803 Send(new DragHostMsg_StartDragging(routing_id_,
2804 drop_data,
2805 mask,
2806 image.getSkBitmap(),
2807 imageOffset,
2808 possible_drag_event_info_));
2809 }
2810
acceptsLoadDrops()2811 bool RenderViewImpl::acceptsLoadDrops() {
2812 return renderer_preferences_.can_accept_load_drops;
2813 }
2814
focusNext()2815 void RenderViewImpl::focusNext() {
2816 Send(new ViewHostMsg_TakeFocus(routing_id_, false));
2817 }
2818
focusPrevious()2819 void RenderViewImpl::focusPrevious() {
2820 Send(new ViewHostMsg_TakeFocus(routing_id_, true));
2821 }
2822
focusedNodeChanged(const WebNode & node)2823 void RenderViewImpl::focusedNodeChanged(const WebNode& node) {
2824 Send(new ViewHostMsg_FocusedNodeChanged(routing_id_, IsEditableNode(node)));
2825
2826 FOR_EACH_OBSERVER(RenderViewObserver, observers_, FocusedNodeChanged(node));
2827 }
2828
numberOfWheelEventHandlersChanged(unsigned num_handlers)2829 void RenderViewImpl::numberOfWheelEventHandlersChanged(unsigned num_handlers) {
2830 Send(new ViewHostMsg_DidChangeNumWheelEvents(routing_id_, num_handlers));
2831 }
2832
didUpdateLayout()2833 void RenderViewImpl::didUpdateLayout() {
2834 FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidUpdateLayout());
2835
2836 // We don't always want to set up a timer, only if we've been put in that
2837 // mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
2838 // message.
2839 if (!send_preferred_size_changes_ || !webview())
2840 return;
2841
2842 if (check_preferred_size_timer_.IsRunning())
2843 return;
2844 check_preferred_size_timer_.Start(FROM_HERE,
2845 TimeDelta::FromMilliseconds(0), this,
2846 &RenderViewImpl::CheckPreferredSize);
2847 }
2848
navigateBackForwardSoon(int offset)2849 void RenderViewImpl::navigateBackForwardSoon(int offset) {
2850 Send(new ViewHostMsg_GoToEntryAtOffset(routing_id_, offset));
2851 }
2852
historyBackListCount()2853 int RenderViewImpl::historyBackListCount() {
2854 return history_list_offset_ < 0 ? 0 : history_list_offset_;
2855 }
2856
historyForwardListCount()2857 int RenderViewImpl::historyForwardListCount() {
2858 return history_list_length_ - historyBackListCount() - 1;
2859 }
2860
postAccessibilityEvent(const WebAXObject & obj,blink::WebAXEvent event)2861 void RenderViewImpl::postAccessibilityEvent(
2862 const WebAXObject& obj, blink::WebAXEvent event) {
2863 if (renderer_accessibility_) {
2864 renderer_accessibility_->HandleWebAccessibilityEvent(obj, event);
2865 }
2866 }
2867
didUpdateInspectorSetting(const WebString & key,const WebString & value)2868 void RenderViewImpl::didUpdateInspectorSetting(const WebString& key,
2869 const WebString& value) {
2870 Send(new ViewHostMsg_UpdateInspectorSetting(routing_id_,
2871 key.utf8(),
2872 value.utf8()));
2873 }
2874
2875 // blink::WebWidgetClient ----------------------------------------------------
2876
didFocus()2877 void RenderViewImpl::didFocus() {
2878 // TODO(jcivelli): when https://bugs.webkit.org/show_bug.cgi?id=33389 is fixed
2879 // we won't have to test for user gesture anymore and we can
2880 // move that code back to render_widget.cc
2881 if (WebUserGestureIndicator::isProcessingUserGesture() &&
2882 !RenderThreadImpl::current()->layout_test_mode()) {
2883 Send(new ViewHostMsg_Focus(routing_id_));
2884 }
2885 }
2886
didBlur()2887 void RenderViewImpl::didBlur() {
2888 // TODO(jcivelli): see TODO above in didFocus().
2889 if (WebUserGestureIndicator::isProcessingUserGesture() &&
2890 !RenderThreadImpl::current()->layout_test_mode()) {
2891 Send(new ViewHostMsg_Blur(routing_id_));
2892 }
2893 }
2894
2895 // We are supposed to get a single call to Show for a newly created RenderView
2896 // that was created via RenderViewImpl::CreateWebView. So, we wait until this
2897 // point to dispatch the ShowView message.
2898 //
2899 // This method provides us with the information about how to display the newly
2900 // created RenderView (i.e., as a blocked popup or as a new tab).
2901 //
show(WebNavigationPolicy policy)2902 void RenderViewImpl::show(WebNavigationPolicy policy) {
2903 if (did_show_) {
2904 // When supports_multiple_windows is disabled, popups are reusing
2905 // the same view. In some scenarios, this makes WebKit to call show() twice.
2906 if (webkit_preferences_.supports_multiple_windows)
2907 NOTREACHED() << "received extraneous Show call";
2908 return;
2909 }
2910 did_show_ = true;
2911
2912 DCHECK(opener_id_ != MSG_ROUTING_NONE);
2913
2914 // Force new windows to a popup if they were not opened with a user gesture.
2915 if (!opened_by_user_gesture_) {
2916 // We exempt background tabs for compat with older versions of Chrome.
2917 // TODO(darin): This seems bogus. These should have a user gesture, so
2918 // we probably don't need this check.
2919 if (policy != blink::WebNavigationPolicyNewBackgroundTab)
2920 policy = blink::WebNavigationPolicyNewPopup;
2921 }
2922
2923 // NOTE: initial_pos_ may still have its default values at this point, but
2924 // that's okay. It'll be ignored if disposition is not NEW_POPUP, or the
2925 // browser process will impose a default position otherwise.
2926 Send(new ViewHostMsg_ShowView(opener_id_, routing_id_,
2927 NavigationPolicyToDisposition(policy), initial_pos_,
2928 opened_by_user_gesture_));
2929 SetPendingWindowRect(initial_pos_);
2930 }
2931
runModal()2932 void RenderViewImpl::runModal() {
2933 DCHECK(did_show_) << "should already have shown the view";
2934
2935 // Don't allow further dialogs if we are waiting to swap out, since the
2936 // PageGroupLoadDeferrer in our stack prevents it.
2937 if (suppress_dialogs_until_swap_out_)
2938 return;
2939
2940 // We must keep WebKit's shared timer running in this case in order to allow
2941 // showModalDialog to function properly.
2942 //
2943 // TODO(darin): WebKit should really be smarter about suppressing events and
2944 // timers so that we do not need to manage the shared timer in such a heavy
2945 // handed manner.
2946 //
2947 if (RenderThreadImpl::current()) // Will be NULL during unit tests.
2948 RenderThreadImpl::current()->DoNotSuspendWebKitSharedTimer();
2949
2950 SendAndRunNestedMessageLoop(new ViewHostMsg_RunModal(
2951 routing_id_, opener_id_));
2952 }
2953
enterFullScreen()2954 bool RenderViewImpl::enterFullScreen() {
2955 Send(new ViewHostMsg_ToggleFullscreen(routing_id_, true));
2956 return true;
2957 }
2958
exitFullScreen()2959 void RenderViewImpl::exitFullScreen() {
2960 Send(new ViewHostMsg_ToggleFullscreen(routing_id_, false));
2961 }
2962
requestPointerLock()2963 bool RenderViewImpl::requestPointerLock() {
2964 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
2965 }
2966
requestPointerUnlock()2967 void RenderViewImpl::requestPointerUnlock() {
2968 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
2969 }
2970
isPointerLocked()2971 bool RenderViewImpl::isPointerLocked() {
2972 return mouse_lock_dispatcher_->IsMouseLockedTo(
2973 webwidget_mouse_lock_target_.get());
2974 }
2975
didActivateCompositor(int input_handler_identifier)2976 void RenderViewImpl::didActivateCompositor(int input_handler_identifier) {
2977 #if !defined(OS_MACOSX) // many events are unhandled - http://crbug.com/138003
2978 InputHandlerManager* input_handler_manager =
2979 RenderThreadImpl::current()->input_handler_manager();
2980 if (input_handler_manager) {
2981 input_handler_manager->AddInputHandler(
2982 routing_id_,
2983 compositor_->GetInputHandler(),
2984 AsWeakPtr());
2985 }
2986 #endif
2987
2988 RenderWidget::didActivateCompositor(input_handler_identifier);
2989 }
2990
didHandleGestureEvent(const WebGestureEvent & event,bool event_cancelled)2991 void RenderViewImpl::didHandleGestureEvent(
2992 const WebGestureEvent& event,
2993 bool event_cancelled) {
2994 RenderWidget::didHandleGestureEvent(event, event_cancelled);
2995
2996 if (event.type != blink::WebGestureEvent::GestureTap)
2997 return;
2998
2999 blink::WebTextInputType text_input_type =
3000 GetWebView()->textInputInfo().type;
3001
3002 Send(new ViewHostMsg_FocusedNodeTouched(
3003 routing_id(), text_input_type != blink::WebTextInputTypeNone));
3004 }
3005
initializeLayerTreeView()3006 void RenderViewImpl::initializeLayerTreeView() {
3007 RenderWidget::initializeLayerTreeView();
3008 RenderWidgetCompositor* rwc = compositor();
3009 if (!rwc || !webview() || !webview()->devToolsAgent())
3010 return;
3011 webview()->devToolsAgent()->setLayerTreeId(rwc->GetLayerTreeId());
3012 }
3013
3014 // blink::WebFrameClient -----------------------------------------------------
3015
createMediaPlayer(WebFrame * frame,const blink::WebURL & url,WebMediaPlayerClient * client)3016 WebMediaPlayer* RenderViewImpl::createMediaPlayer(
3017 WebFrame* frame, const blink::WebURL& url, WebMediaPlayerClient* client) {
3018 NOTREACHED();
3019 return NULL;
3020 }
3021
CreateMediaPlayer(RenderFrame * render_frame,blink::WebFrame * frame,const blink::WebURL & url,blink::WebMediaPlayerClient * client)3022 blink::WebMediaPlayer* RenderViewImpl::CreateMediaPlayer(
3023 RenderFrame* render_frame,
3024 blink::WebFrame* frame,
3025 const blink::WebURL& url,
3026 blink::WebMediaPlayerClient* client) {
3027 FOR_EACH_OBSERVER(
3028 RenderViewObserver, observers_, WillCreateMediaPlayer(frame, client));
3029
3030 WebMediaPlayer* player = CreateWebMediaPlayerForMediaStream(frame, url,
3031 client);
3032 if (player)
3033 return player;
3034
3035 #if defined(OS_ANDROID)
3036 return CreateAndroidWebMediaPlayer(frame, url, client);
3037 #else
3038 scoped_refptr<media::AudioRendererSink> sink;
3039 if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableAudio)) {
3040 sink = RenderThreadImpl::current()->GetAudioRendererMixerManager()->
3041 CreateInput(routing_id_);
3042 DVLOG(1) << "Using AudioRendererMixerManager-provided sink: " << sink.get();
3043 }
3044
3045 WebMediaPlayerParams params(
3046 RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy(),
3047 base::Bind(&ContentRendererClient::DeferMediaLoad,
3048 base::Unretained(GetContentClient()->renderer()),
3049 static_cast<RenderFrame*>(render_frame)),
3050 sink,
3051 RenderThreadImpl::current()->GetGpuFactories(),
3052 new RenderMediaLog());
3053 return new WebMediaPlayerImpl(this, frame, client, AsWeakPtr(), params);
3054 #endif // defined(OS_ANDROID)
3055 }
3056
cookieJar(WebFrame * frame)3057 WebCookieJar* RenderViewImpl::cookieJar(WebFrame* frame) {
3058 return &cookie_jar_;
3059 }
3060
didAccessInitialDocument(WebFrame * frame)3061 void RenderViewImpl::didAccessInitialDocument(WebFrame* frame) {
3062 // Notify the browser process that it is no longer safe to show the pending
3063 // URL of the main frame, since a URL spoof is now possible.
3064 if (!frame->parent() && page_id_ == -1)
3065 Send(new ViewHostMsg_DidAccessInitialDocument(routing_id_));
3066 }
3067
didDisownOpener(blink::WebFrame * frame)3068 void RenderViewImpl::didDisownOpener(blink::WebFrame* frame) {
3069 // We only need to notify the browser if the active, top-level frame clears
3070 // its opener. We can ignore cases where a swapped out frame clears its
3071 // opener after hearing about it from the browser, and the browser does not
3072 // (yet) care about subframe openers.
3073 if (is_swapped_out_ || frame->parent())
3074 return;
3075
3076 // Notify WebContents and all its swapped out RenderViews.
3077 Send(new ViewHostMsg_DidDisownOpener(routing_id_));
3078 }
3079
frameDetached(WebFrame * frame)3080 void RenderViewImpl::frameDetached(WebFrame* frame) {
3081 FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameDetached(frame));
3082 }
3083
willClose(WebFrame * frame)3084 void RenderViewImpl::willClose(WebFrame* frame) {
3085 FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameWillClose(frame));
3086 }
3087
didMatchCSS(WebFrame * frame,const WebVector<WebString> & newly_matching_selectors,const WebVector<WebString> & stopped_matching_selectors)3088 void RenderViewImpl::didMatchCSS(
3089 WebFrame* frame,
3090 const WebVector<WebString>& newly_matching_selectors,
3091 const WebVector<WebString>& stopped_matching_selectors) {
3092 FOR_EACH_OBSERVER(
3093 RenderViewObserver, observers_,
3094 DidMatchCSS(frame, newly_matching_selectors, stopped_matching_selectors));
3095 }
3096
Repaint(const gfx::Size & size)3097 void RenderViewImpl::Repaint(const gfx::Size& size) {
3098 OnRepaint(size);
3099 }
3100
SetEditCommandForNextKeyEvent(const std::string & name,const std::string & value)3101 void RenderViewImpl::SetEditCommandForNextKeyEvent(const std::string& name,
3102 const std::string& value) {
3103 EditCommands edit_commands;
3104 edit_commands.push_back(EditCommand(name, value));
3105 OnSetEditCommandsForNextKeyEvent(edit_commands);
3106 }
3107
ClearEditCommands()3108 void RenderViewImpl::ClearEditCommands() {
3109 edit_commands_.clear();
3110 }
3111
GetSSLStatusOfFrame(blink::WebFrame * frame) const3112 SSLStatus RenderViewImpl::GetSSLStatusOfFrame(blink::WebFrame* frame) const {
3113 std::string security_info;
3114 if (frame && frame->dataSource())
3115 security_info = frame->dataSource()->response().securityInfo();
3116
3117 SSLStatus ssl_status;
3118 DeserializeSecurityInfo(security_info,
3119 &ssl_status.cert_id,
3120 &ssl_status.cert_status,
3121 &ssl_status.security_bits,
3122 &ssl_status.connection_status,
3123 &ssl_status.signed_certificate_timestamp_ids);
3124 return ssl_status;
3125 }
3126
GetAcceptLanguages() const3127 const std::string& RenderViewImpl::GetAcceptLanguages() const {
3128 return renderer_preferences_.accept_languages;
3129 }
3130
decidePolicyForNavigation(WebFrame * frame,WebDataSource::ExtraData * extraData,const WebURLRequest & request,WebNavigationType type,WebNavigationPolicy default_policy,bool is_redirect)3131 WebNavigationPolicy RenderViewImpl::decidePolicyForNavigation(
3132 WebFrame* frame, WebDataSource::ExtraData* extraData,
3133 const WebURLRequest& request, WebNavigationType type,
3134 WebNavigationPolicy default_policy, bool is_redirect) {
3135 #ifdef OS_ANDROID
3136 // The handlenavigation API is deprecated and will be removed once
3137 // crbug.com/325351 is resolved.
3138 if (request.url() != GURL(kSwappedOutURL) &&
3139 GetContentClient()->renderer()->HandleNavigation(
3140 this,
3141 static_cast<DocumentState*>(extraData),
3142 opener_id_,
3143 frame,
3144 request,
3145 type,
3146 default_policy,
3147 is_redirect)) {
3148 return blink::WebNavigationPolicyIgnore;
3149 }
3150 #endif
3151
3152 Referrer referrer(GetReferrerFromRequest(frame, request));
3153
3154 if (is_swapped_out_) {
3155 if (request.url() != GURL(kSwappedOutURL)) {
3156 // Targeted links may try to navigate a swapped out frame. Allow the
3157 // browser process to navigate the tab instead. Note that it is also
3158 // possible for non-targeted navigations (from this view) to arrive
3159 // here just after we are swapped out. It's ok to send them to the
3160 // browser, as long as they're for the top level frame.
3161 // TODO(creis): Ensure this supports targeted form submissions when
3162 // fixing http://crbug.com/101395.
3163 if (frame->parent() == NULL) {
3164 OpenURL(frame, request.url(), referrer, default_policy);
3165 return blink::WebNavigationPolicyIgnore; // Suppress the load here.
3166 }
3167
3168 // We should otherwise ignore in-process iframe navigations, if they
3169 // arrive just after we are swapped out.
3170 return blink::WebNavigationPolicyIgnore;
3171 }
3172
3173 // Allow kSwappedOutURL to complete.
3174 return default_policy;
3175 }
3176
3177 // Webkit is asking whether to navigate to a new URL.
3178 // This is fine normally, except if we're showing UI from one security
3179 // context and they're trying to navigate to a different context.
3180 const GURL& url = request.url();
3181
3182 // A content initiated navigation may have originated from a link-click,
3183 // script, drag-n-drop operation, etc.
3184 bool is_content_initiated = static_cast<DocumentState*>(extraData)->
3185 navigation_state()->is_content_initiated();
3186
3187 // Experimental:
3188 // If --enable-strict-site-isolation or --site-per-process is enabled, send
3189 // all top-level navigations to the browser to let it swap processes when
3190 // crossing site boundaries. This is currently expected to break some script
3191 // calls and navigations, such as form submissions.
3192 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
3193 bool force_swap_due_to_flag =
3194 command_line.HasSwitch(switches::kEnableStrictSiteIsolation) ||
3195 command_line.HasSwitch(switches::kSitePerProcess);
3196 if (force_swap_due_to_flag &&
3197 !frame->parent() && (is_content_initiated || is_redirect)) {
3198 WebString origin_str = frame->document().securityOrigin().toString();
3199 GURL frame_url(origin_str.utf8().data());
3200 // TODO(cevans): revisit whether this site check is still necessary once
3201 // crbug.com/101395 is fixed.
3202 bool same_domain_or_host =
3203 net::registry_controlled_domains::SameDomainOrHost(
3204 frame_url,
3205 url,
3206 net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
3207 if (!same_domain_or_host || frame_url.scheme() != url.scheme()) {
3208 OpenURL(frame, url, referrer, default_policy);
3209 return blink::WebNavigationPolicyIgnore;
3210 }
3211 }
3212
3213 // If the browser is interested, then give it a chance to look at the request.
3214 if (is_content_initiated) {
3215 bool is_form_post = ((type == blink::WebNavigationTypeFormSubmitted) ||
3216 (type == blink::WebNavigationTypeFormResubmitted)) &&
3217 EqualsASCII(request.httpMethod(), "POST");
3218 bool browser_handles_request =
3219 renderer_preferences_.browser_handles_non_local_top_level_requests &&
3220 IsNonLocalTopLevelNavigation(url, frame, type, is_form_post);
3221 if (!browser_handles_request) {
3222 browser_handles_request = IsTopLevelNavigation(frame) &&
3223 (renderer_preferences_.browser_handles_all_top_level_requests ||
3224 (renderer_preferences_.browser_handles_all_top_level_link_clicks &&
3225 type == blink::WebNavigationTypeLinkClicked));
3226 }
3227
3228 if (browser_handles_request) {
3229 // Reset these counters as the RenderView could be reused for the next
3230 // navigation.
3231 page_id_ = -1;
3232 last_page_id_sent_to_browser_ = -1;
3233 OpenURL(frame, url, referrer, default_policy);
3234 return blink::WebNavigationPolicyIgnore; // Suppress the load here.
3235 }
3236 }
3237
3238 // Use the frame's original request's URL rather than the document's URL for
3239 // subsequent checks. For a popup, the document's URL may become the opener
3240 // window's URL if the opener has called document.write().
3241 // See http://crbug.com/93517.
3242 GURL old_url(frame->dataSource()->request().url());
3243
3244 // Detect when we're crossing a permission-based boundary (e.g. into or out of
3245 // an extension or app origin, leaving a WebUI page, etc). We only care about
3246 // top-level navigations (not iframes). But we sometimes navigate to
3247 // about:blank to clear a tab, and we want to still allow that.
3248 //
3249 // Note: this is known to break POST submissions when crossing process
3250 // boundaries until http://crbug.com/101395 is fixed. This is better for
3251 // security than loading a WebUI, extension or app page in the wrong process.
3252 // POST requests don't work because this mechanism does not preserve form
3253 // POST data. We will need to send the request's httpBody data up to the
3254 // browser process, and issue a special POST navigation in WebKit (via
3255 // FrameLoader::loadFrameRequest). See ResourceDispatcher and WebURLLoaderImpl
3256 // for examples of how to send the httpBody data.
3257 if (!frame->parent() && is_content_initiated &&
3258 !url.SchemeIs(chrome::kAboutScheme)) {
3259 bool send_referrer = false;
3260
3261 // All navigations to or from WebUI URLs or within WebUI-enabled
3262 // RenderProcesses must be handled by the browser process so that the
3263 // correct bindings and data sources can be registered.
3264 // Similarly, navigations to view-source URLs or within ViewSource mode
3265 // must be handled by the browser process (except for reloads - those are
3266 // safe to leave within the renderer).
3267 // Lastly, access to file:// URLs from non-file:// URL pages must be
3268 // handled by the browser so that ordinary renderer processes don't get
3269 // blessed with file permissions.
3270 int cumulative_bindings = RenderProcess::current()->GetEnabledBindings();
3271 bool is_initial_navigation = page_id_ == -1;
3272 bool should_fork = HasWebUIScheme(url) || HasWebUIScheme(old_url) ||
3273 (cumulative_bindings & BINDINGS_POLICY_WEB_UI) ||
3274 url.SchemeIs(kViewSourceScheme) ||
3275 (frame->isViewSourceModeEnabled() &&
3276 type != blink::WebNavigationTypeReload);
3277
3278 if (!should_fork && url.SchemeIs(chrome::kFileScheme)) {
3279 // Fork non-file to file opens. Check the opener URL if this is the
3280 // initial navigation in a newly opened window.
3281 GURL source_url(old_url);
3282 if (is_initial_navigation && source_url.is_empty() && frame->opener())
3283 source_url = frame->opener()->top()->document().url();
3284 DCHECK(!source_url.is_empty());
3285 should_fork = !source_url.SchemeIs(chrome::kFileScheme);
3286 }
3287
3288 if (!should_fork) {
3289 // Give the embedder a chance.
3290 should_fork = GetContentClient()->renderer()->ShouldFork(
3291 frame, url, request.httpMethod().utf8(), is_initial_navigation,
3292 is_redirect, &send_referrer);
3293 }
3294
3295 if (should_fork) {
3296 OpenURL(
3297 frame, url, send_referrer ? referrer : Referrer(), default_policy);
3298 return blink::WebNavigationPolicyIgnore; // Suppress the load here.
3299 }
3300 }
3301
3302 // Detect when a page is "forking" a new tab that can be safely rendered in
3303 // its own process. This is done by sites like Gmail that try to open links
3304 // in new windows without script connections back to the original page. We
3305 // treat such cases as browser navigations (in which we will create a new
3306 // renderer for a cross-site navigation), rather than WebKit navigations.
3307 //
3308 // We use the following heuristic to decide whether to fork a new page in its
3309 // own process:
3310 // The parent page must open a new tab to about:blank, set the new tab's
3311 // window.opener to null, and then redirect the tab to a cross-site URL using
3312 // JavaScript.
3313 //
3314 // TODO(creis): Deprecate this logic once we can rely on rel=noreferrer
3315 // (see below).
3316 bool is_fork =
3317 // Must start from a tab showing about:blank, which is later redirected.
3318 old_url == GURL(kAboutBlankURL) &&
3319 // Must be the first real navigation of the tab.
3320 historyBackListCount() < 1 &&
3321 historyForwardListCount() < 1 &&
3322 // The parent page must have set the child's window.opener to null before
3323 // redirecting to the desired URL.
3324 frame->opener() == NULL &&
3325 // Must be a top-level frame.
3326 frame->parent() == NULL &&
3327 // Must not have issued the request from this page.
3328 is_content_initiated &&
3329 // Must be targeted at the current tab.
3330 default_policy == blink::WebNavigationPolicyCurrentTab &&
3331 // Must be a JavaScript navigation, which appears as "other".
3332 type == blink::WebNavigationTypeOther;
3333
3334 if (is_fork) {
3335 // Open the URL via the browser, not via WebKit.
3336 OpenURL(frame, url, Referrer(), default_policy);
3337 return blink::WebNavigationPolicyIgnore;
3338 }
3339
3340 return default_policy;
3341 }
3342
decidePolicyForNavigation(WebFrame * frame,const WebURLRequest & request,WebNavigationType type,WebNavigationPolicy default_policy,bool is_redirect)3343 WebNavigationPolicy RenderViewImpl::decidePolicyForNavigation(
3344 WebFrame* frame, const WebURLRequest& request, WebNavigationType type,
3345 WebNavigationPolicy default_policy, bool is_redirect) {
3346 return decidePolicyForNavigation(frame,
3347 frame->provisionalDataSource()->extraData(),
3348 request, type, default_policy, is_redirect);
3349 }
3350
willSendSubmitEvent(blink::WebFrame * frame,const blink::WebFormElement & form)3351 void RenderViewImpl::willSendSubmitEvent(blink::WebFrame* frame,
3352 const blink::WebFormElement& form) {
3353 FOR_EACH_OBSERVER(
3354 RenderViewObserver, observers_, WillSendSubmitEvent(frame, form));
3355 }
3356
willSubmitForm(WebFrame * frame,const WebFormElement & form)3357 void RenderViewImpl::willSubmitForm(WebFrame* frame,
3358 const WebFormElement& form) {
3359 FOR_EACH_OBSERVER(
3360 RenderViewObserver, observers_, WillSubmitForm(frame, form));
3361 }
3362
didCreateDataSource(WebFrame * frame,WebDataSource * ds)3363 void RenderViewImpl::didCreateDataSource(WebFrame* frame, WebDataSource* ds) {
3364 bool content_initiated = !pending_navigation_params_.get();
3365
3366 // Make sure any previous redirect URLs end up in our new data source.
3367 if (pending_navigation_params_.get()) {
3368 for (std::vector<GURL>::const_iterator i =
3369 pending_navigation_params_->redirects.begin();
3370 i != pending_navigation_params_->redirects.end(); ++i) {
3371 ds->appendRedirect(*i);
3372 }
3373 }
3374
3375 DocumentState* document_state = DocumentState::FromDataSource(ds);
3376 if (!document_state) {
3377 document_state = new DocumentState;
3378 ds->setExtraData(document_state);
3379 if (!content_initiated)
3380 PopulateDocumentStateFromPending(document_state);
3381 }
3382
3383 // Carry over the user agent override flag, if it exists.
3384 if (content_initiated && webview() && webview()->mainFrame() &&
3385 webview()->mainFrame()->dataSource()) {
3386 DocumentState* old_document_state =
3387 DocumentState::FromDataSource(webview()->mainFrame()->dataSource());
3388 if (old_document_state) {
3389 InternalDocumentStateData* internal_data =
3390 InternalDocumentStateData::FromDocumentState(document_state);
3391 InternalDocumentStateData* old_internal_data =
3392 InternalDocumentStateData::FromDocumentState(old_document_state);
3393 internal_data->set_is_overriding_user_agent(
3394 old_internal_data->is_overriding_user_agent());
3395 }
3396 }
3397
3398 // The rest of RenderView assumes that a WebDataSource will always have a
3399 // non-null NavigationState.
3400 if (content_initiated) {
3401 document_state->set_navigation_state(
3402 NavigationState::CreateContentInitiated());
3403 } else {
3404 document_state->set_navigation_state(CreateNavigationStateFromPending());
3405 pending_navigation_params_.reset();
3406 }
3407
3408 // DocumentState::referred_by_prefetcher_ is true if we are
3409 // navigating from a page that used prefetching using a link on that
3410 // page. We are early enough in the request process here that we
3411 // can still see the DocumentState of the previous page and set
3412 // this value appropriately.
3413 // TODO(gavinp): catch the important case of navigation in a new
3414 // renderer process.
3415 if (webview()) {
3416 if (WebFrame* old_frame = webview()->mainFrame()) {
3417 const WebURLRequest& original_request = ds->originalRequest();
3418 const GURL referrer(
3419 original_request.httpHeaderField(WebString::fromUTF8("Referer")));
3420 if (!referrer.is_empty() &&
3421 DocumentState::FromDataSource(
3422 old_frame->dataSource())->was_prefetcher()) {
3423 for (; old_frame; old_frame = old_frame->traverseNext(false)) {
3424 WebDataSource* old_frame_ds = old_frame->dataSource();
3425 if (old_frame_ds && referrer == GURL(old_frame_ds->request().url())) {
3426 document_state->set_was_referred_by_prefetcher(true);
3427 break;
3428 }
3429 }
3430 }
3431 }
3432 }
3433
3434 if (content_initiated) {
3435 const WebURLRequest& request = ds->request();
3436 switch (request.cachePolicy()) {
3437 case WebURLRequest::UseProtocolCachePolicy: // normal load.
3438 document_state->set_load_type(DocumentState::LINK_LOAD_NORMAL);
3439 break;
3440 case WebURLRequest::ReloadIgnoringCacheData: // reload.
3441 document_state->set_load_type(DocumentState::LINK_LOAD_RELOAD);
3442 break;
3443 case WebURLRequest::ReturnCacheDataElseLoad: // allow stale data.
3444 document_state->set_load_type(
3445 DocumentState::LINK_LOAD_CACHE_STALE_OK);
3446 break;
3447 case WebURLRequest::ReturnCacheDataDontLoad: // Don't re-post.
3448 document_state->set_load_type(DocumentState::LINK_LOAD_CACHE_ONLY);
3449 break;
3450 }
3451 }
3452
3453 FOR_EACH_OBSERVER(
3454 RenderViewObserver, observers_, DidCreateDataSource(frame, ds));
3455 }
3456
PopulateDocumentStateFromPending(DocumentState * document_state)3457 void RenderViewImpl::PopulateDocumentStateFromPending(
3458 DocumentState* document_state) {
3459 const ViewMsg_Navigate_Params& params = *pending_navigation_params_.get();
3460 document_state->set_request_time(params.request_time);
3461
3462 InternalDocumentStateData* internal_data =
3463 InternalDocumentStateData::FromDocumentState(document_state);
3464
3465 if (!params.url.SchemeIs(kJavaScriptScheme) &&
3466 params.navigation_type == ViewMsg_Navigate_Type::RESTORE) {
3467 // We're doing a load of a page that was restored from the last session. By
3468 // default this prefers the cache over loading (LOAD_PREFERRING_CACHE) which
3469 // can result in stale data for pages that are set to expire. We explicitly
3470 // override that by setting the policy here so that as necessary we load
3471 // from the network.
3472 internal_data->set_cache_policy_override(
3473 WebURLRequest::UseProtocolCachePolicy);
3474 }
3475
3476 if (IsReload(params))
3477 document_state->set_load_type(DocumentState::RELOAD);
3478 else if (params.page_state.IsValid())
3479 document_state->set_load_type(DocumentState::HISTORY_LOAD);
3480 else
3481 document_state->set_load_type(DocumentState::NORMAL_LOAD);
3482
3483 internal_data->set_referrer_policy(params.referrer.policy);
3484 internal_data->set_is_overriding_user_agent(params.is_overriding_user_agent);
3485 internal_data->set_must_reset_scroll_and_scale_state(
3486 params.navigation_type ==
3487 ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL);
3488 document_state->set_can_load_local_resources(params.can_load_local_resources);
3489 }
3490
CreateNavigationStateFromPending()3491 NavigationState* RenderViewImpl::CreateNavigationStateFromPending() {
3492 const ViewMsg_Navigate_Params& params = *pending_navigation_params_.get();
3493 NavigationState* navigation_state = NULL;
3494
3495 // A navigation resulting from loading a javascript URL should not be treated
3496 // as a browser initiated event. Instead, we want it to look as if the page
3497 // initiated any load resulting from JS execution.
3498 if (!params.url.SchemeIs(kJavaScriptScheme)) {
3499 navigation_state = NavigationState::CreateBrowserInitiated(
3500 params.page_id,
3501 params.pending_history_list_offset,
3502 params.should_clear_history_list,
3503 params.transition);
3504 navigation_state->set_should_replace_current_entry(
3505 params.should_replace_current_entry);
3506 navigation_state->set_transferred_request_child_id(
3507 params.transferred_request_child_id);
3508 navigation_state->set_transferred_request_request_id(
3509 params.transferred_request_request_id);
3510 navigation_state->set_allow_download(params.allow_download);
3511 navigation_state->set_extra_headers(params.extra_headers);
3512 } else {
3513 navigation_state = NavigationState::CreateContentInitiated();
3514 }
3515 return navigation_state;
3516 }
3517
ProcessViewLayoutFlags(const CommandLine & command_line)3518 void RenderViewImpl::ProcessViewLayoutFlags(const CommandLine& command_line) {
3519 bool enable_viewport =
3520 command_line.HasSwitch(switches::kEnableViewport) ||
3521 command_line.HasSwitch(switches::kEnableViewportMeta);
3522
3523 // If viewport tag is enabled, then the WebKit side will take care
3524 // of setting the fixed layout size and page scale limits.
3525 if (enable_viewport)
3526 return;
3527
3528 // When navigating to a new page, reset the page scale factor to be 1.0.
3529 webview()->setInitialPageScaleOverride(1.f);
3530
3531 float maxPageScaleFactor =
3532 command_line.HasSwitch(switches::kEnablePinch) ? 4.f : 1.f ;
3533 webview()->setPageScaleFactorLimits(1, maxPageScaleFactor);
3534 }
3535
3536 // TODO(nasko): Remove this method once WebTestProxy in Blink is fixed.
didStartProvisionalLoad(WebFrame * frame)3537 void RenderViewImpl::didStartProvisionalLoad(WebFrame* frame) {
3538 }
3539
didReceiveServerRedirectForProvisionalLoad(WebFrame * frame)3540 void RenderViewImpl::didReceiveServerRedirectForProvisionalLoad(
3541 WebFrame* frame) {
3542 if (frame->parent())
3543 return;
3544 // Received a redirect on the main frame.
3545 WebDataSource* data_source = frame->provisionalDataSource();
3546 if (!data_source) {
3547 // Should only be invoked when we have a data source.
3548 NOTREACHED();
3549 return;
3550 }
3551 std::vector<GURL> redirects;
3552 GetRedirectChain(data_source, &redirects);
3553 if (redirects.size() >= 2) {
3554 Send(new ViewHostMsg_DidRedirectProvisionalLoad(routing_id_, page_id_,
3555 redirects[redirects.size() - 2], redirects.back()));
3556 }
3557 }
3558
didFailProvisionalLoad(WebFrame * frame,const WebURLError & error)3559 void RenderViewImpl::didFailProvisionalLoad(WebFrame* frame,
3560 const WebURLError& error) {
3561 // Notify the browser that we failed a provisional load with an error.
3562 //
3563 // Note: It is important this notification occur before DidStopLoading so the
3564 // SSL manager can react to the provisional load failure before being
3565 // notified the load stopped.
3566 //
3567 WebDataSource* ds = frame->provisionalDataSource();
3568 DCHECK(ds);
3569
3570 const WebURLRequest& failed_request = ds->request();
3571
3572 FOR_EACH_OBSERVER(
3573 RenderViewObserver, observers_, DidFailProvisionalLoad(frame, error));
3574
3575 bool show_repost_interstitial =
3576 (error.reason == net::ERR_CACHE_MISS &&
3577 EqualsASCII(failed_request.httpMethod(), "POST"));
3578
3579 ViewHostMsg_DidFailProvisionalLoadWithError_Params params;
3580 params.frame_id = frame->identifier();
3581 params.frame_unique_name = frame->uniqueName();
3582 params.is_main_frame = !frame->parent();
3583 params.error_code = error.reason;
3584 GetContentClient()->renderer()->GetNavigationErrorStrings(
3585 frame,
3586 failed_request,
3587 error,
3588 renderer_preferences_.accept_languages,
3589 NULL,
3590 ¶ms.error_description);
3591 params.url = error.unreachableURL;
3592 params.showing_repost_interstitial = show_repost_interstitial;
3593 Send(new ViewHostMsg_DidFailProvisionalLoadWithError(
3594 routing_id_, params));
3595
3596 // Don't display an error page if this is simply a cancelled load. Aside
3597 // from being dumb, WebCore doesn't expect it and it will cause a crash.
3598 if (error.reason == net::ERR_ABORTED)
3599 return;
3600
3601 // Don't display "client blocked" error page if browser has asked us not to.
3602 if (error.reason == net::ERR_BLOCKED_BY_CLIENT &&
3603 renderer_preferences_.disable_client_blocked_error_page) {
3604 return;
3605 }
3606
3607 // Allow the embedder to suppress an error page.
3608 if (GetContentClient()->renderer()->ShouldSuppressErrorPage(
3609 error.unreachableURL)) {
3610 return;
3611 }
3612
3613 if (RenderThreadImpl::current() &&
3614 RenderThreadImpl::current()->layout_test_mode()) {
3615 return;
3616 }
3617
3618 // Make sure we never show errors in view source mode.
3619 frame->enableViewSourceMode(false);
3620
3621 DocumentState* document_state = DocumentState::FromDataSource(ds);
3622 NavigationState* navigation_state = document_state->navigation_state();
3623
3624 // If this is a failed back/forward/reload navigation, then we need to do a
3625 // 'replace' load. This is necessary to avoid messing up session history.
3626 // Otherwise, we do a normal load, which simulates a 'go' navigation as far
3627 // as session history is concerned.
3628 //
3629 // AUTO_SUBFRAME loads should always be treated as loads that do not advance
3630 // the page id.
3631 //
3632 // TODO(davidben): This should also take the failed navigation's replacement
3633 // state into account, if a location.replace() failed.
3634 bool replace =
3635 navigation_state->pending_page_id() != -1 ||
3636 PageTransitionCoreTypeIs(navigation_state->transition_type(),
3637 PAGE_TRANSITION_AUTO_SUBFRAME);
3638
3639 // If we failed on a browser initiated request, then make sure that our error
3640 // page load is regarded as the same browser initiated request.
3641 if (!navigation_state->is_content_initiated()) {
3642 pending_navigation_params_.reset(new ViewMsg_Navigate_Params);
3643 pending_navigation_params_->page_id =
3644 navigation_state->pending_page_id();
3645 pending_navigation_params_->pending_history_list_offset =
3646 navigation_state->pending_history_list_offset();
3647 pending_navigation_params_->should_clear_history_list =
3648 navigation_state->history_list_was_cleared();
3649 pending_navigation_params_->transition =
3650 navigation_state->transition_type();
3651 pending_navigation_params_->request_time =
3652 document_state->request_time();
3653 pending_navigation_params_->should_replace_current_entry = replace;
3654 }
3655
3656 // Provide the user with a more helpful error page?
3657 if (MaybeLoadAlternateErrorPage(frame, error, replace))
3658 return;
3659
3660 // Fallback to a local error page.
3661 LoadNavigationErrorPage(frame, failed_request, error, std::string(), replace);
3662 }
3663
didCommitProvisionalLoad(WebFrame * frame,bool is_new_navigation)3664 void RenderViewImpl::didCommitProvisionalLoad(WebFrame* frame,
3665 bool is_new_navigation) {
3666 DocumentState* document_state =
3667 DocumentState::FromDataSource(frame->dataSource());
3668 NavigationState* navigation_state = document_state->navigation_state();
3669 InternalDocumentStateData* internal_data =
3670 InternalDocumentStateData::FromDocumentState(document_state);
3671
3672 if (document_state->commit_load_time().is_null())
3673 document_state->set_commit_load_time(Time::Now());
3674
3675 if (internal_data->must_reset_scroll_and_scale_state()) {
3676 webview()->resetScrollAndScaleState();
3677 internal_data->set_must_reset_scroll_and_scale_state(false);
3678 }
3679 internal_data->set_use_error_page(false);
3680
3681 if (is_new_navigation) {
3682 // When we perform a new navigation, we need to update the last committed
3683 // session history entry with state for the page we are leaving.
3684 UpdateSessionHistory(frame);
3685
3686 // We bump our Page ID to correspond with the new session history entry.
3687 page_id_ = next_page_id_++;
3688
3689 // Don't update history_page_ids_ (etc) for kSwappedOutURL, since
3690 // we don't want to forget the entry that was there, and since we will
3691 // never come back to kSwappedOutURL. Note that we have to call
3692 // UpdateSessionHistory and update page_id_ even in this case, so that
3693 // the current entry gets a state update and so that we don't send a
3694 // state update to the wrong entry when we swap back in.
3695 if (GetLoadingUrl(frame) != GURL(kSwappedOutURL)) {
3696 // Advance our offset in session history, applying the length limit.
3697 // There is now no forward history.
3698 history_list_offset_++;
3699 if (history_list_offset_ >= kMaxSessionHistoryEntries)
3700 history_list_offset_ = kMaxSessionHistoryEntries - 1;
3701 history_list_length_ = history_list_offset_ + 1;
3702 history_page_ids_.resize(history_list_length_, -1);
3703 history_page_ids_[history_list_offset_] = page_id_;
3704 }
3705 } else {
3706 // Inspect the navigation_state on this frame to see if the navigation
3707 // corresponds to a session history navigation... Note: |frame| may or
3708 // may not be the toplevel frame, but for the case of capturing session
3709 // history, the first committed frame suffices. We keep track of whether
3710 // we've seen this commit before so that only capture session history once
3711 // per navigation.
3712 //
3713 // Note that we need to check if the page ID changed. In the case of a
3714 // reload, the page ID doesn't change, and UpdateSessionHistory gets the
3715 // previous URL and the current page ID, which would be wrong.
3716 if (navigation_state->pending_page_id() != -1 &&
3717 navigation_state->pending_page_id() != page_id_ &&
3718 !navigation_state->request_committed()) {
3719 // This is a successful session history navigation!
3720 UpdateSessionHistory(frame);
3721 page_id_ = navigation_state->pending_page_id();
3722
3723 history_list_offset_ = navigation_state->pending_history_list_offset();
3724
3725 // If the history list is valid, our list of page IDs should be correct.
3726 DCHECK(history_list_length_ <= 0 ||
3727 history_list_offset_ < 0 ||
3728 history_list_offset_ >= history_list_length_ ||
3729 history_page_ids_[history_list_offset_] == page_id_);
3730 }
3731 }
3732
3733 FOR_EACH_OBSERVER(RenderViewObserver, observers_,
3734 DidCommitProvisionalLoad(frame, is_new_navigation));
3735
3736 // Remember that we've already processed this request, so we don't update
3737 // the session history again. We do this regardless of whether this is
3738 // a session history navigation, because if we attempted a session history
3739 // navigation without valid HistoryItem state, WebCore will think it is a
3740 // new navigation.
3741 navigation_state->set_request_committed(true);
3742
3743 UpdateURL(frame);
3744
3745 // Check whether we have new encoding name.
3746 UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
3747
3748 if (!frame->parent()) { // Only for top frames.
3749 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
3750 if (render_thread_impl) { // Can be NULL in tests.
3751 render_thread_impl->histogram_customizer()->
3752 RenderViewNavigatedToHost(GURL(GetLoadingUrl(frame)).host(),
3753 g_view_map.Get().size());
3754 }
3755 }
3756 }
3757
didClearWindowObject(WebFrame * frame)3758 void RenderViewImpl::didClearWindowObject(WebFrame* frame) {
3759 FOR_EACH_OBSERVER(RenderViewObserver, observers_,
3760 DidClearWindowObject(frame));
3761
3762 if (enabled_bindings_ & BINDINGS_POLICY_DOM_AUTOMATION) {
3763 if (!dom_automation_controller_)
3764 dom_automation_controller_.reset(new DomAutomationController());
3765 dom_automation_controller_->set_message_sender(
3766 static_cast<RenderView*>(this));
3767 dom_automation_controller_->set_routing_id(routing_id());
3768 dom_automation_controller_->BindToJavascript(frame,
3769 "domAutomationController");
3770 }
3771
3772 if (enabled_bindings_ & BINDINGS_POLICY_STATS_COLLECTION)
3773 StatsCollectionController::Install(frame);
3774 }
3775
didCreateDocumentElement(WebFrame * frame)3776 void RenderViewImpl::didCreateDocumentElement(WebFrame* frame) {
3777 FOR_EACH_OBSERVER(RenderViewObserver, observers_,
3778 DidCreateDocumentElement(frame));
3779 }
3780
didReceiveTitle(WebFrame * frame,const WebString & title,WebTextDirection direction)3781 void RenderViewImpl::didReceiveTitle(WebFrame* frame, const WebString& title,
3782 WebTextDirection direction) {
3783 UpdateTitle(frame, title, direction);
3784
3785 // Also check whether we have new encoding name.
3786 UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
3787 }
3788
didChangeIcon(WebFrame * frame,WebIconURL::Type icon_type)3789 void RenderViewImpl::didChangeIcon(WebFrame* frame,
3790 WebIconURL::Type icon_type) {
3791 if (frame->parent())
3792 return;
3793
3794 if (!TouchEnabled() && icon_type != WebIconURL::TypeFavicon)
3795 return;
3796
3797 WebVector<WebIconURL> icon_urls = frame->iconURLs(icon_type);
3798 std::vector<FaviconURL> urls;
3799 for (size_t i = 0; i < icon_urls.size(); i++) {
3800 urls.push_back(FaviconURL(icon_urls[i].iconURL(),
3801 ToFaviconType(icon_urls[i].iconType())));
3802 }
3803 SendUpdateFaviconURL(urls);
3804 }
3805
didFinishDocumentLoad(WebFrame * frame)3806 void RenderViewImpl::didFinishDocumentLoad(WebFrame* frame) {
3807 WebDataSource* ds = frame->dataSource();
3808 DocumentState* document_state = DocumentState::FromDataSource(ds);
3809 document_state->set_finish_document_load_time(Time::Now());
3810
3811 Send(new ViewHostMsg_DocumentLoadedInFrame(routing_id_, frame->identifier()));
3812
3813 FOR_EACH_OBSERVER(RenderViewObserver, observers_,
3814 DidFinishDocumentLoad(frame));
3815
3816 // Check whether we have new encoding name.
3817 UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
3818 }
3819
didHandleOnloadEvents(WebFrame * frame)3820 void RenderViewImpl::didHandleOnloadEvents(WebFrame* frame) {
3821 if (webview()->mainFrame() == frame) {
3822 Send(new ViewHostMsg_DocumentOnLoadCompletedInMainFrame(routing_id_,
3823 page_id_));
3824 }
3825 }
3826
didFailLoad(WebFrame * frame,const WebURLError & error)3827 void RenderViewImpl::didFailLoad(WebFrame* frame, const WebURLError& error) {
3828 WebDataSource* ds = frame->dataSource();
3829 DCHECK(ds);
3830
3831
3832 FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFailLoad(frame, error));
3833
3834 const WebURLRequest& failed_request = ds->request();
3835 base::string16 error_description;
3836 GetContentClient()->renderer()->GetNavigationErrorStrings(
3837 frame,
3838 failed_request,
3839 error,
3840 renderer_preferences_.accept_languages,
3841 NULL,
3842 &error_description);
3843 Send(new ViewHostMsg_DidFailLoadWithError(routing_id_,
3844 frame->identifier(),
3845 failed_request.url(),
3846 !frame->parent(),
3847 error.reason,
3848 error_description));
3849 }
3850
didFinishLoad(WebFrame * frame)3851 void RenderViewImpl::didFinishLoad(WebFrame* frame) {
3852 WebDataSource* ds = frame->dataSource();
3853 DocumentState* document_state = DocumentState::FromDataSource(ds);
3854 if (document_state->finish_load_time().is_null()) {
3855 if (!frame->parent()) {
3856 TRACE_EVENT_INSTANT0("WebCore", "LoadFinished",
3857 TRACE_EVENT_SCOPE_PROCESS);
3858 }
3859 document_state->set_finish_load_time(Time::Now());
3860 }
3861
3862 FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFinishLoad(frame));
3863
3864 Send(new ViewHostMsg_DidFinishLoad(routing_id_,
3865 frame->identifier(),
3866 ds->request().url(),
3867 !frame->parent()));
3868 }
3869
didNavigateWithinPage(WebFrame * frame,bool is_new_navigation)3870 void RenderViewImpl::didNavigateWithinPage(
3871 WebFrame* frame, bool is_new_navigation) {
3872 // If this was a reference fragment navigation that we initiated, then we
3873 // could end up having a non-null pending navigation params. We just need to
3874 // update the ExtraData on the datasource so that others who read the
3875 // ExtraData will get the new NavigationState. Similarly, if we did not
3876 // initiate this navigation, then we need to take care to reset any pre-
3877 // existing navigation state to a content-initiated navigation state.
3878 // DidCreateDataSource conveniently takes care of this for us.
3879 didCreateDataSource(frame, frame->dataSource());
3880
3881 DocumentState* document_state =
3882 DocumentState::FromDataSource(frame->dataSource());
3883 NavigationState* new_state = document_state->navigation_state();
3884 new_state->set_was_within_same_page(true);
3885
3886 didCommitProvisionalLoad(frame, is_new_navigation);
3887 }
3888
didUpdateCurrentHistoryItem(WebFrame * frame)3889 void RenderViewImpl::didUpdateCurrentHistoryItem(WebFrame* frame) {
3890 StartNavStateSyncTimerIfNecessary();
3891 }
3892
willSendRequest(WebFrame * frame,unsigned identifier,WebURLRequest & request,const WebURLResponse & redirect_response)3893 void RenderViewImpl::willSendRequest(WebFrame* frame,
3894 unsigned identifier,
3895 WebURLRequest& request,
3896 const WebURLResponse& redirect_response) {
3897 NOTREACHED();
3898 }
3899
didReceiveResponse(WebFrame * frame,unsigned identifier,const WebURLResponse & response)3900 void RenderViewImpl::didReceiveResponse(
3901 WebFrame* frame, unsigned identifier, const WebURLResponse& response) {
3902 NOTREACHED();
3903 }
3904
didFinishResourceLoad(WebFrame * frame,unsigned identifier)3905 void RenderViewImpl::didFinishResourceLoad(
3906 WebFrame* frame, unsigned identifier) {
3907 InternalDocumentStateData* internal_data =
3908 InternalDocumentStateData::FromDataSource(frame->dataSource());
3909 if (!internal_data->use_error_page())
3910 return;
3911
3912 // Do not show error page when DevTools is attached.
3913 if (devtools_agent_->IsAttached())
3914 return;
3915
3916 // Display error page, if appropriate.
3917 int http_status_code = internal_data->http_status_code();
3918 if (http_status_code == 404) {
3919 // On 404s, try a remote search page as a fallback.
3920 const GURL& document_url = frame->document().url();
3921
3922 const GURL& error_page_url =
3923 GetAlternateErrorPageURL(document_url, HTTP_404);
3924 if (error_page_url.is_valid()) {
3925 WebURLError original_error;
3926 original_error.domain = "http";
3927 original_error.reason = 404;
3928 original_error.unreachableURL = document_url;
3929
3930 internal_data->set_alt_error_page_fetcher(
3931 new AltErrorPageResourceFetcher(
3932 error_page_url, frame, frame->dataSource()->request(),
3933 original_error,
3934 base::Bind(&RenderViewImpl::AltErrorPageFinished,
3935 base::Unretained(this))));
3936 return;
3937 }
3938 }
3939
3940 std::string error_domain;
3941 if (GetContentClient()->renderer()->HasErrorPage(
3942 http_status_code, &error_domain)) {
3943 WebURLError error;
3944 error.unreachableURL = frame->document().url();
3945 error.domain = WebString::fromUTF8(error_domain);
3946 error.reason = http_status_code;
3947
3948 LoadNavigationErrorPage(
3949 frame, frame->dataSource()->request(), error, std::string(), true);
3950 }
3951 }
3952
didLoadResourceFromMemoryCache(WebFrame * frame,const WebURLRequest & request,const WebURLResponse & response)3953 void RenderViewImpl::didLoadResourceFromMemoryCache(
3954 WebFrame* frame, const WebURLRequest& request,
3955 const WebURLResponse& response) {
3956 NOTREACHED();
3957 }
3958
didDisplayInsecureContent(WebFrame * frame)3959 void RenderViewImpl::didDisplayInsecureContent(WebFrame* frame) {
3960 NOTREACHED();
3961 }
3962
didRunInsecureContent(WebFrame * frame,const WebSecurityOrigin & origin,const WebURL & target)3963 void RenderViewImpl::didRunInsecureContent(
3964 WebFrame* frame, const WebSecurityOrigin& origin, const WebURL& target) {
3965 NOTREACHED();
3966 }
3967
didExhaustMemoryAvailableForScript(WebFrame * frame)3968 void RenderViewImpl::didExhaustMemoryAvailableForScript(WebFrame* frame) {
3969 NOTREACHED();
3970 }
3971
didCreateScriptContext(WebFrame * frame,v8::Handle<v8::Context> context,int extension_group,int world_id)3972 void RenderViewImpl::didCreateScriptContext(WebFrame* frame,
3973 v8::Handle<v8::Context> context,
3974 int extension_group,
3975 int world_id) {
3976 NOTREACHED();
3977 }
3978
willReleaseScriptContext(WebFrame * frame,v8::Handle<v8::Context> context,int world_id)3979 void RenderViewImpl::willReleaseScriptContext(WebFrame* frame,
3980 v8::Handle<v8::Context> context,
3981 int world_id) {
3982 NOTREACHED();
3983 }
3984
CheckPreferredSize()3985 void RenderViewImpl::CheckPreferredSize() {
3986 // We don't always want to send the change messages over IPC, only if we've
3987 // been put in that mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
3988 // message.
3989 if (!send_preferred_size_changes_ || !webview())
3990 return;
3991
3992 gfx::Size size = webview()->contentsPreferredMinimumSize();
3993
3994 // In the presence of zoom, these sizes are still reported as if unzoomed,
3995 // so we need to adjust.
3996 double zoom_factor = ZoomLevelToZoomFactor(webview()->zoomLevel());
3997 size.set_width(static_cast<int>(size.width() * zoom_factor));
3998 size.set_height(static_cast<int>(size.height() * zoom_factor));
3999
4000 if (size == preferred_size_)
4001 return;
4002
4003 preferred_size_ = size;
4004 Send(new ViewHostMsg_DidContentsPreferredSizeChange(routing_id_,
4005 preferred_size_));
4006 }
4007
GetBrowserPluginManager()4008 BrowserPluginManager* RenderViewImpl::GetBrowserPluginManager() {
4009 if (!browser_plugin_manager_.get())
4010 browser_plugin_manager_ = BrowserPluginManager::Create(this);
4011 return browser_plugin_manager_.get();
4012 }
4013
InitializeMediaStreamClient()4014 bool RenderViewImpl::InitializeMediaStreamClient() {
4015 if (media_stream_client_)
4016 return true;
4017
4018 if (!RenderThreadImpl::current()) // Will be NULL during unit tests.
4019 return false;
4020
4021 #if defined(OS_ANDROID)
4022 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableWebRTC))
4023 return false;
4024 #endif
4025
4026 #if defined(ENABLE_WEBRTC)
4027 if (!media_stream_dispatcher_)
4028 media_stream_dispatcher_ = new MediaStreamDispatcher(this);
4029
4030 MediaStreamImpl* media_stream_impl = new MediaStreamImpl(
4031 this,
4032 media_stream_dispatcher_,
4033 RenderThreadImpl::current()->GetMediaStreamDependencyFactory());
4034 media_stream_client_ = media_stream_impl;
4035 web_user_media_client_ = media_stream_impl;
4036 return true;
4037 #else
4038 return false;
4039 #endif
4040 }
4041
didChangeContentsSize(WebFrame * frame,const WebSize & size)4042 void RenderViewImpl::didChangeContentsSize(WebFrame* frame,
4043 const WebSize& size) {
4044 if (webview()->mainFrame() != frame)
4045 return;
4046 WebView* frameView = frame->view();
4047 if (!frameView)
4048 return;
4049
4050 bool has_horizontal_scrollbar = frame->hasHorizontalScrollbar();
4051 bool has_vertical_scrollbar = frame->hasVerticalScrollbar();
4052
4053 if (has_horizontal_scrollbar != cached_has_main_frame_horizontal_scrollbar_ ||
4054 has_vertical_scrollbar != cached_has_main_frame_vertical_scrollbar_) {
4055 Send(new ViewHostMsg_DidChangeScrollbarsForMainFrame(
4056 routing_id_, has_horizontal_scrollbar, has_vertical_scrollbar));
4057
4058 cached_has_main_frame_horizontal_scrollbar_ = has_horizontal_scrollbar;
4059 cached_has_main_frame_vertical_scrollbar_ = has_vertical_scrollbar;
4060 }
4061 }
4062
UpdateScrollState(WebFrame * frame)4063 void RenderViewImpl::UpdateScrollState(WebFrame* frame) {
4064 WebSize offset = frame->scrollOffset();
4065 WebSize minimum_offset = frame->minimumScrollOffset();
4066 WebSize maximum_offset = frame->maximumScrollOffset();
4067
4068 bool is_pinned_to_left = offset.width <= minimum_offset.width;
4069 bool is_pinned_to_right = offset.width >= maximum_offset.width;
4070
4071 if (is_pinned_to_left != cached_is_main_frame_pinned_to_left_ ||
4072 is_pinned_to_right != cached_is_main_frame_pinned_to_right_) {
4073 Send(new ViewHostMsg_DidChangeScrollOffsetPinningForMainFrame(
4074 routing_id_, is_pinned_to_left, is_pinned_to_right));
4075
4076 cached_is_main_frame_pinned_to_left_ = is_pinned_to_left;
4077 cached_is_main_frame_pinned_to_right_ = is_pinned_to_right;
4078 }
4079
4080 Send(new ViewHostMsg_DidChangeScrollOffset(routing_id_));
4081 }
4082
didChangeScrollOffset(WebFrame * frame)4083 void RenderViewImpl::didChangeScrollOffset(WebFrame* frame) {
4084 StartNavStateSyncTimerIfNecessary();
4085
4086 if (webview()->mainFrame() == frame)
4087 UpdateScrollState(frame);
4088
4089 FOR_EACH_OBSERVER(
4090 RenderViewObserver, observers_, DidChangeScrollOffset(frame));
4091 }
4092
willInsertBody(blink::WebFrame * frame)4093 void RenderViewImpl::willInsertBody(blink::WebFrame* frame) {
4094 NOTREACHED();
4095 }
4096
didFirstVisuallyNonEmptyLayout(WebFrame * frame)4097 void RenderViewImpl::didFirstVisuallyNonEmptyLayout(WebFrame* frame) {
4098 if (frame != webview()->mainFrame())
4099 return;
4100
4101 InternalDocumentStateData* data =
4102 InternalDocumentStateData::FromDataSource(frame->dataSource());
4103 data->set_did_first_visually_non_empty_layout(true);
4104
4105 #if defined(OS_ANDROID)
4106 // Update body background color if necessary.
4107 SkColor bg_color = webwidget_->backgroundColor();
4108
4109 // If not initialized, default to white. Note that 0 is different from black
4110 // as black still has alpha 0xFF.
4111 if (!bg_color)
4112 bg_color = SK_ColorWHITE;
4113
4114 if (bg_color != body_background_color_) {
4115 body_background_color_ = bg_color;
4116 Send(new ViewHostMsg_DidChangeBodyBackgroundColor(
4117 GetRoutingID(), bg_color));
4118 }
4119 #endif
4120 }
4121
SendFindReply(int request_id,int match_count,int ordinal,const WebRect & selection_rect,bool final_status_update)4122 void RenderViewImpl::SendFindReply(int request_id,
4123 int match_count,
4124 int ordinal,
4125 const WebRect& selection_rect,
4126 bool final_status_update) {
4127 Send(new ViewHostMsg_Find_Reply(routing_id_,
4128 request_id,
4129 match_count,
4130 selection_rect,
4131 ordinal,
4132 final_status_update));
4133 }
4134
4135 // static
ShouldUpdateSelectionTextFromContextMenuParams(const base::string16 & selection_text,size_t selection_text_offset,const gfx::Range & selection_range,const ContextMenuParams & params)4136 bool RenderViewImpl::ShouldUpdateSelectionTextFromContextMenuParams(
4137 const base::string16& selection_text,
4138 size_t selection_text_offset,
4139 const gfx::Range& selection_range,
4140 const ContextMenuParams& params) {
4141 base::string16 trimmed_selection_text;
4142 if (!selection_text.empty() && !selection_range.is_empty()) {
4143 const int start = selection_range.GetMin() - selection_text_offset;
4144 const size_t length = selection_range.length();
4145 if (start >= 0 && start + length <= selection_text.length()) {
4146 TrimWhitespace(selection_text.substr(start, length), TRIM_ALL,
4147 &trimmed_selection_text);
4148 }
4149 }
4150 base::string16 trimmed_params_text;
4151 TrimWhitespace(params.selection_text, TRIM_ALL, &trimmed_params_text);
4152 return trimmed_params_text != trimmed_selection_text;
4153 }
4154
reportFindInPageMatchCount(int request_id,int count,bool final_update)4155 void RenderViewImpl::reportFindInPageMatchCount(int request_id,
4156 int count,
4157 bool final_update) {
4158 NOTREACHED();
4159 }
4160
reportFindInPageSelection(int request_id,int active_match_ordinal,const WebRect & selection_rect)4161 void RenderViewImpl::reportFindInPageSelection(int request_id,
4162 int active_match_ordinal,
4163 const WebRect& selection_rect) {
4164 NOTREACHED();
4165 }
4166
requestStorageQuota(WebFrame * frame,WebStorageQuotaType type,unsigned long long requested_size,WebStorageQuotaCallbacks * callbacks)4167 void RenderViewImpl::requestStorageQuota(
4168 WebFrame* frame,
4169 WebStorageQuotaType type,
4170 unsigned long long requested_size,
4171 WebStorageQuotaCallbacks* callbacks) {
4172 NOTREACHED();
4173 }
4174
willCheckAndDispatchMessageEvent(blink::WebFrame * sourceFrame,blink::WebFrame * targetFrame,blink::WebSecurityOrigin target_origin,blink::WebDOMMessageEvent event)4175 bool RenderViewImpl::willCheckAndDispatchMessageEvent(
4176 blink::WebFrame* sourceFrame,
4177 blink::WebFrame* targetFrame,
4178 blink::WebSecurityOrigin target_origin,
4179 blink::WebDOMMessageEvent event) {
4180 if (!is_swapped_out_)
4181 return false;
4182
4183 ViewMsg_PostMessage_Params params;
4184 params.data = event.data().toString();
4185 params.source_origin = event.origin();
4186 if (!target_origin.isNull())
4187 params.target_origin = target_origin.toString();
4188
4189 blink::WebMessagePortChannelArray channels = event.releaseChannels();
4190 if (!channels.isEmpty()) {
4191 std::vector<int> message_port_ids(channels.size());
4192 // Extract the port IDs from the channel array.
4193 for (size_t i = 0; i < channels.size(); ++i) {
4194 WebMessagePortChannelImpl* webchannel =
4195 static_cast<WebMessagePortChannelImpl*>(channels[i]);
4196 message_port_ids[i] = webchannel->message_port_id();
4197 webchannel->QueueMessages();
4198 DCHECK_NE(message_port_ids[i], MSG_ROUTING_NONE);
4199 }
4200 params.message_port_ids = message_port_ids;
4201 }
4202
4203 // Include the routing ID for the source frame (if one exists), which the
4204 // browser process will translate into the routing ID for the equivalent
4205 // frame in the target process.
4206 params.source_routing_id = MSG_ROUTING_NONE;
4207 if (sourceFrame) {
4208 RenderViewImpl* source_view = FromWebView(sourceFrame->view());
4209 if (source_view)
4210 params.source_routing_id = source_view->routing_id();
4211 }
4212
4213 Send(new ViewHostMsg_RouteMessageEvent(routing_id_, params));
4214 return true;
4215 }
4216
willOpenSocketStream(WebSocketStreamHandle * handle)4217 void RenderViewImpl::willOpenSocketStream(
4218 WebSocketStreamHandle* handle) {
4219 NOTREACHED();
4220 }
4221
willStartUsingPeerConnectionHandler(blink::WebFrame * frame,blink::WebRTCPeerConnectionHandler * handler)4222 void RenderViewImpl::willStartUsingPeerConnectionHandler(
4223 blink::WebFrame* frame, blink::WebRTCPeerConnectionHandler* handler) {
4224 NOTREACHED();
4225 }
4226
acceptLanguages()4227 blink::WebString RenderViewImpl::acceptLanguages() {
4228 return WebString::fromUTF8(renderer_preferences_.accept_languages);
4229 }
4230
userAgentOverride(blink::WebFrame * frame,const blink::WebURL & url)4231 blink::WebString RenderViewImpl::userAgentOverride(
4232 blink::WebFrame* frame,
4233 const blink::WebURL& url) {
4234 NOTREACHED();
4235 return blink::WebString();
4236 }
4237
doNotTrackValue(WebFrame * frame)4238 WebString RenderViewImpl::doNotTrackValue(WebFrame* frame) {
4239 NOTREACHED();
4240 return blink::WebString();
4241 }
4242
allowWebGL(WebFrame * frame,bool default_value)4243 bool RenderViewImpl::allowWebGL(WebFrame* frame, bool default_value) {
4244 NOTREACHED();
4245 return false;
4246 }
4247
didLoseWebGLContext(blink::WebFrame * frame,int arb_robustness_status_code)4248 void RenderViewImpl::didLoseWebGLContext(
4249 blink::WebFrame* frame,
4250 int arb_robustness_status_code) {
4251 NOTREACHED();
4252 }
4253
4254 // blink::WebPageSerializerClient implementation ------------------------------
4255
didSerializeDataForFrame(const WebURL & frame_url,const WebCString & data,WebPageSerializerClient::PageSerializationStatus status)4256 void RenderViewImpl::didSerializeDataForFrame(
4257 const WebURL& frame_url,
4258 const WebCString& data,
4259 WebPageSerializerClient::PageSerializationStatus status) {
4260 Send(new ViewHostMsg_SendSerializedHtmlData(
4261 routing_id(),
4262 frame_url,
4263 data.data(),
4264 static_cast<int32>(status)));
4265 }
4266
4267 // RenderView implementation ---------------------------------------------------
4268
Send(IPC::Message * message)4269 bool RenderViewImpl::Send(IPC::Message* message) {
4270 return RenderWidget::Send(message);
4271 }
4272
GetMainRenderFrame()4273 RenderFrame* RenderViewImpl::GetMainRenderFrame() {
4274 return main_render_frame_.get();
4275 }
4276
GetRoutingID() const4277 int RenderViewImpl::GetRoutingID() const {
4278 return routing_id_;
4279 }
4280
GetPageId() const4281 int RenderViewImpl::GetPageId() const {
4282 return page_id_;
4283 }
4284
GetSize() const4285 gfx::Size RenderViewImpl::GetSize() const {
4286 return size();
4287 }
4288
GetWebkitPreferences()4289 WebPreferences& RenderViewImpl::GetWebkitPreferences() {
4290 return webkit_preferences_;
4291 }
4292
SetWebkitPreferences(const WebPreferences & preferences)4293 void RenderViewImpl::SetWebkitPreferences(const WebPreferences& preferences) {
4294 OnUpdateWebPreferences(preferences);
4295 }
4296
GetWebView()4297 blink::WebView* RenderViewImpl::GetWebView() {
4298 return webview();
4299 }
4300
GetFocusedNode() const4301 blink::WebNode RenderViewImpl::GetFocusedNode() const {
4302 if (!webview())
4303 return WebNode();
4304 WebFrame* focused_frame = webview()->focusedFrame();
4305 if (focused_frame) {
4306 WebDocument doc = focused_frame->document();
4307 if (!doc.isNull())
4308 return doc.focusedNode();
4309 }
4310
4311 return WebNode();
4312 }
4313
GetContextMenuNode() const4314 blink::WebNode RenderViewImpl::GetContextMenuNode() const {
4315 return context_menu_node_;
4316 }
4317
IsEditableNode(const WebNode & node) const4318 bool RenderViewImpl::IsEditableNode(const WebNode& node) const {
4319 if (node.isNull())
4320 return false;
4321
4322 if (node.isContentEditable())
4323 return true;
4324
4325 if (node.isElementNode()) {
4326 const WebElement& element = node.toConst<WebElement>();
4327 if (element.isTextFormControlElement())
4328 return true;
4329
4330 // Also return true if it has an ARIA role of 'textbox'.
4331 for (unsigned i = 0; i < element.attributeCount(); ++i) {
4332 if (LowerCaseEqualsASCII(element.attributeLocalName(i), "role")) {
4333 if (LowerCaseEqualsASCII(element.attributeValue(i), "textbox"))
4334 return true;
4335 break;
4336 }
4337 }
4338 }
4339
4340 return false;
4341 }
4342
EvaluateScript(const base::string16 & frame_xpath,const base::string16 & jscript,int id,bool notify_result)4343 void RenderViewImpl::EvaluateScript(const base::string16& frame_xpath,
4344 const base::string16& jscript,
4345 int id,
4346 bool notify_result) {
4347 v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
4348 v8::Handle<v8::Value> result;
4349 WebFrame* web_frame = GetChildFrame(frame_xpath);
4350 if (web_frame)
4351 result = web_frame->executeScriptAndReturnValue(WebScriptSource(jscript));
4352 if (notify_result) {
4353 base::ListValue list;
4354 if (!result.IsEmpty() && web_frame) {
4355 v8::Local<v8::Context> context = web_frame->mainWorldScriptContext();
4356 v8::Context::Scope context_scope(context);
4357 V8ValueConverterImpl converter;
4358 converter.SetDateAllowed(true);
4359 converter.SetRegExpAllowed(true);
4360 base::Value* result_value = converter.FromV8Value(result, context);
4361 list.Set(0, result_value ? result_value : base::Value::CreateNullValue());
4362 } else {
4363 list.Set(0, base::Value::CreateNullValue());
4364 }
4365 Send(new ViewHostMsg_ScriptEvalResponse(routing_id_, id, list));
4366 }
4367 }
4368
ShouldDisplayScrollbars(int width,int height) const4369 bool RenderViewImpl::ShouldDisplayScrollbars(int width, int height) const {
4370 return (!send_preferred_size_changes_ ||
4371 (disable_scrollbars_size_limit_.width() <= width ||
4372 disable_scrollbars_size_limit_.height() <= height));
4373 }
4374
GetEnabledBindings() const4375 int RenderViewImpl::GetEnabledBindings() const {
4376 return enabled_bindings_;
4377 }
4378
GetContentStateImmediately() const4379 bool RenderViewImpl::GetContentStateImmediately() const {
4380 return send_content_state_immediately_;
4381 }
4382
GetFilteredTimePerFrame() const4383 float RenderViewImpl::GetFilteredTimePerFrame() const {
4384 return filtered_time_per_frame();
4385 }
4386
ShowContextMenu(ContextMenuClient * client,const ContextMenuParams & params)4387 int RenderViewImpl::ShowContextMenu(ContextMenuClient* client,
4388 const ContextMenuParams& params) {
4389 DCHECK(client); // A null client means "internal" when we issue callbacks.
4390 ContextMenuParams our_params(params);
4391 our_params.custom_context.request_id = pending_context_menus_.Add(client);
4392 Send(new ViewHostMsg_ContextMenu(routing_id_, our_params));
4393 return our_params.custom_context.request_id;
4394 }
4395
CancelContextMenu(int request_id)4396 void RenderViewImpl::CancelContextMenu(int request_id) {
4397 DCHECK(pending_context_menus_.Lookup(request_id));
4398 pending_context_menus_.Remove(request_id);
4399 }
4400
GetVisibilityState() const4401 blink::WebPageVisibilityState RenderViewImpl::GetVisibilityState() const {
4402 return visibilityState();
4403 }
4404
RunModalAlertDialog(blink::WebFrame * frame,const blink::WebString & message)4405 void RenderViewImpl::RunModalAlertDialog(blink::WebFrame* frame,
4406 const blink::WebString& message) {
4407 return runModalAlertDialog(frame, message);
4408 }
4409
DidStartLoading()4410 void RenderViewImpl::DidStartLoading() {
4411 didStartLoading();
4412 }
4413
DidStopLoading()4414 void RenderViewImpl::DidStopLoading() {
4415 didStopLoading();
4416 }
4417
DidPlay(blink::WebMediaPlayer * player)4418 void RenderViewImpl::DidPlay(blink::WebMediaPlayer* player) {
4419 Send(new ViewHostMsg_MediaNotification(routing_id_,
4420 reinterpret_cast<int64>(player),
4421 player->hasVideo(),
4422 player->hasAudio(),
4423 true));
4424 }
4425
DidPause(blink::WebMediaPlayer * player)4426 void RenderViewImpl::DidPause(blink::WebMediaPlayer* player) {
4427 Send(new ViewHostMsg_MediaNotification(routing_id_,
4428 reinterpret_cast<int64>(player),
4429 player->hasVideo(),
4430 player->hasAudio(),
4431 false));
4432 }
4433
PlayerGone(blink::WebMediaPlayer * player)4434 void RenderViewImpl::PlayerGone(blink::WebMediaPlayer* player) {
4435 DidPause(player);
4436 }
4437
SyncNavigationState()4438 void RenderViewImpl::SyncNavigationState() {
4439 if (!webview())
4440 return;
4441
4442 const WebHistoryItem& item = webview()->mainFrame()->currentHistoryItem();
4443 SendUpdateState(item);
4444 }
4445
SyncSelectionIfRequired()4446 void RenderViewImpl::SyncSelectionIfRequired() {
4447 WebFrame* frame = webview()->focusedFrame();
4448 if (!frame)
4449 return;
4450
4451 base::string16 text;
4452 size_t offset;
4453 gfx::Range range;
4454 #if defined(ENABLE_PLUGINS)
4455 if (focused_pepper_plugin_) {
4456 focused_pepper_plugin_->GetSurroundingText(&text, &range);
4457 offset = 0; // Pepper API does not support offset reporting.
4458 // TODO(kinaba): cut as needed.
4459 } else
4460 #endif
4461 {
4462 size_t location, length;
4463 if (!webview()->caretOrSelectionRange(&location, &length))
4464 return;
4465
4466 range = gfx::Range(location, location + length);
4467
4468 if (webview()->textInputInfo().type != blink::WebTextInputTypeNone) {
4469 // If current focused element is editable, we will send 100 more chars
4470 // before and after selection. It is for input method surrounding text
4471 // feature.
4472 if (location > kExtraCharsBeforeAndAfterSelection)
4473 offset = location - kExtraCharsBeforeAndAfterSelection;
4474 else
4475 offset = 0;
4476 length = location + length - offset + kExtraCharsBeforeAndAfterSelection;
4477 WebRange webrange = WebRange::fromDocumentRange(frame, offset, length);
4478 if (!webrange.isNull())
4479 text = WebRange::fromDocumentRange(frame, offset, length).toPlainText();
4480 } else {
4481 offset = location;
4482 text = frame->selectionAsText();
4483 // http://crbug.com/101435
4484 // In some case, frame->selectionAsText() returned text's length is not
4485 // equal to the length returned from webview()->caretOrSelectionRange().
4486 // So we have to set the range according to text.length().
4487 range.set_end(range.start() + text.length());
4488 }
4489 }
4490
4491 // Sometimes we get repeated didChangeSelection calls from webkit when
4492 // the selection hasn't actually changed. We don't want to report these
4493 // because it will cause us to continually claim the X clipboard.
4494 if (selection_text_offset_ != offset ||
4495 selection_range_ != range ||
4496 selection_text_ != text) {
4497 selection_text_ = text;
4498 selection_text_offset_ = offset;
4499 selection_range_ = range;
4500 Send(new ViewHostMsg_SelectionChanged(routing_id_, text, offset, range));
4501 }
4502 UpdateSelectionBounds();
4503 }
4504
GetAlternateErrorPageURL(const GURL & failed_url,ErrorPageType error_type)4505 GURL RenderViewImpl::GetAlternateErrorPageURL(const GURL& failed_url,
4506 ErrorPageType error_type) {
4507 if (failed_url.SchemeIsSecure()) {
4508 // If the URL that failed was secure, then the embedding web page was not
4509 // expecting a network attacker to be able to manipulate its contents. As
4510 // we fetch alternate error pages over HTTP, we would be allowing a network
4511 // attacker to manipulate the contents of the response if we tried to use
4512 // the link doctor here.
4513 return GURL();
4514 }
4515
4516 // Grab the base URL from the browser process.
4517 if (!alternate_error_page_url_.is_valid())
4518 return GURL();
4519
4520 // Strip query params from the failed URL.
4521 GURL::Replacements remove_params;
4522 remove_params.ClearUsername();
4523 remove_params.ClearPassword();
4524 remove_params.ClearQuery();
4525 remove_params.ClearRef();
4526 const GURL url_to_send = failed_url.ReplaceComponents(remove_params);
4527 // TODO(yuusuke): change to net::FormatUrl when link doctor
4528 // becomes unicode-capable.
4529 std::string spec_to_send = url_to_send.spec();
4530 // Notify link doctor of the url truncation by sending of "?" at the end.
4531 if (failed_url.has_query())
4532 spec_to_send.append("?");
4533
4534 // Construct the query params to send to link doctor.
4535 std::string params(alternate_error_page_url_.query());
4536 params.append("&url=");
4537 params.append(net::EscapeQueryParamValue(spec_to_send, true));
4538 params.append("&sourceid=chrome");
4539 params.append("&error=");
4540 switch (error_type) {
4541 case DNS_ERROR:
4542 params.append("dnserror");
4543 break;
4544
4545 case HTTP_404:
4546 params.append("http404");
4547 break;
4548
4549 case CONNECTION_ERROR:
4550 params.append("connectionfailure");
4551 break;
4552
4553 default:
4554 NOTREACHED() << "unknown ErrorPageType";
4555 }
4556
4557 // OK, build the final url to return.
4558 GURL::Replacements link_doctor_params;
4559 link_doctor_params.SetQueryStr(params);
4560 GURL url = alternate_error_page_url_.ReplaceComponents(link_doctor_params);
4561 return url;
4562 }
4563
GetLoadingUrl(blink::WebFrame * frame) const4564 GURL RenderViewImpl::GetLoadingUrl(blink::WebFrame* frame) const {
4565 WebDataSource* ds = frame->dataSource();
4566 if (ds->hasUnreachableURL())
4567 return ds->unreachableURL();
4568
4569 const WebURLRequest& request = ds->request();
4570 return request.url();
4571 }
4572
GetWebPluginFromPluginDocument()4573 blink::WebPlugin* RenderViewImpl::GetWebPluginFromPluginDocument() {
4574 return webview()->mainFrame()->document().to<WebPluginDocument>().plugin();
4575 }
4576
OnFind(int request_id,const base::string16 & search_text,const WebFindOptions & options)4577 void RenderViewImpl::OnFind(int request_id,
4578 const base::string16& search_text,
4579 const WebFindOptions& options) {
4580 WebFrame* main_frame = webview()->mainFrame();
4581
4582 // Check if the plugin still exists in the document.
4583 if (main_frame->document().isPluginDocument() &&
4584 GetWebPluginFromPluginDocument()) {
4585 if (options.findNext) {
4586 // Just navigate back/forward.
4587 GetWebPluginFromPluginDocument()->selectFindResult(options.forward);
4588 } else {
4589 if (!GetWebPluginFromPluginDocument()->startFind(
4590 search_text, options.matchCase, request_id)) {
4591 // Send "no results".
4592 SendFindReply(request_id, 0, 0, gfx::Rect(), true);
4593 }
4594 }
4595 return;
4596 }
4597
4598 WebFrame* frame_after_main = main_frame->traverseNext(true);
4599 WebFrame* focused_frame = webview()->focusedFrame();
4600 WebFrame* search_frame = focused_frame; // start searching focused frame.
4601
4602 bool multi_frame = (frame_after_main != main_frame);
4603
4604 // If we have multiple frames, we don't want to wrap the search within the
4605 // frame, so we check here if we only have main_frame in the chain.
4606 bool wrap_within_frame = !multi_frame;
4607
4608 WebRect selection_rect;
4609 bool result = false;
4610
4611 // If something is selected when we start searching it means we cannot just
4612 // increment the current match ordinal; we need to re-generate it.
4613 WebRange current_selection = focused_frame->selectionRange();
4614
4615 do {
4616 result = search_frame->find(
4617 request_id, search_text, options, wrap_within_frame, &selection_rect);
4618
4619 if (!result) {
4620 // don't leave text selected as you move to the next frame.
4621 search_frame->executeCommand(WebString::fromUTF8("Unselect"),
4622 GetFocusedNode());
4623
4624 // Find the next frame, but skip the invisible ones.
4625 do {
4626 // What is the next frame to search? (we might be going backwards). Note
4627 // that we specify wrap=true so that search_frame never becomes NULL.
4628 search_frame = options.forward ?
4629 search_frame->traverseNext(true) :
4630 search_frame->traversePrevious(true);
4631 } while (!search_frame->hasVisibleContent() &&
4632 search_frame != focused_frame);
4633
4634 // Make sure selection doesn't affect the search operation in new frame.
4635 search_frame->executeCommand(WebString::fromUTF8("Unselect"),
4636 GetFocusedNode());
4637
4638 // If we have multiple frames and we have wrapped back around to the
4639 // focused frame, we need to search it once more allowing wrap within
4640 // the frame, otherwise it will report 'no match' if the focused frame has
4641 // reported matches, but no frames after the focused_frame contain a
4642 // match for the search word(s).
4643 if (multi_frame && search_frame == focused_frame) {
4644 result = search_frame->find(
4645 request_id, search_text, options, true, // Force wrapping.
4646 &selection_rect);
4647 }
4648 }
4649
4650 webview()->setFocusedFrame(search_frame);
4651 } while (!result && search_frame != focused_frame);
4652
4653 if (options.findNext && current_selection.isNull()) {
4654 // Force the main_frame to report the actual count.
4655 main_frame->increaseMatchCount(0, request_id);
4656 } else {
4657 // If nothing is found, set result to "0 of 0", otherwise, set it to
4658 // "-1 of 1" to indicate that we found at least one item, but we don't know
4659 // yet what is active.
4660 int ordinal = result ? -1 : 0; // -1 here means, we might know more later.
4661 int match_count = result ? 1 : 0; // 1 here means possibly more coming.
4662
4663 // If we find no matches then this will be our last status update.
4664 // Otherwise the scoping effort will send more results.
4665 bool final_status_update = !result;
4666
4667 SendFindReply(request_id, match_count, ordinal, selection_rect,
4668 final_status_update);
4669
4670 // Scoping effort begins, starting with the mainframe.
4671 search_frame = main_frame;
4672
4673 main_frame->resetMatchCount();
4674
4675 do {
4676 // Cancel all old scoping requests before starting a new one.
4677 search_frame->cancelPendingScopingEffort();
4678
4679 // We don't start another scoping effort unless at least one match has
4680 // been found.
4681 if (result) {
4682 // Start new scoping request. If the scoping function determines that it
4683 // needs to scope, it will defer until later.
4684 search_frame->scopeStringMatches(request_id,
4685 search_text,
4686 options,
4687 true); // reset the tickmarks
4688 }
4689
4690 // Iterate to the next frame. The frame will not necessarily scope, for
4691 // example if it is not visible.
4692 search_frame = search_frame->traverseNext(true);
4693 } while (search_frame != main_frame);
4694 }
4695 }
4696
OnStopFinding(StopFindAction action)4697 void RenderViewImpl::OnStopFinding(StopFindAction action) {
4698 WebView* view = webview();
4699 if (!view)
4700 return;
4701
4702 WebDocument doc = view->mainFrame()->document();
4703 if (doc.isPluginDocument() && GetWebPluginFromPluginDocument()) {
4704 GetWebPluginFromPluginDocument()->stopFind();
4705 return;
4706 }
4707
4708 bool clear_selection = action == STOP_FIND_ACTION_CLEAR_SELECTION;
4709 if (clear_selection) {
4710 view->focusedFrame()->executeCommand(WebString::fromUTF8("Unselect"),
4711 GetFocusedNode());
4712 }
4713
4714 WebFrame* frame = view->mainFrame();
4715 while (frame) {
4716 frame->stopFinding(clear_selection);
4717 frame = frame->traverseNext(false);
4718 }
4719
4720 if (action == STOP_FIND_ACTION_ACTIVATE_SELECTION) {
4721 WebFrame* focused_frame = view->focusedFrame();
4722 if (focused_frame) {
4723 WebDocument doc = focused_frame->document();
4724 if (!doc.isNull()) {
4725 WebNode node = doc.focusedNode();
4726 if (!node.isNull())
4727 node.simulateClick();
4728 }
4729 }
4730 }
4731 }
4732
4733 #if defined(OS_ANDROID)
OnActivateNearestFindResult(int request_id,float x,float y)4734 void RenderViewImpl::OnActivateNearestFindResult(int request_id,
4735 float x, float y) {
4736 if (!webview())
4737 return;
4738
4739 WebFrame* main_frame = webview()->mainFrame();
4740 WebRect selection_rect;
4741 int ordinal = main_frame->selectNearestFindMatch(WebFloatPoint(x, y),
4742 &selection_rect);
4743 if (ordinal == -1) {
4744 // Something went wrong, so send a no-op reply (force the main_frame to
4745 // report the current match count) in case the host is waiting for a
4746 // response due to rate-limiting).
4747 main_frame->increaseMatchCount(0, request_id);
4748 return;
4749 }
4750
4751 SendFindReply(request_id,
4752 -1 /* number_of_matches */,
4753 ordinal,
4754 selection_rect,
4755 true /* final_update */);
4756 }
4757
OnFindMatchRects(int current_version)4758 void RenderViewImpl::OnFindMatchRects(int current_version) {
4759 if (!webview())
4760 return;
4761
4762 WebFrame* main_frame = webview()->mainFrame();
4763 std::vector<gfx::RectF> match_rects;
4764
4765 int rects_version = main_frame->findMatchMarkersVersion();
4766 if (current_version != rects_version) {
4767 WebVector<WebFloatRect> web_match_rects;
4768 main_frame->findMatchRects(web_match_rects);
4769 match_rects.reserve(web_match_rects.size());
4770 for (size_t i = 0; i < web_match_rects.size(); ++i)
4771 match_rects.push_back(gfx::RectF(web_match_rects[i]));
4772 }
4773
4774 gfx::RectF active_rect = main_frame->activeFindMatchRect();
4775 Send(new ViewHostMsg_FindMatchRects_Reply(routing_id_,
4776 rects_version,
4777 match_rects,
4778 active_rect));
4779 }
4780 #endif
4781
OnZoom(PageZoom zoom)4782 void RenderViewImpl::OnZoom(PageZoom zoom) {
4783 if (!webview()) // Not sure if this can happen, but no harm in being safe.
4784 return;
4785
4786 webview()->hidePopups();
4787
4788 double old_zoom_level = webview()->zoomLevel();
4789 double zoom_level;
4790 if (zoom == PAGE_ZOOM_RESET) {
4791 zoom_level = 0;
4792 } else if (static_cast<int>(old_zoom_level) == old_zoom_level) {
4793 // Previous zoom level is a whole number, so just increment/decrement.
4794 zoom_level = old_zoom_level + zoom;
4795 } else {
4796 // Either the user hit the zoom factor limit and thus the zoom level is now
4797 // not a whole number, or a plugin changed it to a custom value. We want
4798 // to go to the next whole number so that the user can always get back to
4799 // 100% with the keyboard/menu.
4800 if ((old_zoom_level > 1 && zoom > 0) ||
4801 (old_zoom_level < 1 && zoom < 0)) {
4802 zoom_level = static_cast<int>(old_zoom_level + zoom);
4803 } else {
4804 // We're going towards 100%, so first go to the next whole number.
4805 zoom_level = static_cast<int>(old_zoom_level);
4806 }
4807 }
4808 webview()->setZoomLevel(zoom_level);
4809 zoomLevelChanged();
4810 }
4811
OnZoomFactor(PageZoom zoom,int zoom_center_x,int zoom_center_y)4812 void RenderViewImpl::OnZoomFactor(PageZoom zoom, int zoom_center_x,
4813 int zoom_center_y) {
4814 ZoomFactorHelper(zoom, zoom_center_x, zoom_center_y,
4815 kScalingIncrementForGesture);
4816 }
4817
ZoomFactorHelper(PageZoom zoom,int zoom_center_x,int zoom_center_y,float scaling_increment)4818 void RenderViewImpl::ZoomFactorHelper(PageZoom zoom,
4819 int zoom_center_x,
4820 int zoom_center_y,
4821 float scaling_increment) {
4822 if (!webview()) // Not sure if this can happen, but no harm in being safe.
4823 return;
4824
4825 double old_page_scale_factor = webview()->pageScaleFactor();
4826 double page_scale_factor;
4827 if (zoom == PAGE_ZOOM_RESET) {
4828 page_scale_factor = 1.0;
4829 } else {
4830 page_scale_factor = old_page_scale_factor +
4831 (zoom > 0 ? scaling_increment : -scaling_increment);
4832 }
4833 if (page_scale_factor > 0) {
4834 webview()->setPageScaleFactor(page_scale_factor,
4835 WebPoint(zoom_center_x, zoom_center_y));
4836 }
4837 }
4838
OnSetZoomLevel(double zoom_level)4839 void RenderViewImpl::OnSetZoomLevel(double zoom_level) {
4840 webview()->hidePopups();
4841 webview()->setZoomLevel(zoom_level);
4842 zoomLevelChanged();
4843 }
4844
OnSetZoomLevelForLoadingURL(const GURL & url,double zoom_level)4845 void RenderViewImpl::OnSetZoomLevelForLoadingURL(const GURL& url,
4846 double zoom_level) {
4847 #if !defined(OS_ANDROID)
4848 // On Android, page zoom isn't used, and in case of WebView, text zoom is used
4849 // for legacy WebView text scaling emulation. Thus, the code that resets
4850 // the zoom level from this map will be effectively resetting text zoom level.
4851 host_zoom_levels_[url] = zoom_level;
4852 #endif
4853 }
4854
OnSetPageEncoding(const std::string & encoding_name)4855 void RenderViewImpl::OnSetPageEncoding(const std::string& encoding_name) {
4856 webview()->setPageEncoding(WebString::fromUTF8(encoding_name));
4857 }
4858
OnResetPageEncodingToDefault()4859 void RenderViewImpl::OnResetPageEncodingToDefault() {
4860 WebString no_encoding;
4861 webview()->setPageEncoding(no_encoding);
4862 }
4863
GetChildFrame(const base::string16 & xpath) const4864 WebFrame* RenderViewImpl::GetChildFrame(const base::string16& xpath) const {
4865 if (xpath.empty())
4866 return webview()->mainFrame();
4867
4868 // xpath string can represent a frame deep down the tree (across multiple
4869 // frame DOMs).
4870 // Example, /html/body/table/tbody/tr/td/iframe\n/frameset/frame[0]
4871 // should break into 2 xpaths
4872 // /html/body/table/tbody/tr/td/iframe & /frameset/frame[0]
4873 std::vector<base::string16> xpaths;
4874 base::SplitString(xpath, '\n', &xpaths);
4875
4876 WebFrame* frame = webview()->mainFrame();
4877 for (std::vector<base::string16>::const_iterator i = xpaths.begin();
4878 frame && i != xpaths.end(); ++i) {
4879 frame = frame->findChildByExpression(*i);
4880 }
4881
4882 return frame;
4883 }
4884
OnScriptEvalRequest(const base::string16 & frame_xpath,const base::string16 & jscript,int id,bool notify_result)4885 void RenderViewImpl::OnScriptEvalRequest(const base::string16& frame_xpath,
4886 const base::string16& jscript,
4887 int id,
4888 bool notify_result) {
4889 TRACE_EVENT_INSTANT0("test_tracing", "OnScriptEvalRequest",
4890 TRACE_EVENT_SCOPE_THREAD);
4891 EvaluateScript(frame_xpath, jscript, id, notify_result);
4892 }
4893
OnPostMessageEvent(const ViewMsg_PostMessage_Params & params)4894 void RenderViewImpl::OnPostMessageEvent(
4895 const ViewMsg_PostMessage_Params& params) {
4896 // TODO(nasko): Support sending to subframes.
4897 WebFrame* frame = webview()->mainFrame();
4898
4899 // Find the source frame if it exists.
4900 WebFrame* source_frame = NULL;
4901 if (params.source_routing_id != MSG_ROUTING_NONE) {
4902 RenderViewImpl* source_view = FromRoutingID(params.source_routing_id);
4903 if (source_view)
4904 source_frame = source_view->webview()->mainFrame();
4905 }
4906
4907 // If the message contained MessagePorts, create the corresponding endpoints.
4908 DCHECK_EQ(params.message_port_ids.size(), params.new_routing_ids.size());
4909 blink::WebMessagePortChannelArray channels(params.message_port_ids.size());
4910 for (size_t i = 0;
4911 i < params.message_port_ids.size() && i < params.new_routing_ids.size();
4912 ++i) {
4913 channels[i] =
4914 new WebMessagePortChannelImpl(params.new_routing_ids[i],
4915 params.message_port_ids[i],
4916 base::MessageLoopProxy::current().get());
4917 }
4918
4919 // Create an event with the message. The final parameter to initMessageEvent
4920 // is the last event ID, which is not used with postMessage.
4921 WebDOMEvent event = frame->document().createEvent("MessageEvent");
4922 WebDOMMessageEvent msg_event = event.to<WebDOMMessageEvent>();
4923 msg_event.initMessageEvent("message",
4924 // |canBubble| and |cancellable| are always false
4925 false, false,
4926 WebSerializedScriptValue::fromString(params.data),
4927 params.source_origin, source_frame, "", channels);
4928
4929 // We must pass in the target_origin to do the security check on this side,
4930 // since it may have changed since the original postMessage call was made.
4931 WebSecurityOrigin target_origin;
4932 if (!params.target_origin.empty()) {
4933 target_origin =
4934 WebSecurityOrigin::createFromString(WebString(params.target_origin));
4935 }
4936 frame->dispatchMessageEventWithOriginCheck(target_origin, msg_event);
4937 }
4938
OnCSSInsertRequest(const base::string16 & frame_xpath,const std::string & css)4939 void RenderViewImpl::OnCSSInsertRequest(const base::string16& frame_xpath,
4940 const std::string& css) {
4941 WebFrame* frame = GetChildFrame(frame_xpath);
4942 if (!frame)
4943 return;
4944
4945 frame->document().insertUserStyleSheet(
4946 WebString::fromUTF8(css),
4947 WebDocument::UserStyleAuthorLevel);
4948 }
4949
OnAllowBindings(int enabled_bindings_flags)4950 void RenderViewImpl::OnAllowBindings(int enabled_bindings_flags) {
4951 if ((enabled_bindings_flags & BINDINGS_POLICY_WEB_UI) &&
4952 !(enabled_bindings_ & BINDINGS_POLICY_WEB_UI)) {
4953 // WebUI uses <dialog> which is not yet enabled by default in Chrome.
4954 WebRuntimeFeatures::enableDialogElement(true);
4955
4956 RenderThread::Get()->RegisterExtension(WebUIExtension::Get());
4957 new WebUIExtensionData(this);
4958 }
4959
4960 enabled_bindings_ |= enabled_bindings_flags;
4961
4962 // Keep track of the total bindings accumulated in this process.
4963 RenderProcess::current()->AddBindings(enabled_bindings_flags);
4964 }
4965
OnDragTargetDragEnter(const DropData & drop_data,const gfx::Point & client_point,const gfx::Point & screen_point,WebDragOperationsMask ops,int key_modifiers)4966 void RenderViewImpl::OnDragTargetDragEnter(const DropData& drop_data,
4967 const gfx::Point& client_point,
4968 const gfx::Point& screen_point,
4969 WebDragOperationsMask ops,
4970 int key_modifiers) {
4971 WebDragOperation operation = webview()->dragTargetDragEnter(
4972 DropDataToWebDragData(drop_data),
4973 client_point,
4974 screen_point,
4975 ops,
4976 key_modifiers);
4977
4978 Send(new DragHostMsg_UpdateDragCursor(routing_id_, operation));
4979 }
4980
OnDragTargetDragOver(const gfx::Point & client_point,const gfx::Point & screen_point,WebDragOperationsMask ops,int key_modifiers)4981 void RenderViewImpl::OnDragTargetDragOver(const gfx::Point& client_point,
4982 const gfx::Point& screen_point,
4983 WebDragOperationsMask ops,
4984 int key_modifiers) {
4985 WebDragOperation operation = webview()->dragTargetDragOver(
4986 client_point,
4987 screen_point,
4988 ops,
4989 key_modifiers);
4990
4991 Send(new DragHostMsg_UpdateDragCursor(routing_id_, operation));
4992 }
4993
OnDragTargetDragLeave()4994 void RenderViewImpl::OnDragTargetDragLeave() {
4995 webview()->dragTargetDragLeave();
4996 }
4997
OnDragTargetDrop(const gfx::Point & client_point,const gfx::Point & screen_point,int key_modifiers)4998 void RenderViewImpl::OnDragTargetDrop(const gfx::Point& client_point,
4999 const gfx::Point& screen_point,
5000 int key_modifiers) {
5001 webview()->dragTargetDrop(client_point, screen_point, key_modifiers);
5002
5003 Send(new DragHostMsg_TargetDrop_ACK(routing_id_));
5004 }
5005
OnDragSourceEndedOrMoved(const gfx::Point & client_point,const gfx::Point & screen_point,bool ended,WebDragOperation op)5006 void RenderViewImpl::OnDragSourceEndedOrMoved(const gfx::Point& client_point,
5007 const gfx::Point& screen_point,
5008 bool ended,
5009 WebDragOperation op) {
5010 if (ended) {
5011 webview()->dragSourceEndedAt(client_point, screen_point, op);
5012 } else {
5013 webview()->dragSourceMovedTo(client_point, screen_point, op);
5014 }
5015 }
5016
OnDragSourceSystemDragEnded()5017 void RenderViewImpl::OnDragSourceSystemDragEnded() {
5018 webview()->dragSourceSystemDragEnded();
5019 }
5020
OnUpdateWebPreferences(const WebPreferences & prefs)5021 void RenderViewImpl::OnUpdateWebPreferences(const WebPreferences& prefs) {
5022 webkit_preferences_ = prefs;
5023 ApplyWebPreferences(webkit_preferences_, webview());
5024 }
5025
OnUpdateTimezone()5026 void RenderViewImpl::OnUpdateTimezone() {
5027 if (webview())
5028 NotifyTimezoneChange(webview()->mainFrame());
5029 }
5030
OnSetAltErrorPageURL(const GURL & url)5031 void RenderViewImpl::OnSetAltErrorPageURL(const GURL& url) {
5032 alternate_error_page_url_ = url;
5033 }
5034
OnCustomContextMenuAction(const CustomContextMenuContext & custom_context,unsigned action)5035 void RenderViewImpl::OnCustomContextMenuAction(
5036 const CustomContextMenuContext& custom_context,
5037 unsigned action) {
5038 if (custom_context.request_id) {
5039 // External context menu request, look in our map.
5040 ContextMenuClient* client =
5041 pending_context_menus_.Lookup(custom_context.request_id);
5042 if (client)
5043 client->OnMenuAction(custom_context.request_id, action);
5044 } else {
5045 // Internal request, forward to WebKit.
5046 webview()->performCustomContextMenuAction(action);
5047 }
5048 }
5049
OnEnumerateDirectoryResponse(int id,const std::vector<base::FilePath> & paths)5050 void RenderViewImpl::OnEnumerateDirectoryResponse(
5051 int id,
5052 const std::vector<base::FilePath>& paths) {
5053 if (!enumeration_completions_[id])
5054 return;
5055
5056 WebVector<WebString> ws_file_names(paths.size());
5057 for (size_t i = 0; i < paths.size(); ++i)
5058 ws_file_names[i] = paths[i].AsUTF16Unsafe();
5059
5060 enumeration_completions_[id]->didChooseFile(ws_file_names);
5061 enumeration_completions_.erase(id);
5062 }
5063
OnFileChooserResponse(const std::vector<ui::SelectedFileInfo> & files)5064 void RenderViewImpl::OnFileChooserResponse(
5065 const std::vector<ui::SelectedFileInfo>& files) {
5066 // This could happen if we navigated to a different page before the user
5067 // closed the chooser.
5068 if (file_chooser_completions_.empty())
5069 return;
5070
5071 // Convert Chrome's SelectedFileInfo list to WebKit's.
5072 WebVector<WebFileChooserCompletion::SelectedFileInfo> selected_files(
5073 files.size());
5074 for (size_t i = 0; i < files.size(); ++i) {
5075 WebFileChooserCompletion::SelectedFileInfo selected_file;
5076 selected_file.path = files[i].local_path.AsUTF16Unsafe();
5077 selected_file.displayName =
5078 base::FilePath(files[i].display_name).AsUTF16Unsafe();
5079 selected_files[i] = selected_file;
5080 }
5081
5082 if (file_chooser_completions_.front()->completion)
5083 file_chooser_completions_.front()->completion->didChooseFile(
5084 selected_files);
5085 file_chooser_completions_.pop_front();
5086
5087 // If there are more pending file chooser requests, schedule one now.
5088 if (!file_chooser_completions_.empty()) {
5089 Send(new ViewHostMsg_RunFileChooser(routing_id_,
5090 file_chooser_completions_.front()->params));
5091 }
5092 }
5093
OnEnableAutoResize(const gfx::Size & min_size,const gfx::Size & max_size)5094 void RenderViewImpl::OnEnableAutoResize(const gfx::Size& min_size,
5095 const gfx::Size& max_size) {
5096 DCHECK(disable_scrollbars_size_limit_.IsEmpty());
5097 if (!webview())
5098 return;
5099 auto_resize_mode_ = true;
5100 webview()->enableAutoResizeMode(min_size, max_size);
5101 }
5102
OnDisableAutoResize(const gfx::Size & new_size)5103 void RenderViewImpl::OnDisableAutoResize(const gfx::Size& new_size) {
5104 DCHECK(disable_scrollbars_size_limit_.IsEmpty());
5105 if (!webview())
5106 return;
5107 auto_resize_mode_ = false;
5108 webview()->disableAutoResizeMode();
5109
5110 if (!new_size.IsEmpty()) {
5111 Resize(new_size,
5112 physical_backing_size_,
5113 overdraw_bottom_height_,
5114 resizer_rect_,
5115 is_fullscreen_,
5116 NO_RESIZE_ACK);
5117 }
5118 }
5119
OnEnablePreferredSizeChangedMode()5120 void RenderViewImpl::OnEnablePreferredSizeChangedMode() {
5121 if (send_preferred_size_changes_)
5122 return;
5123 send_preferred_size_changes_ = true;
5124
5125 // Start off with an initial preferred size notification (in case
5126 // |didUpdateLayout| was already called).
5127 didUpdateLayout();
5128 }
5129
OnDisableScrollbarsForSmallWindows(const gfx::Size & disable_scrollbar_size_limit)5130 void RenderViewImpl::OnDisableScrollbarsForSmallWindows(
5131 const gfx::Size& disable_scrollbar_size_limit) {
5132 disable_scrollbars_size_limit_ = disable_scrollbar_size_limit;
5133 }
5134
OnSetRendererPrefs(const RendererPreferences & renderer_prefs)5135 void RenderViewImpl::OnSetRendererPrefs(
5136 const RendererPreferences& renderer_prefs) {
5137 double old_zoom_level = renderer_preferences_.default_zoom_level;
5138 renderer_preferences_ = renderer_prefs;
5139 UpdateFontRenderingFromRendererPrefs();
5140
5141 #if defined(USE_DEFAULT_RENDER_THEME) || defined(TOOLKIT_GTK)
5142 if (renderer_prefs.use_custom_colors) {
5143 WebColorName name = blink::WebColorWebkitFocusRingColor;
5144 blink::setNamedColors(&name, &renderer_prefs.focus_ring_color, 1);
5145 blink::setCaretBlinkInterval(renderer_prefs.caret_blink_interval);
5146 #if defined(TOOLKIT_GTK)
5147 ui::NativeTheme::instance()->SetScrollbarColors(
5148 renderer_prefs.thumb_inactive_color,
5149 renderer_prefs.thumb_active_color,
5150 renderer_prefs.track_color);
5151 #endif // defined(TOOLKIT_GTK)
5152
5153 if (webview()) {
5154 webview()->setSelectionColors(
5155 renderer_prefs.active_selection_bg_color,
5156 renderer_prefs.active_selection_fg_color,
5157 renderer_prefs.inactive_selection_bg_color,
5158 renderer_prefs.inactive_selection_fg_color);
5159 webview()->themeChanged();
5160 }
5161 }
5162 #endif // defined(USE_DEFAULT_RENDER_THEME) || defined(TOOLKIT_GTK)
5163
5164 if (RenderThreadImpl::current()) // Will be NULL during unit tests.
5165 RenderThreadImpl::current()->SetFlingCurveParameters(
5166 renderer_prefs.touchpad_fling_profile,
5167 renderer_prefs.touchscreen_fling_profile);
5168
5169 // If the zoom level for this page matches the old zoom default, and this
5170 // is not a plugin, update the zoom level to match the new default.
5171 if (webview() && !webview()->mainFrame()->document().isPluginDocument() &&
5172 !ZoomValuesEqual(old_zoom_level,
5173 renderer_preferences_.default_zoom_level) &&
5174 ZoomValuesEqual(webview()->zoomLevel(), old_zoom_level)) {
5175 webview()->setZoomLevel(renderer_preferences_.default_zoom_level);
5176 zoomLevelChanged();
5177 }
5178 }
5179
OnMediaPlayerActionAt(const gfx::Point & location,const WebMediaPlayerAction & action)5180 void RenderViewImpl::OnMediaPlayerActionAt(const gfx::Point& location,
5181 const WebMediaPlayerAction& action) {
5182 if (webview())
5183 webview()->performMediaPlayerAction(action, location);
5184 }
5185
OnOrientationChangeEvent(int orientation)5186 void RenderViewImpl::OnOrientationChangeEvent(int orientation) {
5187 // Screen has rotated. 0 = default (portrait), 90 = one turn right, and so on.
5188 FOR_EACH_OBSERVER(RenderViewObserver,
5189 observers_,
5190 OrientationChangeEvent(orientation));
5191 webview()->mainFrame()->sendOrientationChangeEvent(orientation);
5192 }
5193
OnPluginActionAt(const gfx::Point & location,const WebPluginAction & action)5194 void RenderViewImpl::OnPluginActionAt(const gfx::Point& location,
5195 const WebPluginAction& action) {
5196 if (webview())
5197 webview()->performPluginAction(action, location);
5198 }
5199
OnGetAllSavableResourceLinksForCurrentPage(const GURL & page_url)5200 void RenderViewImpl::OnGetAllSavableResourceLinksForCurrentPage(
5201 const GURL& page_url) {
5202 // Prepare list to storage all savable resource links.
5203 std::vector<GURL> resources_list;
5204 std::vector<GURL> referrer_urls_list;
5205 std::vector<blink::WebReferrerPolicy> referrer_policies_list;
5206 std::vector<GURL> frames_list;
5207 SavableResourcesResult result(&resources_list,
5208 &referrer_urls_list,
5209 &referrer_policies_list,
5210 &frames_list);
5211
5212 // webkit/ doesn't know about Referrer.
5213 if (!GetAllSavableResourceLinksForCurrentPage(
5214 webview(),
5215 page_url,
5216 &result,
5217 const_cast<const char**>(GetSavableSchemes()))) {
5218 // If something is wrong when collecting all savable resource links,
5219 // send empty list to embedder(browser) to tell it failed.
5220 referrer_urls_list.clear();
5221 referrer_policies_list.clear();
5222 resources_list.clear();
5223 frames_list.clear();
5224 }
5225
5226 std::vector<Referrer> referrers_list;
5227 CHECK_EQ(referrer_urls_list.size(), referrer_policies_list.size());
5228 for (unsigned i = 0; i < referrer_urls_list.size(); ++i) {
5229 referrers_list.push_back(
5230 Referrer(referrer_urls_list[i], referrer_policies_list[i]));
5231 }
5232
5233 // Send result of all savable resource links to embedder.
5234 Send(new ViewHostMsg_SendCurrentPageAllSavableResourceLinks(routing_id(),
5235 resources_list,
5236 referrers_list,
5237 frames_list));
5238 }
5239
OnGetSerializedHtmlDataForCurrentPageWithLocalLinks(const std::vector<GURL> & links,const std::vector<base::FilePath> & local_paths,const base::FilePath & local_directory_name)5240 void RenderViewImpl::OnGetSerializedHtmlDataForCurrentPageWithLocalLinks(
5241 const std::vector<GURL>& links,
5242 const std::vector<base::FilePath>& local_paths,
5243 const base::FilePath& local_directory_name) {
5244
5245 // Convert std::vector of GURLs to WebVector<WebURL>
5246 WebVector<WebURL> weburl_links(links);
5247
5248 // Convert std::vector of base::FilePath to WebVector<WebString>
5249 WebVector<WebString> webstring_paths(local_paths.size());
5250 for (size_t i = 0; i < local_paths.size(); i++)
5251 webstring_paths[i] = local_paths[i].AsUTF16Unsafe();
5252
5253 WebPageSerializer::serialize(webview()->mainFrame(), true, this, weburl_links,
5254 webstring_paths,
5255 local_directory_name.AsUTF16Unsafe());
5256 }
5257
OnShouldClose()5258 void RenderViewImpl::OnShouldClose() {
5259 base::TimeTicks before_unload_start_time = base::TimeTicks::Now();
5260 bool should_close = webview()->dispatchBeforeUnloadEvent();
5261 base::TimeTicks before_unload_end_time = base::TimeTicks::Now();
5262 Send(new ViewHostMsg_ShouldClose_ACK(routing_id_, should_close,
5263 before_unload_start_time,
5264 before_unload_end_time));
5265 }
5266
OnSuppressDialogsUntilSwapOut()5267 void RenderViewImpl::OnSuppressDialogsUntilSwapOut() {
5268 // Don't show any more dialogs until we finish OnSwapOut.
5269 suppress_dialogs_until_swap_out_ = true;
5270 }
5271
OnSwapOut()5272 void RenderViewImpl::OnSwapOut() {
5273 // Only run unload if we're not swapped out yet, but send the ack either way.
5274 if (!is_swapped_out_) {
5275 // Swap this RenderView out so the tab can navigate to a page rendered by a
5276 // different process. This involves running the unload handler and clearing
5277 // the page. Once WasSwappedOut is called, we also allow this process to
5278 // exit if there are no other active RenderViews in it.
5279
5280 // Send an UpdateState message before we get swapped out.
5281 SyncNavigationState();
5282
5283 // Synchronously run the unload handler before sending the ACK.
5284 webview()->dispatchUnloadEvent();
5285
5286 // Swap out and stop sending any IPC messages that are not ACKs.
5287 SetSwappedOut(true);
5288
5289 // Now that we're swapped out and filtering IPC messages, stop loading to
5290 // ensure that no other in-progress navigation continues. We do this here
5291 // to avoid sending a DidStopLoading message to the browser process.
5292 OnStop();
5293
5294 // Replace the page with a blank dummy URL. The unload handler will not be
5295 // run a second time, thanks to a check in FrameLoader::stopLoading.
5296 // TODO(creis): Need to add a better way to do this that avoids running the
5297 // beforeunload handler. For now, we just run it a second time silently.
5298 NavigateToSwappedOutURL(webview()->mainFrame());
5299
5300 // Let WebKit know that this view is hidden so it can drop resources and
5301 // stop compositing.
5302 webview()->setVisibilityState(blink::WebPageVisibilityStateHidden, false);
5303 }
5304
5305 // It is now safe to show modal dialogs again.
5306 suppress_dialogs_until_swap_out_ = false;
5307
5308 Send(new ViewHostMsg_SwapOut_ACK(routing_id_));
5309 }
5310
NavigateToSwappedOutURL(blink::WebFrame * frame)5311 void RenderViewImpl::NavigateToSwappedOutURL(blink::WebFrame* frame) {
5312 // We use loadRequest instead of loadHTMLString because the former commits
5313 // synchronously. Otherwise a new navigation can interrupt the navigation
5314 // to kSwappedOutURL. If that happens to be to the page we had been
5315 // showing, then WebKit will never send a commit and we'll be left spinning.
5316 CHECK(is_swapped_out_);
5317 GURL swappedOutURL(kSwappedOutURL);
5318 WebURLRequest request(swappedOutURL);
5319 frame->loadRequest(request);
5320 }
5321
OnClosePage()5322 void RenderViewImpl::OnClosePage() {
5323 FOR_EACH_OBSERVER(RenderViewObserver, observers_, ClosePage());
5324 // TODO(creis): We'd rather use webview()->Close() here, but that currently
5325 // sets the WebView's delegate_ to NULL, preventing any JavaScript dialogs
5326 // in the onunload handler from appearing. For now, we're bypassing that and
5327 // calling the FrameLoader's CloseURL method directly. This should be
5328 // revisited to avoid having two ways to close a page. Having a single way
5329 // to close that can run onunload is also useful for fixing
5330 // http://b/issue?id=753080.
5331 webview()->dispatchUnloadEvent();
5332
5333 Send(new ViewHostMsg_ClosePage_ACK(routing_id_));
5334 }
5335
OnThemeChanged()5336 void RenderViewImpl::OnThemeChanged() {
5337 #if defined(USE_AURA)
5338 // Aura doesn't care if we switch themes.
5339 #elif defined(OS_WIN)
5340 ui::NativeThemeWin::instance()->CloseHandles();
5341 if (webview())
5342 webview()->themeChanged();
5343 #else // defined(OS_WIN)
5344 // TODO(port): we don't support theming on non-Windows platforms yet
5345 NOTIMPLEMENTED();
5346 #endif
5347 }
5348
MaybeLoadAlternateErrorPage(WebFrame * frame,const WebURLError & error,bool replace)5349 bool RenderViewImpl::MaybeLoadAlternateErrorPage(WebFrame* frame,
5350 const WebURLError& error,
5351 bool replace) {
5352 // We only show alternate error pages in the main frame. They are
5353 // intended to assist the user when navigating, so there is not much
5354 // value in showing them for failed subframes. Ideally, we would be
5355 // able to use the TYPED transition type for this, but that flag is
5356 // not preserved across page reloads.
5357 if (frame->parent())
5358 return false;
5359
5360 // Use the alternate error page service if this is a DNS failure or
5361 // connection failure.
5362 int ec = error.reason;
5363 if (ec != net::ERR_NAME_NOT_RESOLVED &&
5364 ec != net::ERR_CONNECTION_FAILED &&
5365 ec != net::ERR_CONNECTION_REFUSED &&
5366 ec != net::ERR_ADDRESS_UNREACHABLE &&
5367 ec != net::ERR_CONNECTION_TIMED_OUT) {
5368 return false;
5369 }
5370
5371 const GURL& error_page_url = GetAlternateErrorPageURL(error.unreachableURL,
5372 ec == net::ERR_NAME_NOT_RESOLVED ? DNS_ERROR : CONNECTION_ERROR);
5373 if (!error_page_url.is_valid())
5374 return false;
5375
5376 WebDataSource* ds = frame->provisionalDataSource();
5377 const WebURLRequest& failed_request = ds->request();
5378
5379 // Load an empty page first so there is an immediate response to the error,
5380 // and then kick off a request for the alternate error page.
5381 frame->loadHTMLString(std::string(),
5382 GURL(kUnreachableWebDataURL),
5383 error.unreachableURL,
5384 replace);
5385
5386 // Now, create a fetcher for the error page and associate it with the data
5387 // source we just created via the LoadHTMLString call. That way if another
5388 // navigation occurs, the fetcher will get destroyed.
5389 InternalDocumentStateData* internal_data =
5390 InternalDocumentStateData::FromDataSource(frame->provisionalDataSource());
5391 internal_data->set_alt_error_page_fetcher(
5392 new AltErrorPageResourceFetcher(
5393 error_page_url, frame, failed_request, error,
5394 base::Bind(&RenderViewImpl::AltErrorPageFinished,
5395 base::Unretained(this))));
5396 return true;
5397 }
5398
AltErrorPageFinished(WebFrame * frame,const WebURLRequest & original_request,const WebURLError & original_error,const std::string & html)5399 void RenderViewImpl::AltErrorPageFinished(WebFrame* frame,
5400 const WebURLRequest& original_request,
5401 const WebURLError& original_error,
5402 const std::string& html) {
5403 // Here, we replace the blank page we loaded previously.
5404 // If we failed to download the alternate error page, LoadNavigationErrorPage
5405 // will simply display a default error page.
5406 LoadNavigationErrorPage(frame, original_request, original_error, html, true);
5407 }
5408
OnMoveOrResizeStarted()5409 void RenderViewImpl::OnMoveOrResizeStarted() {
5410 if (webview())
5411 webview()->hidePopups();
5412 }
5413
OnResize(const ViewMsg_Resize_Params & params)5414 void RenderViewImpl::OnResize(const ViewMsg_Resize_Params& params) {
5415 if (webview()) {
5416 webview()->hidePopups();
5417 if (send_preferred_size_changes_) {
5418 webview()->mainFrame()->setCanHaveScrollbars(
5419 ShouldDisplayScrollbars(params.new_size.width(),
5420 params.new_size.height()));
5421 }
5422 UpdateScrollState(webview()->mainFrame());
5423 }
5424
5425 RenderWidget::OnResize(params);
5426 }
5427
DidInitiatePaint()5428 void RenderViewImpl::DidInitiatePaint() {
5429 #if defined(ENABLE_PLUGINS)
5430 main_render_frame_->DidInitiatePaint();
5431 #endif
5432 }
5433
DidFlushPaint()5434 void RenderViewImpl::DidFlushPaint() {
5435 #if defined(ENABLE_PLUGINS)
5436 main_render_frame_->DidFlushPaint();
5437 #endif
5438
5439 // If the RenderWidget is closing down then early-exit, otherwise we'll crash.
5440 // See crbug.com/112921.
5441 if (!webview())
5442 return;
5443
5444 WebFrame* main_frame = webview()->mainFrame();
5445
5446 // If we have a provisional frame we are between the start and commit stages
5447 // of loading and we don't want to save stats.
5448 if (!main_frame->provisionalDataSource()) {
5449 WebDataSource* ds = main_frame->dataSource();
5450 DocumentState* document_state = DocumentState::FromDataSource(ds);
5451 InternalDocumentStateData* data =
5452 InternalDocumentStateData::FromDocumentState(document_state);
5453 if (data->did_first_visually_non_empty_layout() &&
5454 !data->did_first_visually_non_empty_paint()) {
5455 data->set_did_first_visually_non_empty_paint(true);
5456 Send(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_,
5457 page_id_));
5458 }
5459
5460 // TODO(jar): The following code should all be inside a method, probably in
5461 // NavigatorState.
5462 Time now = Time::Now();
5463 if (document_state->first_paint_time().is_null()) {
5464 document_state->set_first_paint_time(now);
5465 }
5466 if (document_state->first_paint_after_load_time().is_null() &&
5467 !document_state->finish_load_time().is_null()) {
5468 document_state->set_first_paint_after_load_time(now);
5469 }
5470 }
5471 }
5472
GetBitmapForOptimizedPluginPaint(const gfx::Rect & paint_bounds,TransportDIB ** dib,gfx::Rect * location,gfx::Rect * clip,float * scale_factor)5473 PepperPluginInstanceImpl* RenderViewImpl::GetBitmapForOptimizedPluginPaint(
5474 const gfx::Rect& paint_bounds,
5475 TransportDIB** dib,
5476 gfx::Rect* location,
5477 gfx::Rect* clip,
5478 float* scale_factor) {
5479 #if defined(ENABLE_PLUGINS)
5480 return main_render_frame_->GetBitmapForOptimizedPluginPaint(
5481 paint_bounds, dib, location, clip, scale_factor);
5482 #endif
5483 return NULL;
5484 }
5485
GetScrollOffset()5486 gfx::Vector2d RenderViewImpl::GetScrollOffset() {
5487 WebSize scroll_offset = webview()->mainFrame()->scrollOffset();
5488 return gfx::Vector2d(scroll_offset.width, scroll_offset.height);
5489 }
5490
OnClearFocusedNode()5491 void RenderViewImpl::OnClearFocusedNode() {
5492 if (webview())
5493 webview()->clearFocusedNode();
5494 }
5495
OnSetBackground(const SkBitmap & background)5496 void RenderViewImpl::OnSetBackground(const SkBitmap& background) {
5497 if (webview())
5498 webview()->setIsTransparent(!background.empty());
5499 if (compositor_)
5500 compositor_->setHasTransparentBackground(!background.empty());
5501
5502 SetBackground(background);
5503 }
5504
OnSetAccessibilityMode(AccessibilityMode new_mode)5505 void RenderViewImpl::OnSetAccessibilityMode(AccessibilityMode new_mode) {
5506 if (accessibility_mode_ == new_mode)
5507 return;
5508 accessibility_mode_ = new_mode;
5509 if (renderer_accessibility_) {
5510 delete renderer_accessibility_;
5511 renderer_accessibility_ = NULL;
5512 }
5513 if (accessibility_mode_ == AccessibilityModeComplete)
5514 renderer_accessibility_ = new RendererAccessibilityComplete(this);
5515 #if !defined(OS_ANDROID)
5516 else if (accessibility_mode_ == AccessibilityModeEditableTextOnly)
5517 renderer_accessibility_ = new RendererAccessibilityFocusOnly(this);
5518 #endif
5519 }
5520
OnSetActive(bool active)5521 void RenderViewImpl::OnSetActive(bool active) {
5522 if (webview())
5523 webview()->setIsActive(active);
5524
5525 #if defined(ENABLE_PLUGINS) && defined(OS_MACOSX)
5526 std::set<WebPluginDelegateProxy*>::iterator plugin_it;
5527 for (plugin_it = plugin_delegates_.begin();
5528 plugin_it != plugin_delegates_.end(); ++plugin_it) {
5529 (*plugin_it)->SetWindowFocus(active);
5530 }
5531 #endif
5532 }
5533
5534 #if defined(OS_MACOSX)
OnSetWindowVisibility(bool visible)5535 void RenderViewImpl::OnSetWindowVisibility(bool visible) {
5536 #if defined(ENABLE_PLUGINS)
5537 // Inform plugins that their container has changed visibility.
5538 std::set<WebPluginDelegateProxy*>::iterator plugin_it;
5539 for (plugin_it = plugin_delegates_.begin();
5540 plugin_it != plugin_delegates_.end(); ++plugin_it) {
5541 (*plugin_it)->SetContainerVisibility(visible);
5542 }
5543 #endif
5544 }
5545
OnWindowFrameChanged(const gfx::Rect & window_frame,const gfx::Rect & view_frame)5546 void RenderViewImpl::OnWindowFrameChanged(const gfx::Rect& window_frame,
5547 const gfx::Rect& view_frame) {
5548 #if defined(ENABLE_PLUGINS)
5549 // Inform plugins that their window's frame has changed.
5550 std::set<WebPluginDelegateProxy*>::iterator plugin_it;
5551 for (plugin_it = plugin_delegates_.begin();
5552 plugin_it != plugin_delegates_.end(); ++plugin_it) {
5553 (*plugin_it)->WindowFrameChanged(window_frame, view_frame);
5554 }
5555 #endif
5556 }
5557
OnPluginImeCompositionCompleted(const base::string16 & text,int plugin_id)5558 void RenderViewImpl::OnPluginImeCompositionCompleted(const base::string16& text,
5559 int plugin_id) {
5560 // WebPluginDelegateProxy is responsible for figuring out if this event
5561 // applies to it or not, so inform all the delegates.
5562 std::set<WebPluginDelegateProxy*>::iterator plugin_it;
5563 for (plugin_it = plugin_delegates_.begin();
5564 plugin_it != plugin_delegates_.end(); ++plugin_it) {
5565 (*plugin_it)->ImeCompositionCompleted(text, plugin_id);
5566 }
5567 }
5568 #endif // OS_MACOSX
5569
Close()5570 void RenderViewImpl::Close() {
5571 // We need to grab a pointer to the doomed WebView before we destroy it.
5572 WebView* doomed = webview();
5573 RenderWidget::Close();
5574 g_view_map.Get().erase(doomed);
5575 g_routing_id_view_map.Get().erase(routing_id_);
5576 }
5577
DidHandleKeyEvent()5578 void RenderViewImpl::DidHandleKeyEvent() {
5579 ClearEditCommands();
5580 }
5581
WillHandleMouseEvent(const blink::WebMouseEvent & event)5582 bool RenderViewImpl::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
5583 context_menu_source_type_ = ui::MENU_SOURCE_MOUSE;
5584 possible_drag_event_info_.event_source =
5585 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
5586 possible_drag_event_info_.event_location =
5587 gfx::Point(event.globalX, event.globalY);
5588
5589 #if defined(ENABLE_PLUGINS)
5590 main_render_frame_->WillHandleMouseEvent(event);
5591 #endif
5592
5593 // If the mouse is locked, only the current owner of the mouse lock can
5594 // process mouse events.
5595 return mouse_lock_dispatcher_->WillHandleMouseEvent(event);
5596 }
5597
WillHandleKeyEvent(const blink::WebKeyboardEvent & event)5598 bool RenderViewImpl::WillHandleKeyEvent(const blink::WebKeyboardEvent& event) {
5599 context_menu_source_type_ = ui::MENU_SOURCE_KEYBOARD;
5600 return false;
5601 }
5602
WillHandleGestureEvent(const blink::WebGestureEvent & event)5603 bool RenderViewImpl::WillHandleGestureEvent(
5604 const blink::WebGestureEvent& event) {
5605 context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
5606 possible_drag_event_info_.event_source =
5607 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
5608 possible_drag_event_info_.event_location =
5609 gfx::Point(event.globalX, event.globalY);
5610 return false;
5611 }
5612
DidHandleMouseEvent(const WebMouseEvent & event)5613 void RenderViewImpl::DidHandleMouseEvent(const WebMouseEvent& event) {
5614 FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidHandleMouseEvent(event));
5615 }
5616
DidHandleTouchEvent(const WebTouchEvent & event)5617 void RenderViewImpl::DidHandleTouchEvent(const WebTouchEvent& event) {
5618 FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidHandleTouchEvent(event));
5619 }
5620
HasTouchEventHandlersAt(const gfx::Point & point) const5621 bool RenderViewImpl::HasTouchEventHandlersAt(const gfx::Point& point) const {
5622 if (!webview())
5623 return false;
5624 return webview()->hasTouchEventHandlersAt(point);
5625 }
5626
OnWasHidden()5627 void RenderViewImpl::OnWasHidden() {
5628 RenderWidget::OnWasHidden();
5629
5630 #if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
5631 RenderThreadImpl::current()->video_capture_impl_manager()->
5632 SuspendDevices(true);
5633 #endif
5634
5635 if (webview())
5636 webview()->setVisibilityState(visibilityState(), false);
5637
5638 #if defined(ENABLE_PLUGINS)
5639 main_render_frame_->PageVisibilityChanged(false);
5640
5641 #if defined(OS_MACOSX)
5642 // Inform NPAPI plugins that their container is no longer visible.
5643 std::set<WebPluginDelegateProxy*>::iterator plugin_it;
5644 for (plugin_it = plugin_delegates_.begin();
5645 plugin_it != plugin_delegates_.end(); ++plugin_it) {
5646 (*plugin_it)->SetContainerVisibility(false);
5647 }
5648 #endif // OS_MACOSX
5649 #endif // ENABLE_PLUGINS
5650 }
5651
OnWasShown(bool needs_repainting)5652 void RenderViewImpl::OnWasShown(bool needs_repainting) {
5653 RenderWidget::OnWasShown(needs_repainting);
5654
5655 #if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
5656 RenderThreadImpl::current()->video_capture_impl_manager()->
5657 SuspendDevices(false);
5658 #endif
5659
5660 if (webview())
5661 webview()->setVisibilityState(visibilityState(), false);
5662
5663 #if defined(ENABLE_PLUGINS)
5664 main_render_frame_->PageVisibilityChanged(true);
5665
5666 #if defined(OS_MACOSX)
5667 // Inform NPAPI plugins that their container is now visible.
5668 std::set<WebPluginDelegateProxy*>::iterator plugin_it;
5669 for (plugin_it = plugin_delegates_.begin();
5670 plugin_it != plugin_delegates_.end(); ++plugin_it) {
5671 (*plugin_it)->SetContainerVisibility(true);
5672 }
5673 #endif // OS_MACOSX
5674 #endif // ENABLE_PLUGINS
5675 }
5676
GetURLForGraphicsContext3D()5677 GURL RenderViewImpl::GetURLForGraphicsContext3D() {
5678 DCHECK(webview());
5679 if (webview()->mainFrame())
5680 return GURL(webview()->mainFrame()->document().url());
5681 else
5682 return GURL("chrome://gpu/RenderViewImpl::CreateGraphicsContext3D");
5683 }
5684
ForceCompositingModeEnabled()5685 bool RenderViewImpl::ForceCompositingModeEnabled() {
5686 return webkit_preferences_.force_compositing_mode;
5687 }
5688
OnSetFocus(bool enable)5689 void RenderViewImpl::OnSetFocus(bool enable) {
5690 RenderWidget::OnSetFocus(enable);
5691
5692 #if defined(ENABLE_PLUGINS)
5693 if (webview() && webview()->isActive()) {
5694 // Notify all NPAPI plugins.
5695 std::set<WebPluginDelegateProxy*>::iterator plugin_it;
5696 for (plugin_it = plugin_delegates_.begin();
5697 plugin_it != plugin_delegates_.end(); ++plugin_it) {
5698 #if defined(OS_MACOSX)
5699 // RenderWidget's call to setFocus can cause the underlying webview's
5700 // activation state to change just like a call to setIsActive.
5701 if (enable)
5702 (*plugin_it)->SetWindowFocus(true);
5703 #endif
5704 (*plugin_it)->SetContentAreaFocus(enable);
5705 }
5706 }
5707 main_render_frame_->OnSetFocus(enable);
5708 #endif
5709 // Notify all BrowserPlugins of the RenderView's focus state.
5710 if (browser_plugin_manager_.get())
5711 browser_plugin_manager_->UpdateFocusState();
5712 }
5713
OnImeSetComposition(const base::string16 & text,const std::vector<blink::WebCompositionUnderline> & underlines,int selection_start,int selection_end)5714 void RenderViewImpl::OnImeSetComposition(
5715 const base::string16& text,
5716 const std::vector<blink::WebCompositionUnderline>& underlines,
5717 int selection_start,
5718 int selection_end) {
5719 #if defined(ENABLE_PLUGINS)
5720 if (focused_pepper_plugin_) {
5721 focused_pepper_plugin_->render_frame()->OnImeSetComposition(
5722 text, underlines, selection_start, selection_end);
5723 return;
5724 }
5725
5726 #if defined(OS_WIN)
5727 // When a plug-in has focus, we create platform-specific IME data used by
5728 // our IME emulator and send it directly to the focused plug-in, i.e. we
5729 // bypass WebKit. (WebPluginDelegate dispatches this IME data only when its
5730 // instance ID is the same one as the specified ID.)
5731 if (focused_plugin_id_ >= 0) {
5732 std::vector<int> clauses;
5733 std::vector<int> target;
5734 for (size_t i = 0; i < underlines.size(); ++i) {
5735 clauses.push_back(underlines[i].startOffset);
5736 clauses.push_back(underlines[i].endOffset);
5737 if (underlines[i].thick) {
5738 target.clear();
5739 target.push_back(underlines[i].startOffset);
5740 target.push_back(underlines[i].endOffset);
5741 }
5742 }
5743 std::set<WebPluginDelegateProxy*>::iterator it;
5744 for (it = plugin_delegates_.begin(); it != plugin_delegates_.end(); ++it) {
5745 (*it)->ImeCompositionUpdated(text, clauses, target, selection_end,
5746 focused_plugin_id_);
5747 }
5748 return;
5749 }
5750 #endif // OS_WIN
5751 #endif // ENABLE_PLUGINS
5752 RenderWidget::OnImeSetComposition(text,
5753 underlines,
5754 selection_start,
5755 selection_end);
5756 }
5757
OnImeConfirmComposition(const base::string16 & text,const gfx::Range & replacement_range,bool keep_selection)5758 void RenderViewImpl::OnImeConfirmComposition(
5759 const base::string16& text,
5760 const gfx::Range& replacement_range,
5761 bool keep_selection) {
5762 #if defined(ENABLE_PLUGINS)
5763 if (focused_pepper_plugin_) {
5764 focused_pepper_plugin_->render_frame()->OnImeConfirmComposition(
5765 text, replacement_range, keep_selection);
5766 return;
5767 }
5768 #if defined(OS_WIN)
5769 // Same as OnImeSetComposition(), we send the text from IMEs directly to
5770 // plug-ins. When we send IME text directly to plug-ins, we should not send
5771 // it to WebKit to prevent WebKit from controlling IMEs.
5772 // TODO(thakis): Honor |replacement_range| for plugins?
5773 if (focused_plugin_id_ >= 0) {
5774 std::set<WebPluginDelegateProxy*>::iterator it;
5775 for (it = plugin_delegates_.begin();
5776 it != plugin_delegates_.end(); ++it) {
5777 (*it)->ImeCompositionCompleted(text, focused_plugin_id_);
5778 }
5779 return;
5780 }
5781 #endif // OS_WIN
5782 #endif // ENABLE_PLUGINS
5783 if (replacement_range.IsValid() && webview()) {
5784 // Select the text in |replacement_range|, it will then be replaced by
5785 // text added by the call to RenderWidget::OnImeConfirmComposition().
5786 if (WebFrame* frame = webview()->focusedFrame()) {
5787 WebRange webrange = WebRange::fromDocumentRange(
5788 frame, replacement_range.start(), replacement_range.length());
5789 if (!webrange.isNull())
5790 frame->selectRange(webrange);
5791 }
5792 }
5793 RenderWidget::OnImeConfirmComposition(text,
5794 replacement_range,
5795 keep_selection);
5796 }
5797
SetDeviceScaleFactor(float device_scale_factor)5798 void RenderViewImpl::SetDeviceScaleFactor(float device_scale_factor) {
5799 RenderWidget::SetDeviceScaleFactor(device_scale_factor);
5800 if (webview()) {
5801 webview()->setDeviceScaleFactor(device_scale_factor);
5802 webview()->settings()->setAcceleratedCompositingForFixedPositionEnabled(
5803 ShouldUseFixedPositionCompositing(device_scale_factor_));
5804 webview()->settings()->setAcceleratedCompositingForOverflowScrollEnabled(
5805 ShouldUseAcceleratedCompositingForOverflowScroll(device_scale_factor_));
5806 webview()->settings()->setAcceleratedCompositingForTransitionEnabled(
5807 ShouldUseTransitionCompositing(device_scale_factor_));
5808 webview()->settings()->
5809 setAcceleratedCompositingForFixedRootBackgroundEnabled(
5810 ShouldUseAcceleratedFixedRootBackground(device_scale_factor_));
5811 webview()->settings()->setAcceleratedCompositingForScrollableFramesEnabled(
5812 ShouldUseAcceleratedCompositingForScrollableFrames(
5813 device_scale_factor_));
5814 webview()->settings()->setCompositedScrollingForFramesEnabled(
5815 ShouldUseCompositedScrollingForFrames(device_scale_factor_));
5816 }
5817 if (auto_resize_mode_)
5818 AutoResizeCompositor();
5819
5820 if (browser_plugin_manager_.get())
5821 browser_plugin_manager_->UpdateDeviceScaleFactor(device_scale_factor_);
5822 }
5823
GetTextInputType()5824 ui::TextInputType RenderViewImpl::GetTextInputType() {
5825 #if defined(ENABLE_PLUGINS)
5826 if (focused_pepper_plugin_)
5827 return focused_pepper_plugin_->text_input_type();
5828 #endif
5829 return RenderWidget::GetTextInputType();
5830 }
5831
GetSelectionBounds(gfx::Rect * start,gfx::Rect * end)5832 void RenderViewImpl::GetSelectionBounds(gfx::Rect* start, gfx::Rect* end) {
5833 #if defined(ENABLE_PLUGINS)
5834 if (focused_pepper_plugin_) {
5835 // TODO(kinaba) http://crbug.com/101101
5836 // Current Pepper IME API does not handle selection bounds. So we simply
5837 // use the caret position as an empty range for now. It will be updated
5838 // after Pepper API equips features related to surrounding text retrieval.
5839 gfx::Rect caret = focused_pepper_plugin_->GetCaretBounds();
5840 *start = caret;
5841 *end = caret;
5842 return;
5843 }
5844 #endif
5845 RenderWidget::GetSelectionBounds(start, end);
5846 }
5847
5848 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
GetCompositionCharacterBounds(std::vector<gfx::Rect> * bounds)5849 void RenderViewImpl::GetCompositionCharacterBounds(
5850 std::vector<gfx::Rect>* bounds) {
5851 DCHECK(bounds);
5852 bounds->clear();
5853
5854 #if defined(ENABLE_PLUGINS)
5855 if (focused_pepper_plugin_) {
5856 return;
5857 }
5858 #endif
5859
5860 if (!webview())
5861 return;
5862 size_t start_offset = 0;
5863 size_t character_count = 0;
5864 if (!webview()->compositionRange(&start_offset, &character_count))
5865 return;
5866 if (character_count == 0)
5867 return;
5868
5869 blink::WebFrame* frame = webview()->focusedFrame();
5870 if (!frame)
5871 return;
5872
5873 bounds->reserve(character_count);
5874 blink::WebRect webrect;
5875 for (size_t i = 0; i < character_count; ++i) {
5876 if (!frame->firstRectForCharacterRange(start_offset + i, 1, webrect)) {
5877 DLOG(ERROR) << "Could not retrieve character rectangle at " << i;
5878 bounds->clear();
5879 return;
5880 }
5881 bounds->push_back(webrect);
5882 }
5883 }
5884
GetCompositionRange(gfx::Range * range)5885 void RenderViewImpl::GetCompositionRange(gfx::Range* range) {
5886 #if defined(ENABLE_PLUGINS)
5887 if (focused_pepper_plugin_) {
5888 return;
5889 }
5890 #endif
5891 RenderWidget::GetCompositionRange(range);
5892 }
5893 #endif
5894
CanComposeInline()5895 bool RenderViewImpl::CanComposeInline() {
5896 #if defined(ENABLE_PLUGINS)
5897 if (focused_pepper_plugin_)
5898 return focused_pepper_plugin_->IsPluginAcceptingCompositionEvents();
5899 #endif
5900 return true;
5901 }
5902
InstrumentWillBeginFrame(int frame_id)5903 void RenderViewImpl::InstrumentWillBeginFrame(int frame_id) {
5904 if (!webview())
5905 return;
5906 if (!webview()->devToolsAgent())
5907 return;
5908 webview()->devToolsAgent()->didBeginFrame(frame_id);
5909 }
5910
InstrumentDidBeginFrame()5911 void RenderViewImpl::InstrumentDidBeginFrame() {
5912 if (!webview())
5913 return;
5914 if (!webview()->devToolsAgent())
5915 return;
5916 // TODO(jamesr/caseq): Decide if this needs to be renamed.
5917 webview()->devToolsAgent()->didComposite();
5918 }
5919
InstrumentDidCancelFrame()5920 void RenderViewImpl::InstrumentDidCancelFrame() {
5921 if (!webview())
5922 return;
5923 if (!webview()->devToolsAgent())
5924 return;
5925 webview()->devToolsAgent()->didCancelFrame();
5926 }
5927
InstrumentWillComposite()5928 void RenderViewImpl::InstrumentWillComposite() {
5929 if (!webview())
5930 return;
5931 if (!webview()->devToolsAgent())
5932 return;
5933 webview()->devToolsAgent()->willComposite();
5934 }
5935
AllowPartialSwap() const5936 bool RenderViewImpl::AllowPartialSwap() const {
5937 return allow_partial_swap_;
5938 }
5939
SetScreenMetricsEmulationParameters(float device_scale_factor,const gfx::Point & root_layer_offset,float root_layer_scale)5940 void RenderViewImpl::SetScreenMetricsEmulationParameters(
5941 float device_scale_factor,
5942 const gfx::Point& root_layer_offset,
5943 float root_layer_scale) {
5944 if (webview()) {
5945 webview()->setCompositorDeviceScaleFactorOverride(device_scale_factor);
5946 webview()->setRootLayerTransform(
5947 blink::WebSize(root_layer_offset.x(), root_layer_offset.y()),
5948 root_layer_scale);
5949 }
5950 }
5951
ScheduleFileChooser(const FileChooserParams & params,WebFileChooserCompletion * completion)5952 bool RenderViewImpl::ScheduleFileChooser(
5953 const FileChooserParams& params,
5954 WebFileChooserCompletion* completion) {
5955 static const size_t kMaximumPendingFileChooseRequests = 4;
5956 if (file_chooser_completions_.size() > kMaximumPendingFileChooseRequests) {
5957 // This sanity check prevents too many file choose requests from getting
5958 // queued which could DoS the user. Getting these is most likely a
5959 // programming error (there are many ways to DoS the user so it's not
5960 // considered a "real" security check), either in JS requesting many file
5961 // choosers to pop up, or in a plugin.
5962 //
5963 // TODO(brettw) we might possibly want to require a user gesture to open
5964 // a file picker, which will address this issue in a better way.
5965 return false;
5966 }
5967
5968 file_chooser_completions_.push_back(linked_ptr<PendingFileChooser>(
5969 new PendingFileChooser(params, completion)));
5970 if (file_chooser_completions_.size() == 1) {
5971 // Actually show the browse dialog when this is the first request.
5972 Send(new ViewHostMsg_RunFileChooser(routing_id_, params));
5973 }
5974 return true;
5975 }
5976
geolocationClient()5977 blink::WebGeolocationClient* RenderViewImpl::geolocationClient() {
5978 if (!geolocation_dispatcher_)
5979 geolocation_dispatcher_ = new GeolocationDispatcher(this);
5980 return geolocation_dispatcher_;
5981 }
5982
speechInputController(blink::WebSpeechInputListener * listener)5983 blink::WebSpeechInputController* RenderViewImpl::speechInputController(
5984 blink::WebSpeechInputListener* listener) {
5985 #if defined(ENABLE_INPUT_SPEECH)
5986 if (!input_tag_speech_dispatcher_)
5987 input_tag_speech_dispatcher_ =
5988 new InputTagSpeechDispatcher(this, listener);
5989 #endif
5990 return input_tag_speech_dispatcher_;
5991 }
5992
speechRecognizer()5993 blink::WebSpeechRecognizer* RenderViewImpl::speechRecognizer() {
5994 if (!speech_recognition_dispatcher_)
5995 speech_recognition_dispatcher_ = new SpeechRecognitionDispatcher(this);
5996 return speech_recognition_dispatcher_;
5997 }
5998
zoomLimitsChanged(double minimum_level,double maximum_level)5999 void RenderViewImpl::zoomLimitsChanged(double minimum_level,
6000 double maximum_level) {
6001 // For now, don't remember plugin zoom values. We don't want to mix them with
6002 // normal web content (i.e. a fixed layout plugin would usually want them
6003 // different).
6004 bool remember = !webview()->mainFrame()->document().isPluginDocument();
6005
6006 int minimum_percent = static_cast<int>(
6007 ZoomLevelToZoomFactor(minimum_level) * 100);
6008 int maximum_percent = static_cast<int>(
6009 ZoomLevelToZoomFactor(maximum_level) * 100);
6010
6011 Send(new ViewHostMsg_UpdateZoomLimits(
6012 routing_id_, minimum_percent, maximum_percent, remember));
6013 }
6014
zoomLevelChanged()6015 void RenderViewImpl::zoomLevelChanged() {
6016 bool remember = !webview()->mainFrame()->document().isPluginDocument();
6017 float zoom_level = webview()->zoomLevel();
6018
6019 FOR_EACH_OBSERVER(RenderViewObserver, observers_, ZoomLevelChanged());
6020
6021 // Tell the browser which url got zoomed so it can update the menu and the
6022 // saved values if necessary
6023 Send(new ViewHostMsg_DidZoomURL(
6024 routing_id_, zoom_level, remember,
6025 GURL(webview()->mainFrame()->document().url())));
6026 }
6027
zoomLevelToZoomFactor(double zoom_level) const6028 double RenderViewImpl::zoomLevelToZoomFactor(double zoom_level) const {
6029 return ZoomLevelToZoomFactor(zoom_level);
6030 }
6031
zoomFactorToZoomLevel(double factor) const6032 double RenderViewImpl::zoomFactorToZoomLevel(double factor) const {
6033 return ZoomFactorToZoomLevel(factor);
6034 }
6035
registerProtocolHandler(const WebString & scheme,const WebString & base_url,const WebString & url,const WebString & title)6036 void RenderViewImpl::registerProtocolHandler(const WebString& scheme,
6037 const WebString& base_url,
6038 const WebString& url,
6039 const WebString& title) {
6040 bool user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
6041 GURL base(base_url);
6042 GURL absolute_url = base.Resolve(UTF16ToUTF8(url));
6043 if (base.GetOrigin() != absolute_url.GetOrigin()) {
6044 return;
6045 }
6046 Send(new ViewHostMsg_RegisterProtocolHandler(routing_id_,
6047 UTF16ToUTF8(scheme),
6048 absolute_url,
6049 title,
6050 user_gesture));
6051 }
6052
visibilityState() const6053 blink::WebPageVisibilityState RenderViewImpl::visibilityState() const {
6054 blink::WebPageVisibilityState current_state = is_hidden() ?
6055 blink::WebPageVisibilityStateHidden :
6056 blink::WebPageVisibilityStateVisible;
6057 blink::WebPageVisibilityState override_state = current_state;
6058 // TODO(jam): move this method to WebFrameClient.
6059 if (GetContentClient()->renderer()->
6060 ShouldOverridePageVisibilityState(main_render_frame_.get(),
6061 &override_state))
6062 return override_state;
6063 return current_state;
6064 }
6065
userMediaClient()6066 blink::WebUserMediaClient* RenderViewImpl::userMediaClient() {
6067 // This can happen in tests, in which case it's OK to return NULL.
6068 if (!InitializeMediaStreamClient())
6069 return NULL;
6070
6071 return web_user_media_client_;
6072 }
6073
webMIDIClient()6074 blink::WebMIDIClient* RenderViewImpl::webMIDIClient() {
6075 if (!midi_dispatcher_)
6076 midi_dispatcher_ = new MIDIDispatcher(this);
6077 return midi_dispatcher_;
6078 }
6079
draggableRegionsChanged()6080 void RenderViewImpl::draggableRegionsChanged() {
6081 FOR_EACH_OBSERVER(
6082 RenderViewObserver,
6083 observers_,
6084 DraggableRegionsChanged(webview()->mainFrame()));
6085 }
6086
CreateWebMediaPlayerForMediaStream(WebFrame * frame,const blink::WebURL & url,WebMediaPlayerClient * client)6087 WebMediaPlayer* RenderViewImpl::CreateWebMediaPlayerForMediaStream(
6088 WebFrame* frame,
6089 const blink::WebURL& url,
6090 WebMediaPlayerClient* client) {
6091 #if defined(ENABLE_WEBRTC)
6092 if (!InitializeMediaStreamClient()) {
6093 LOG(ERROR) << "Failed to initialize MediaStreamClient";
6094 return NULL;
6095 }
6096 #if !defined(GOOGLE_TV)
6097 if (media_stream_client_->IsMediaStream(url)) {
6098 #if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
6099 bool found_neon =
6100 (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
6101 UMA_HISTOGRAM_BOOLEAN("Platform.WebRtcNEONFound", found_neon);
6102 #endif // defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
6103 return new WebMediaPlayerMS(frame, client, AsWeakPtr(),
6104 media_stream_client_, new RenderMediaLog());
6105 }
6106 #endif // !defined(GOOGLE_TV)
6107 #endif // defined(ENABLE_WEBRTC)
6108 return NULL;
6109 }
6110
6111 #if defined(OS_ANDROID)
detectContentAround(const WebHitTestResult & touch_hit)6112 WebContentDetectionResult RenderViewImpl::detectContentAround(
6113 const WebHitTestResult& touch_hit) {
6114 DCHECK(!touch_hit.isNull());
6115 DCHECK(!touch_hit.node().isNull());
6116 DCHECK(touch_hit.node().isTextNode());
6117
6118 // Process the position with all the registered content detectors until
6119 // a match is found. Priority is provided by their relative order.
6120 for (ContentDetectorList::const_iterator it = content_detectors_.begin();
6121 it != content_detectors_.end(); ++it) {
6122 ContentDetector::Result content = (*it)->FindTappedContent(touch_hit);
6123 if (content.valid) {
6124 return WebContentDetectionResult(content.content_boundaries,
6125 UTF8ToUTF16(content.text), content.intent_url);
6126 }
6127 }
6128 return WebContentDetectionResult();
6129 }
6130
scheduleContentIntent(const WebURL & intent)6131 void RenderViewImpl::scheduleContentIntent(const WebURL& intent) {
6132 // Introduce a short delay so that the user can notice the content.
6133 base::MessageLoop::current()->PostDelayedTask(
6134 FROM_HERE,
6135 base::Bind(&RenderViewImpl::LaunchAndroidContentIntent,
6136 AsWeakPtr(),
6137 intent,
6138 expected_content_intent_id_),
6139 base::TimeDelta::FromMilliseconds(kContentIntentDelayMilliseconds));
6140 }
6141
cancelScheduledContentIntents()6142 void RenderViewImpl::cancelScheduledContentIntents() {
6143 ++expected_content_intent_id_;
6144 }
6145
LaunchAndroidContentIntent(const GURL & intent,size_t request_id)6146 void RenderViewImpl::LaunchAndroidContentIntent(const GURL& intent,
6147 size_t request_id) {
6148 if (request_id != expected_content_intent_id_)
6149 return;
6150
6151 // Remove the content highlighting if any.
6152 scheduleComposite();
6153
6154 if (!intent.is_empty())
6155 Send(new ViewHostMsg_StartContentIntent(routing_id_, intent));
6156 }
6157
openDateTimeChooser(const blink::WebDateTimeChooserParams & params,blink::WebDateTimeChooserCompletion * completion)6158 bool RenderViewImpl::openDateTimeChooser(
6159 const blink::WebDateTimeChooserParams& params,
6160 blink::WebDateTimeChooserCompletion* completion) {
6161 // JavaScript may try to open a date time chooser while one is already open.
6162 if (date_time_picker_client_)
6163 return false;
6164 date_time_picker_client_.reset(
6165 new RendererDateTimePicker(this, params, completion));
6166 return date_time_picker_client_->Open();
6167 }
6168
6169 #if defined(OS_ANDROID)
DismissDateTimeDialog()6170 void RenderViewImpl::DismissDateTimeDialog() {
6171 DCHECK(date_time_picker_client_);
6172 date_time_picker_client_.reset(NULL);
6173 }
6174 #endif
6175
CreateAndroidWebMediaPlayer(WebFrame * frame,const blink::WebURL & url,WebMediaPlayerClient * client)6176 WebMediaPlayer* RenderViewImpl::CreateAndroidWebMediaPlayer(
6177 WebFrame* frame,
6178 const blink::WebURL& url,
6179 WebMediaPlayerClient* client) {
6180 GpuChannelHost* gpu_channel_host =
6181 RenderThreadImpl::current()->EstablishGpuChannelSync(
6182 CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
6183 if (!gpu_channel_host) {
6184 LOG(ERROR) << "Failed to establish GPU channel for media player";
6185 return NULL;
6186 }
6187
6188 scoped_ptr<StreamTextureFactory> stream_texture_factory;
6189 if (UsingSynchronousRendererCompositor()) {
6190 SynchronousCompositorFactory* factory =
6191 SynchronousCompositorFactory::GetInstance();
6192 stream_texture_factory = factory->CreateStreamTextureFactory(routing_id_);
6193 } else {
6194 scoped_refptr<cc::ContextProvider> context_provider =
6195 RenderThreadImpl::current()->SharedMainThreadContextProvider();
6196
6197 if (!context_provider.get()) {
6198 LOG(ERROR) << "Failed to get context3d for media player";
6199 return NULL;
6200 }
6201
6202 stream_texture_factory.reset(new StreamTextureFactoryImpl(
6203 context_provider->Context3d(), gpu_channel_host, routing_id_));
6204 }
6205
6206 scoped_ptr<WebMediaPlayerAndroid> web_media_player_android(
6207 new WebMediaPlayerAndroid(
6208 frame,
6209 client,
6210 AsWeakPtr(),
6211 media_player_manager_,
6212 stream_texture_factory.release(),
6213 RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy(),
6214 new RenderMediaLog()));
6215 #if defined(ENABLE_WEBRTC) && defined(GOOGLE_TV)
6216 if (media_stream_client_ && media_stream_client_->IsMediaStream(url)) {
6217 RTCVideoDecoderFactoryTv* factory = RenderThreadImpl::current()
6218 ->GetMediaStreamDependencyFactory()->decoder_factory_tv();
6219 // |media_stream_client| and |factory| outlives |web_media_player_android|.
6220 if (!factory->AcquireDemuxer() ||
6221 !web_media_player_android->InjectMediaStream(
6222 media_stream_client_,
6223 factory,
6224 base::Bind(
6225 base::IgnoreResult(&RTCVideoDecoderFactoryTv::ReleaseDemuxer),
6226 base::Unretained(factory)))) {
6227 LOG(ERROR) << "Failed to inject media stream.";
6228 return NULL;
6229 }
6230 }
6231 #endif // defined(ENABLE_WEBRTC) && defined(GOOGLE_TV)
6232 return web_media_player_android.release();
6233 }
6234
6235 #endif // defined(OS_ANDROID)
6236
6237 #if defined(OS_MACOSX)
OnSelectPopupMenuItem(int selected_index)6238 void RenderViewImpl::OnSelectPopupMenuItem(int selected_index) {
6239 if (external_popup_menu_ == NULL) {
6240 // Crash reports from the field indicate that we can be notified with a
6241 // NULL external popup menu (we probably get notified twice).
6242 // If you hit this please file a bug against jcivelli and include the page
6243 // and steps to repro.
6244 NOTREACHED();
6245 return;
6246 }
6247 external_popup_menu_->DidSelectItem(selected_index);
6248 external_popup_menu_.reset();
6249 }
6250 #endif
6251
6252 #if defined(OS_ANDROID)
OnSelectPopupMenuItems(bool canceled,const std::vector<int> & selected_indices)6253 void RenderViewImpl::OnSelectPopupMenuItems(
6254 bool canceled,
6255 const std::vector<int>& selected_indices) {
6256 // It is possible to receive more than one of these calls if the user presses
6257 // a select faster than it takes for the show-select-popup IPC message to make
6258 // it to the browser UI thread. Ignore the extra-messages.
6259 // TODO(jcivelli): http:/b/5793321 Implement a better fix, as detailed in bug.
6260 if (!external_popup_menu_)
6261 return;
6262
6263 external_popup_menu_->DidSelectItems(canceled, selected_indices);
6264 external_popup_menu_.reset();
6265 }
6266 #endif
6267
OnContextMenuClosed(const CustomContextMenuContext & custom_context)6268 void RenderViewImpl::OnContextMenuClosed(
6269 const CustomContextMenuContext& custom_context) {
6270 if (custom_context.request_id) {
6271 // External request, should be in our map.
6272 ContextMenuClient* client =
6273 pending_context_menus_.Lookup(custom_context.request_id);
6274 if (client) {
6275 client->OnMenuClosed(custom_context.request_id);
6276 pending_context_menus_.Remove(custom_context.request_id);
6277 }
6278 } else {
6279 // Internal request, forward to WebKit.
6280 context_menu_node_.reset();
6281 }
6282 }
6283
OnShowContextMenu(const gfx::Point & location)6284 void RenderViewImpl::OnShowContextMenu(const gfx::Point& location) {
6285 context_menu_source_type_ = ui::MENU_SOURCE_TOUCH_EDIT_MENU;
6286 touch_editing_context_menu_location_ = location;
6287 if (webview())
6288 webview()->showContextMenu();
6289 }
6290
OnEnableViewSourceMode()6291 void RenderViewImpl::OnEnableViewSourceMode() {
6292 if (!webview())
6293 return;
6294 WebFrame* main_frame = webview()->mainFrame();
6295 if (!main_frame)
6296 return;
6297 main_frame->enableViewSourceMode(true);
6298 }
6299
OnDisownOpener()6300 void RenderViewImpl::OnDisownOpener() {
6301 if (!webview())
6302 return;
6303
6304 WebFrame* main_frame = webview()->mainFrame();
6305 if (main_frame && main_frame->opener())
6306 main_frame->setOpener(NULL);
6307 }
6308
6309 #if defined(OS_ANDROID)
didTapMultipleTargets(const blink::WebGestureEvent & event,const WebVector<WebRect> & target_rects)6310 bool RenderViewImpl::didTapMultipleTargets(
6311 const blink::WebGestureEvent& event,
6312 const WebVector<WebRect>& target_rects) {
6313 // Never show a disambiguation popup when accessibility is enabled,
6314 // as this interferes with "touch exploration".
6315 if (accessibility_mode_ == AccessibilityModeComplete)
6316 return false;
6317
6318 gfx::Rect finger_rect(
6319 event.x - event.data.tap.width / 2, event.y - event.data.tap.height / 2,
6320 event.data.tap.width, event.data.tap.height);
6321 gfx::Rect zoom_rect;
6322 float new_total_scale =
6323 DisambiguationPopupHelper::ComputeZoomAreaAndScaleFactor(
6324 finger_rect, target_rects, GetSize(),
6325 gfx::Rect(webview()->mainFrame()->visibleContentRect()).size(),
6326 device_scale_factor_ * webview()->pageScaleFactor(), &zoom_rect);
6327 if (!new_total_scale)
6328 return false;
6329
6330 bool handled = false;
6331 switch (renderer_preferences_.tap_multiple_targets_strategy) {
6332 case TAP_MULTIPLE_TARGETS_STRATEGY_ZOOM:
6333 handled = webview()->zoomToMultipleTargetsRect(zoom_rect);
6334 break;
6335 case TAP_MULTIPLE_TARGETS_STRATEGY_POPUP: {
6336 gfx::Size canvas_size =
6337 gfx::ToCeiledSize(gfx::ScaleSize(zoom_rect.size(), new_total_scale));
6338 TransportDIB* transport_dib = NULL;
6339 {
6340 scoped_ptr<skia::PlatformCanvas> canvas(
6341 RenderProcess::current()->GetDrawingCanvas(&transport_dib,
6342 gfx::Rect(canvas_size)));
6343 if (!canvas) {
6344 handled = false;
6345 break;
6346 }
6347
6348 // TODO(trchen): Cleanup the device scale factor mess.
6349 // device scale will be applied in WebKit
6350 // --> zoom_rect doesn't include device scale,
6351 // but WebKit will still draw on zoom_rect * device_scale_factor_
6352 canvas->scale(new_total_scale / device_scale_factor_,
6353 new_total_scale / device_scale_factor_);
6354 canvas->translate(-zoom_rect.x() * device_scale_factor_,
6355 -zoom_rect.y() * device_scale_factor_);
6356
6357 webwidget_->paint(
6358 canvas.get(),
6359 zoom_rect,
6360 WebWidget::ForceSoftwareRenderingAndIgnoreGPUResidentContent);
6361 }
6362
6363 gfx::Rect physical_window_zoom_rect = gfx::ToEnclosingRect(
6364 ClientRectToPhysicalWindowRect(gfx::RectF(zoom_rect)));
6365 Send(new ViewHostMsg_ShowDisambiguationPopup(routing_id_,
6366 physical_window_zoom_rect,
6367 canvas_size,
6368 transport_dib->id()));
6369 handled = true;
6370 break;
6371 }
6372 case TAP_MULTIPLE_TARGETS_STRATEGY_NONE:
6373 // No-op.
6374 break;
6375 }
6376
6377 return handled;
6378 }
6379 #endif
6380
GetLocalSessionHistoryLengthForTesting() const6381 unsigned RenderViewImpl::GetLocalSessionHistoryLengthForTesting() const {
6382 return history_list_length_;
6383 }
6384
SetFocusAndActivateForTesting(bool enable)6385 void RenderViewImpl::SetFocusAndActivateForTesting(bool enable) {
6386 if (enable) {
6387 if (has_focus())
6388 return;
6389 OnSetActive(true);
6390 OnSetFocus(true);
6391 } else {
6392 if (!has_focus())
6393 return;
6394 OnSetFocus(false);
6395 OnSetActive(false);
6396 }
6397 }
6398
SetDeviceScaleFactorForTesting(float factor)6399 void RenderViewImpl::SetDeviceScaleFactorForTesting(float factor) {
6400 ViewMsg_Resize_Params params;
6401 params.screen_info = screen_info_;
6402 params.screen_info.deviceScaleFactor = factor;
6403 params.new_size = size();
6404 params.physical_backing_size =
6405 gfx::ToCeiledSize(gfx::ScaleSize(size(), factor));
6406 params.overdraw_bottom_height = 0.f;
6407 params.resizer_rect = WebRect();
6408 params.is_fullscreen = is_fullscreen();
6409 OnResize(params);
6410 }
6411
ForceResizeForTesting(const gfx::Size & new_size)6412 void RenderViewImpl::ForceResizeForTesting(const gfx::Size& new_size) {
6413 gfx::Rect new_position(rootWindowRect().x,
6414 rootWindowRect().y,
6415 new_size.width(),
6416 new_size.height());
6417 ResizeSynchronously(new_position);
6418 }
6419
UseSynchronousResizeModeForTesting(bool enable)6420 void RenderViewImpl::UseSynchronousResizeModeForTesting(bool enable) {
6421 resizing_mode_selector_->set_is_synchronous_mode(enable);
6422 }
6423
EnableAutoResizeForTesting(const gfx::Size & min_size,const gfx::Size & max_size)6424 void RenderViewImpl::EnableAutoResizeForTesting(const gfx::Size& min_size,
6425 const gfx::Size& max_size) {
6426 OnEnableAutoResize(min_size, max_size);
6427 }
6428
DisableAutoResizeForTesting(const gfx::Size & new_size)6429 void RenderViewImpl::DisableAutoResizeForTesting(const gfx::Size& new_size) {
6430 OnDisableAutoResize(new_size);
6431 }
6432
SetMediaStreamClientForTesting(MediaStreamClient * media_stream_client)6433 void RenderViewImpl::SetMediaStreamClientForTesting(
6434 MediaStreamClient* media_stream_client) {
6435 DCHECK(!media_stream_client_);
6436 DCHECK(!web_user_media_client_);
6437 media_stream_client_ = media_stream_client;
6438 }
6439
OnReleaseDisambiguationPopupDIB(TransportDIB::Handle dib_handle)6440 void RenderViewImpl::OnReleaseDisambiguationPopupDIB(
6441 TransportDIB::Handle dib_handle) {
6442 TransportDIB* dib = TransportDIB::CreateWithHandle(dib_handle);
6443 RenderProcess::current()->ReleaseTransportDIB(dib);
6444 }
6445
DidCommitCompositorFrame()6446 void RenderViewImpl::DidCommitCompositorFrame() {
6447 RenderWidget::DidCommitCompositorFrame();
6448 FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidCommitCompositorFrame());
6449 }
6450
SendUpdateFaviconURL(const std::vector<FaviconURL> & urls)6451 void RenderViewImpl::SendUpdateFaviconURL(const std::vector<FaviconURL>& urls) {
6452 if (!urls.empty())
6453 Send(new ViewHostMsg_UpdateFaviconURL(routing_id_, page_id_, urls));
6454 }
6455
DidStopLoadingIcons()6456 void RenderViewImpl::DidStopLoadingIcons() {
6457 int icon_types = WebIconURL::TypeFavicon;
6458 if (TouchEnabled())
6459 icon_types |= WebIconURL::TypeTouchPrecomposed | WebIconURL::TypeTouch;
6460
6461 WebVector<WebIconURL> icon_urls =
6462 webview()->mainFrame()->iconURLs(icon_types);
6463
6464 std::vector<FaviconURL> urls;
6465 for (size_t i = 0; i < icon_urls.size(); i++) {
6466 WebURL url = icon_urls[i].iconURL();
6467 if (!url.isEmpty())
6468 urls.push_back(FaviconURL(url,
6469 ToFaviconType(icon_urls[i].iconType())));
6470 }
6471 SendUpdateFaviconURL(urls);
6472 }
6473
GetOriginalRequestURL(WebDataSource * ds)6474 GURL RenderViewImpl::GetOriginalRequestURL(WebDataSource* ds) {
6475 // WebDataSource has unreachable URL means that the frame is loaded through
6476 // blink::WebFrame::loadData(), and the base URL will be in the redirect
6477 // chain. However, we never visited the baseURL. So in this case, we should
6478 // use the unreachable URL as the original URL.
6479 if (ds->hasUnreachableURL())
6480 return ds->unreachableURL();
6481
6482 std::vector<GURL> redirects;
6483 GetRedirectChain(ds, &redirects);
6484 if (!redirects.empty())
6485 return redirects.at(0);
6486
6487 return ds->originalRequest().url();
6488 }
6489
6490 } // namespace content
6491