1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "content/renderer/render_frame_impl.h"
10 #include "base/auto_reset.h"
11 #include "base/command_line.h"
12 #include "base/debug/alias.h"
13 #include "base/debug/asan_invalid_access.h"
14 #include "base/debug/dump_without_crashing.h"
15 #include "base/i18n/char_iterator.h"
16 #include "base/metrics/histogram.h"
17 #include "base/process/kill.h"
18 #include "base/process/process.h"
19 #include "base/strings/string16.h"
20 #include "base/strings/utf_string_conversions.h"
21 #include "base/time/time.h"
22 #include "content/child/appcache/appcache_dispatcher.h"
23 #include "content/child/plugin_messages.h"
24 #include "content/child/quota_dispatcher.h"
25 #include "content/child/request_extra_data.h"
26 #include "content/child/service_worker/service_worker_handle_reference.h"
27 #include "content/child/service_worker/service_worker_network_provider.h"
28 #include "content/child/service_worker/service_worker_provider_context.h"
29 #include "content/child/service_worker/web_service_worker_provider_impl.h"
30 #include "content/child/v8_value_converter_impl.h"
31 #include "content/child/web_url_loader_impl.h"
32 #include "content/child/web_url_request_util.h"
33 #include "content/child/webmessageportchannel_impl.h"
34 #include "content/child/websocket_bridge.h"
35 #include "content/child/weburlresponse_extradata_impl.h"
36 #include "content/common/clipboard_messages.h"
37 #include "content/common/frame_messages.h"
38 #include "content/common/frame_replication_state.h"
39 #include "content/common/input_messages.h"
40 #include "content/common/service_worker/service_worker_types.h"
41 #include "content/common/swapped_out_messages.h"
42 #include "content/common/view_messages.h"
43 #include "content/public/common/bindings_policy.h"
44 #include "content/public/common/content_constants.h"
45 #include "content/public/common/content_switches.h"
46 #include "content/public/common/context_menu_params.h"
47 #include "content/public/common/page_state.h"
48 #include "content/public/common/resource_response.h"
49 #include "content/public/common/url_constants.h"
50 #include "content/public/common/url_utils.h"
51 #include "content/public/renderer/browser_plugin_delegate.h"
52 #include "content/public/renderer/content_renderer_client.h"
53 #include "content/public/renderer/context_menu_client.h"
54 #include "content/public/renderer/document_state.h"
55 #include "content/public/renderer/navigation_state.h"
56 #include "content/public/renderer/render_frame_observer.h"
57 #include "content/public/renderer/renderer_ppapi_host.h"
58 #include "content/renderer/accessibility/renderer_accessibility.h"
59 #include "content/renderer/browser_plugin/browser_plugin.h"
60 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
61 #include "content/renderer/child_frame_compositing_helper.h"
62 #include "content/renderer/context_menu_params_builder.h"
63 #include "content/renderer/devtools/devtools_agent.h"
64 #include "content/renderer/dom_automation_controller.h"
65 #include "content/renderer/dom_utils.h"
66 #include "content/renderer/external_popup_menu.h"
67 #include "content/renderer/geolocation_dispatcher.h"
68 #include "content/renderer/history_controller.h"
69 #include "content/renderer/history_serialization.h"
70 #include "content/renderer/image_loading_helper.h"
71 #include "content/renderer/ime_event_guard.h"
72 #include "content/renderer/internal_document_state_data.h"
73 #include "content/renderer/manifest/manifest_manager.h"
74 #include "content/renderer/media/audio_renderer_mixer_manager.h"
75 #include "content/renderer/media/crypto/render_cdm_factory.h"
76 #include "content/renderer/media/media_permission_dispatcher.h"
77 #include "content/renderer/media/media_stream_dispatcher.h"
78 #include "content/renderer/media/media_stream_renderer_factory.h"
79 #include "content/renderer/media/midi_dispatcher.h"
80 #include "content/renderer/media/render_media_log.h"
81 #include "content/renderer/media/user_media_client_impl.h"
82 #include "content/renderer/media/webmediaplayer_ms.h"
83 #include "content/renderer/mojo/service_registry_js_wrapper.h"
84 #include "content/renderer/notification_permission_dispatcher.h"
85 #include "content/renderer/npapi/plugin_channel_host.h"
86 #include "content/renderer/pepper/plugin_instance_throttler_impl.h"
87 #include "content/renderer/presentation/presentation_dispatcher.h"
88 #include "content/renderer/push_messaging/push_messaging_dispatcher.h"
89 #include "content/renderer/render_frame_proxy.h"
90 #include "content/renderer/render_process.h"
91 #include "content/renderer/render_thread_impl.h"
92 #include "content/renderer/render_view_impl.h"
93 #include "content/renderer/render_widget_fullscreen_pepper.h"
94 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
95 #include "content/renderer/renderer_webcolorchooser_impl.h"
96 #include "content/renderer/screen_orientation/screen_orientation_dispatcher.h"
97 #include "content/renderer/shared_worker_repository.h"
98 #include "content/renderer/websharedworker_proxy.h"
99 #include "gin/modules/module_registry.h"
100 #include "media/base/audio_renderer_mixer_input.h"
101 #include "media/base/media_log.h"
102 #include "media/blink/webencryptedmediaclient_impl.h"
103 #include "media/blink/webmediaplayer_impl.h"
104 #include "media/blink/webmediaplayer_params.h"
105 #include "media/filters/gpu_video_accelerator_factories.h"
106 #include "net/base/data_url.h"
107 #include "net/base/net_errors.h"
108 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
109 #include "net/http/http_util.h"
110 #include "third_party/WebKit/public/platform/WebStorageQuotaCallbacks.h"
111 #include "third_party/WebKit/public/platform/WebString.h"
112 #include "third_party/WebKit/public/platform/WebURL.h"
113 #include "third_party/WebKit/public/platform/WebURLError.h"
114 #include "third_party/WebKit/public/platform/WebURLResponse.h"
115 #include "third_party/WebKit/public/platform/WebVector.h"
116 #include "third_party/WebKit/public/web/WebColorSuggestion.h"
117 #include "third_party/WebKit/public/web/WebDocument.h"
118 #include "third_party/WebKit/public/web/WebFrameWidget.h"
119 #include "third_party/WebKit/public/web/WebGlyphCache.h"
120 #include "third_party/WebKit/public/web/WebLocalFrame.h"
121 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
122 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
123 #include "third_party/WebKit/public/web/WebPlugin.h"
124 #include "third_party/WebKit/public/web/WebPluginParams.h"
125 #include "third_party/WebKit/public/web/WebPluginPlaceholder.h"
126 #include "third_party/WebKit/public/web/WebRange.h"
127 #include "third_party/WebKit/public/web/WebScriptSource.h"
128 #include "third_party/WebKit/public/web/WebSearchableFormData.h"
129 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
130 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
131 #include "third_party/WebKit/public/web/WebSurroundingText.h"
132 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
133 #include "third_party/WebKit/public/web/WebView.h"
134 #include "third_party/mojo/src/mojo/edk/js/core.h"
135 #include "third_party/mojo/src/mojo/edk/js/support.h"
137 #if defined(ENABLE_PLUGINS)
138 #include "content/renderer/npapi/webplugin_impl.h"
139 #include "content/renderer/pepper/pepper_browser_connection.h"
140 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
141 #include "content/renderer/pepper/pepper_webplugin_impl.h"
142 #include "content/renderer/pepper/plugin_module.h"
145 #if defined(ENABLE_WEBRTC)
146 #include "content/renderer/media/rtc_peer_connection_handler.h"
149 #if defined(OS_ANDROID)
150 #include <cpu-features.h>
152 #include "content/common/gpu/client/context_provider_command_buffer.h"
153 #include "content/renderer/android/synchronous_compositor_factory.h"
154 #include "content/renderer/java/gin_java_bridge_dispatcher.h"
155 #include "content/renderer/media/android/renderer_media_player_manager.h"
156 #include "content/renderer/media/android/stream_texture_factory_impl.h"
157 #include "content/renderer/media/android/webmediaplayer_android.h"
159 #include "cc/blink/context_provider_web_context.h"
162 #if defined(ENABLE_PEPPER_CDMS)
163 #include "content/renderer/media/crypto/pepper_cdm_wrapper_impl.h"
164 #elif defined(ENABLE_BROWSER_CDMS)
165 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
168 #if defined(ENABLE_MEDIA_MOJO_RENDERER)
169 #include "content/renderer/media/media_renderer_service_provider.h"
170 #include "media/mojo/services/mojo_renderer_factory.h"
172 #include "media/filters/default_renderer_factory.h"
175 using blink::WebContextMenuData
;
176 using blink::WebData
;
177 using blink::WebDataSource
;
178 using blink::WebDocument
;
179 using blink::WebElement
;
180 using blink::WebExternalPopupMenu
;
181 using blink::WebExternalPopupMenuClient
;
182 using blink::WebFrame
;
183 using blink::WebHistoryItem
;
184 using blink::WebHTTPBody
;
185 using blink::WebLocalFrame
;
186 using blink::WebMediaPlayer
;
187 using blink::WebMediaPlayerClient
;
188 using blink::WebNavigationPolicy
;
189 using blink::WebNavigationType
;
190 using blink::WebNode
;
191 using blink::WebPluginParams
;
192 using blink::WebPopupMenuInfo
;
193 using blink::WebRange
;
194 using blink::WebReferrerPolicy
;
195 using blink::WebScriptSource
;
196 using blink::WebSearchableFormData
;
197 using blink::WebSecurityOrigin
;
198 using blink::WebSecurityPolicy
;
199 using blink::WebServiceWorkerProvider
;
200 using blink::WebStorageQuotaCallbacks
;
201 using blink::WebString
;
203 using blink::WebURLError
;
204 using blink::WebURLRequest
;
205 using blink::WebURLResponse
;
206 using blink::WebUserGestureIndicator
;
207 using blink::WebVector
;
208 using blink::WebView
;
210 using base::TimeDelta
;
216 const char kDefaultAcceptHeader
[] =
217 "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/"
219 const char kAcceptHeader
[] = "Accept";
221 const size_t kExtraCharsBeforeAndAfterSelection
= 100;
223 typedef std::map
<int, RenderFrameImpl
*> RoutingIDFrameMap
;
224 static base::LazyInstance
<RoutingIDFrameMap
> g_routing_id_frame_map
=
225 LAZY_INSTANCE_INITIALIZER
;
227 typedef std::map
<blink::WebFrame
*, RenderFrameImpl
*> FrameMap
;
228 base::LazyInstance
<FrameMap
> g_frame_map
= LAZY_INSTANCE_INITIALIZER
;
230 int64
ExtractPostId(HistoryEntry
* entry
) {
234 const WebHistoryItem
& item
= entry
->root();
235 if (item
.isNull() || item
.httpBody().isNull())
238 return item
.httpBody().identifier();
241 WebURLResponseExtraDataImpl
* GetExtraDataFromResponse(
242 const WebURLResponse
& response
) {
243 return static_cast<WebURLResponseExtraDataImpl
*>(response
.extraData());
246 void GetRedirectChain(WebDataSource
* ds
, std::vector
<GURL
>* result
) {
247 // Replace any occurrences of swappedout:// with about:blank.
248 const WebURL
& blank_url
= GURL(url::kAboutBlankURL
);
249 WebVector
<WebURL
> urls
;
250 ds
->redirectChain(urls
);
251 result
->reserve(urls
.size());
252 for (size_t i
= 0; i
< urls
.size(); ++i
) {
253 if (urls
[i
] != GURL(kSwappedOutURL
))
254 result
->push_back(urls
[i
]);
256 result
->push_back(blank_url
);
260 // Returns the original request url. If there is no redirect, the original
261 // url is the same as ds->request()->url(). If the WebDataSource belongs to a
262 // frame was loaded by loadData, the original url will be ds->unreachableURL()
263 GURL
GetOriginalRequestURL(WebDataSource
* ds
) {
264 // WebDataSource has unreachable URL means that the frame is loaded through
265 // blink::WebFrame::loadData(), and the base URL will be in the redirect
266 // chain. However, we never visited the baseURL. So in this case, we should
267 // use the unreachable URL as the original URL.
268 if (ds
->hasUnreachableURL())
269 return ds
->unreachableURL();
271 std::vector
<GURL
> redirects
;
272 GetRedirectChain(ds
, &redirects
);
273 if (!redirects
.empty())
274 return redirects
.at(0);
276 return ds
->originalRequest().url();
279 NOINLINE
void CrashIntentionally() {
280 // NOTE(shess): Crash directly rather than using NOTREACHED() so
281 // that the signature is easier to triage in crash reports.
282 volatile int* zero
= NULL
;
286 #if defined(ADDRESS_SANITIZER) || defined(SYZYASAN)
287 NOINLINE
void MaybeTriggerAsanError(const GURL
& url
) {
288 // NOTE(rogerm): We intentionally perform an invalid heap access here in
289 // order to trigger an Address Sanitizer (ASAN) error report.
290 const char kCrashDomain
[] = "crash";
291 const char kHeapOverflow
[] = "/heap-overflow";
292 const char kHeapUnderflow
[] = "/heap-underflow";
293 const char kUseAfterFree
[] = "/use-after-free";
294 #if defined(SYZYASAN)
295 const char kCorruptHeapBlock
[] = "/corrupt-heap-block";
296 const char kCorruptHeap
[] = "/corrupt-heap";
299 if (!url
.DomainIs(kCrashDomain
, sizeof(kCrashDomain
) - 1))
305 std::string
crash_type(url
.path());
306 if (crash_type
== kHeapOverflow
) {
307 base::debug::AsanHeapOverflow();
308 } else if (crash_type
== kHeapUnderflow
) {
309 base::debug::AsanHeapUnderflow();
310 } else if (crash_type
== kUseAfterFree
) {
311 base::debug::AsanHeapUseAfterFree();
312 #if defined(SYZYASAN)
313 } else if (crash_type
== kCorruptHeapBlock
) {
314 base::debug::AsanCorruptHeapBlock();
315 } else if (crash_type
== kCorruptHeap
) {
316 base::debug::AsanCorruptHeap();
320 #endif // ADDRESS_SANITIZER || SYZYASAN
322 void MaybeHandleDebugURL(const GURL
& url
) {
323 if (!url
.SchemeIs(kChromeUIScheme
))
325 if (url
== GURL(kChromeUICrashURL
)) {
326 CrashIntentionally();
327 } else if (url
== GURL(kChromeUIDumpURL
)) {
328 // This URL will only correctly create a crash dump file if content is
329 // hosted in a process that has correctly called
330 // base::debug::SetDumpWithoutCrashingFunction. Refer to the documentation
331 // of base::debug::DumpWithoutCrashing for more details.
332 base::debug::DumpWithoutCrashing();
333 } else if (url
== GURL(kChromeUIKillURL
)) {
334 base::KillProcess(base::GetCurrentProcessHandle(), 1, false);
335 } else if (url
== GURL(kChromeUIHangURL
)) {
337 base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
339 } else if (url
== GURL(kChromeUIShorthangURL
)) {
340 base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
343 #if defined(ADDRESS_SANITIZER) || defined(SYZYASAN)
344 MaybeTriggerAsanError(url
);
345 #endif // ADDRESS_SANITIZER || SYZYASAN
348 // Returns false unless this is a top-level navigation.
349 bool IsTopLevelNavigation(WebFrame
* frame
) {
350 return frame
->parent() == NULL
;
353 // Returns false unless this is a top-level navigation that crosses origins.
354 bool IsNonLocalTopLevelNavigation(const GURL
& url
,
356 WebNavigationType type
,
358 if (!IsTopLevelNavigation(frame
))
361 // Navigations initiated within Webkit are not sent out to the external host
362 // in the following cases.
363 // 1. The url scheme is not http/https
364 // 2. The origin of the url and the opener is the same in which case the
365 // opener relationship is maintained.
366 // 3. Reloads/form submits/back forward navigations
367 if (!url
.SchemeIs(url::kHttpScheme
) && !url
.SchemeIs(url::kHttpsScheme
))
370 if (type
!= blink::WebNavigationTypeReload
&&
371 type
!= blink::WebNavigationTypeBackForward
&& !is_form_post
) {
372 // The opener relationship between the new window and the parent allows the
373 // new window to script the parent and vice versa. This is not allowed if
374 // the origins of the two domains are different. This can be treated as a
375 // top level navigation and routed back to the host.
376 blink::WebFrame
* opener
= frame
->opener();
380 if (url
.GetOrigin() != GURL(opener
->document().url()).GetOrigin())
386 WebURLRequest
CreateURLRequestForNavigation(
387 const CommonNavigationParams
& common_params
,
388 scoped_ptr
<StreamOverrideParameters
> stream_override
,
389 bool is_view_source_mode_enabled
) {
390 WebURLRequest
request(common_params
.url
);
391 if (is_view_source_mode_enabled
)
392 request
.setCachePolicy(WebURLRequest::ReturnCacheDataElseLoad
);
394 if (common_params
.referrer
.url
.is_valid()) {
395 WebString web_referrer
= WebSecurityPolicy::generateReferrerHeader(
396 common_params
.referrer
.policy
,
398 WebString::fromUTF8(common_params
.referrer
.url
.spec()));
399 if (!web_referrer
.isEmpty())
400 request
.setHTTPReferrer(web_referrer
, common_params
.referrer
.policy
);
403 RequestExtraData
* extra_data
= new RequestExtraData();
404 extra_data
->set_stream_override(stream_override
.Pass());
405 request
.setExtraData(extra_data
);
407 // Set the ui timestamp for this navigation. Currently the timestamp here is
408 // only non empty when the navigation was triggered by an Android intent. The
409 // timestamp is converted to a double version supported by blink. It will be
410 // passed back to the browser in the DidCommitProvisionalLoad and the
411 // DocumentLoadComplete IPCs.
412 base::TimeDelta ui_timestamp
= common_params
.ui_timestamp
- base::TimeTicks();
413 request
.setUiStartTime(ui_timestamp
.InSecondsF());
414 request
.setInputPerfMetricReportPolicy(
415 static_cast<WebURLRequest::InputToLoadPerfMetricReportPolicy
>(
416 common_params
.report_type
));
420 void UpdateFrameNavigationTiming(WebFrame
* frame
,
421 base::TimeTicks browser_navigation_start
,
422 base::TimeTicks renderer_navigation_start
) {
423 // The browser provides the navigation_start time to bootstrap the
424 // Navigation Timing information for the browser-initiated navigations. In
425 // case of cross-process navigations, this carries over the time of
426 // finishing the onbeforeunload handler of the previous page.
427 DCHECK(!browser_navigation_start
.is_null());
428 if (frame
->provisionalDataSource()) {
429 // |browser_navigation_start| is likely before this process existed, so we
430 // can't use InterProcessTimeTicksConverter. We need at least to ensure
431 // that the browser-side navigation start we set is not later than the one
432 // on the renderer side.
433 base::TimeTicks navigation_start
= std::min(
434 browser_navigation_start
, renderer_navigation_start
);
435 double navigation_start_seconds
=
436 (navigation_start
- base::TimeTicks()).InSecondsF();
437 frame
->provisionalDataSource()->setNavigationStartTime(
438 navigation_start_seconds
);
439 // TODO(clamy): We need to provide additional timing values for the
440 // Navigation Timing API to work with browser-side navigations.
445 CommonNavigationParams
MakeCommonNavigationParams(
446 blink::WebURLRequest
* request
) {
447 const RequestExtraData kEmptyData
;
448 const RequestExtraData
* extra_data
=
449 static_cast<RequestExtraData
*>(request
->extraData());
451 extra_data
= &kEmptyData
;
452 CommonNavigationParams params
;
453 params
.url
= request
->url();
454 params
.referrer
= Referrer(
455 GURL(request
->httpHeaderField(WebString::fromUTF8("Referer")).latin1()),
456 request
->referrerPolicy());
457 params
.transition
= extra_data
->transition_type();
459 // Set the ui timestamp for this navigation. Currently the timestamp here is
460 // only non empty when the navigation was triggered by an Android intent, or
461 // by the user clicking on a link. The timestamp is converted from a double
462 // version supported by blink. It will be passed back to the renderer in the
463 // CommitNavigation IPC, and then back to the browser again in the
464 // DidCommitProvisionalLoad and the DocumentLoadComplete IPCs.
465 params
.ui_timestamp
=
466 base::TimeTicks() + base::TimeDelta::FromSecondsD(request
->uiStartTime());
467 params
.report_type
= static_cast<FrameMsg_UILoadMetricsReportType::Value
>(
468 request
->inputPerfMetricReportPolicy());
472 #if !defined(OS_ANDROID)
473 media::Context3D
GetSharedMainThreadContext3D() {
474 cc::ContextProvider
* provider
=
475 RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
477 return media::Context3D();
478 return media::Context3D(provider
->ContextGL(), provider
->GrContext());
482 RenderFrameImpl::CreateRenderFrameImplFunction g_create_render_frame_impl
=
485 #define STATIC_ASSERT_MATCHING_ENUMS(content_name, blink_name) \
487 static_cast<int>(content_name) == static_cast<int>(blink_name), \
488 "enum values must match")
490 // Check that blink::WebSandboxFlags is kept in sync with
491 // content::SandboxFlags.
492 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::NONE
,
493 blink::WebSandboxFlags::None
);
494 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::NAVIGATION
,
495 blink::WebSandboxFlags::Navigation
);
496 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::PLUGINS
,
497 blink::WebSandboxFlags::Plugins
);
498 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::ORIGIN
,
499 blink::WebSandboxFlags::Origin
);
500 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::FORMS
,
501 blink::WebSandboxFlags::Forms
);
502 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::SCRIPTS
,
503 blink::WebSandboxFlags::Scripts
);
504 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::TOP_NAVIGATION
,
505 blink::WebSandboxFlags::TopNavigation
);
506 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::POPUPS
,
507 blink::WebSandboxFlags::Popups
);
508 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::AUTOMATIC_FEATURES
,
509 blink::WebSandboxFlags::AutomaticFeatures
);
510 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::POINTER_LOCK
,
511 blink::WebSandboxFlags::PointerLock
);
512 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::DOCUMENT_DOMAIN
,
513 blink::WebSandboxFlags::DocumentDomain
);
514 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::ORIENTATION_LOCK
,
515 blink::WebSandboxFlags::OrientationLock
);
516 STATIC_ASSERT_MATCHING_ENUMS(SandboxFlags::ALL
,
517 blink::WebSandboxFlags::All
);
522 RenderFrameImpl
* RenderFrameImpl::Create(RenderViewImpl
* render_view
,
524 DCHECK(routing_id
!= MSG_ROUTING_NONE
);
526 if (g_create_render_frame_impl
)
527 return g_create_render_frame_impl(render_view
, routing_id
);
529 return new RenderFrameImpl(render_view
, routing_id
);
533 RenderFrameImpl
* RenderFrameImpl::FromRoutingID(int32 routing_id
) {
534 RoutingIDFrameMap::iterator iter
=
535 g_routing_id_frame_map
.Get().find(routing_id
);
536 if (iter
!= g_routing_id_frame_map
.Get().end())
542 void RenderFrameImpl::CreateFrame(
544 int parent_routing_id
,
545 int proxy_routing_id
,
546 const FrameReplicationState
& replicated_state
,
547 CompositorDependencies
* compositor_deps
,
548 const FrameMsg_NewFrame_WidgetParams
& widget_params
) {
549 // TODO(nasko): For now, this message is only sent for subframes, as the
550 // top level frame is created when the RenderView is created through the
552 CHECK_NE(MSG_ROUTING_NONE
, parent_routing_id
);
554 blink::WebLocalFrame
* web_frame
;
555 RenderFrameImpl
* render_frame
;
556 if (proxy_routing_id
== MSG_ROUTING_NONE
) {
557 RenderFrameProxy
* parent_proxy
=
558 RenderFrameProxy::FromRoutingID(parent_routing_id
);
559 // If the browser is sending a valid parent routing id, it should already
560 // be created and registered.
562 blink::WebRemoteFrame
* parent_web_frame
= parent_proxy
->web_frame();
564 // Create the RenderFrame and WebLocalFrame, linking the two.
566 RenderFrameImpl::Create(parent_proxy
->render_view(), routing_id
);
567 web_frame
= parent_web_frame
->createLocalChild(
568 WebString::fromUTF8(replicated_state
.name
),
569 ContentToWebSandboxFlags(replicated_state
.sandbox_flags
), render_frame
);
571 RenderFrameProxy
* proxy
=
572 RenderFrameProxy::FromRoutingID(proxy_routing_id
);
574 render_frame
= RenderFrameImpl::Create(proxy
->render_view(), routing_id
);
575 web_frame
= blink::WebLocalFrame::create(render_frame
);
576 render_frame
->proxy_routing_id_
= proxy_routing_id
;
577 web_frame
->initializeToReplaceRemoteFrame(proxy
->web_frame());
579 render_frame
->SetWebFrame(web_frame
);
581 if (widget_params
.routing_id
!= MSG_ROUTING_NONE
) {
582 CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
583 switches::kSitePerProcess
));
584 render_frame
->render_widget_
= RenderWidget::CreateForFrame(
585 widget_params
.routing_id
, widget_params
.surface_id
,
586 widget_params
.hidden
, render_frame
->render_view_
->screen_info(),
587 compositor_deps
, web_frame
);
588 // TODO(kenrb): Observing shouldn't be necessary when we sort out
589 // WasShown and WasHidden, separating page-level visibility from
590 // frame-level visibility.
591 render_frame
->render_widget_
->RegisterRenderFrame(render_frame
);
594 render_frame
->Initialize();
598 RenderFrame
* RenderFrame::FromWebFrame(blink::WebFrame
* web_frame
) {
599 return RenderFrameImpl::FromWebFrame(web_frame
);
603 RenderFrameImpl
* RenderFrameImpl::FromWebFrame(blink::WebFrame
* web_frame
) {
604 FrameMap::iterator iter
= g_frame_map
.Get().find(web_frame
);
605 if (iter
!= g_frame_map
.Get().end())
611 void RenderFrameImpl::InstallCreateHook(
612 CreateRenderFrameImplFunction create_render_frame_impl
) {
613 CHECK(!g_create_render_frame_impl
);
614 g_create_render_frame_impl
= create_render_frame_impl
;
618 content::SandboxFlags
RenderFrameImpl::WebToContentSandboxFlags(
619 blink::WebSandboxFlags flags
) {
620 return static_cast<content::SandboxFlags
>(flags
);
624 blink::WebSandboxFlags
RenderFrameImpl::ContentToWebSandboxFlags(
625 content::SandboxFlags flags
) {
626 return static_cast<blink::WebSandboxFlags
>(flags
);
629 // RenderFrameImpl ----------------------------------------------------------
630 RenderFrameImpl::RenderFrameImpl(RenderViewImpl
* render_view
, int routing_id
)
632 render_view_(render_view
->AsWeakPtr()),
633 routing_id_(routing_id
),
634 is_swapped_out_(false),
635 render_frame_proxy_(NULL
),
636 is_detaching_(false),
637 proxy_routing_id_(MSG_ROUTING_NONE
),
638 #if defined(ENABLE_PLUGINS)
639 plugin_power_saver_helper_(NULL
),
642 selection_text_offset_(0),
643 selection_range_(gfx::Range::InvalidRange()),
644 handling_select_range_(false),
645 notification_permission_dispatcher_(NULL
),
646 web_user_media_client_(NULL
),
647 media_permission_dispatcher_(NULL
),
648 midi_dispatcher_(NULL
),
649 #if defined(OS_ANDROID)
650 media_player_manager_(NULL
),
652 #if defined(ENABLE_BROWSER_CDMS)
655 #if defined(VIDEO_HOLE)
656 contains_media_player_(false),
658 geolocation_dispatcher_(NULL
),
659 push_messaging_dispatcher_(NULL
),
660 presentation_dispatcher_(NULL
),
661 screen_orientation_dispatcher_(NULL
),
662 manifest_manager_(NULL
),
663 accessibility_mode_(AccessibilityModeOff
),
664 renderer_accessibility_(NULL
),
665 weak_factory_(this) {
666 std::pair
<RoutingIDFrameMap::iterator
, bool> result
=
667 g_routing_id_frame_map
.Get().insert(std::make_pair(routing_id_
, this));
668 CHECK(result
.second
) << "Inserting a duplicate item.";
670 RenderThread::Get()->AddRoute(routing_id_
, this);
672 render_view_
->RegisterRenderFrame(this);
674 // Everything below subclasses RenderFrameObserver and is automatically
675 // deleted when the RenderFrame gets deleted.
676 #if defined(OS_ANDROID)
677 new GinJavaBridgeDispatcher(this);
680 #if defined(ENABLE_PLUGINS)
681 plugin_power_saver_helper_
= new PluginPowerSaverHelper(this);
684 manifest_manager_
= new ManifestManager(this);
687 RenderFrameImpl::~RenderFrameImpl() {
688 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, RenderFrameGone());
689 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, OnDestruct());
691 #if defined(VIDEO_HOLE)
692 if (contains_media_player_
)
693 render_view_
->UnregisterVideoHoleFrame(this);
696 if (render_frame_proxy_
)
697 delete render_frame_proxy_
;
699 render_view_
->UnregisterRenderFrame(this);
700 g_routing_id_frame_map
.Get().erase(routing_id_
);
701 RenderThread::Get()->RemoveRoute(routing_id_
);
704 void RenderFrameImpl::SetWebFrame(blink::WebLocalFrame
* web_frame
) {
707 std::pair
<FrameMap::iterator
, bool> result
= g_frame_map
.Get().insert(
708 std::make_pair(web_frame
, this));
709 CHECK(result
.second
) << "Inserting a duplicate item.";
714 void RenderFrameImpl::Initialize() {
715 #if defined(ENABLE_PLUGINS)
716 new PepperBrowserConnection(this);
718 new SharedWorkerRepository(this);
720 if (!frame_
->parent())
721 new ImageLoadingHelper(this);
723 // We delay calling this until we have the WebFrame so that any observer or
724 // embedder can call GetWebFrame on any RenderFrame.
725 GetContentClient()->renderer()->RenderFrameCreated(this);
728 RenderWidget
* RenderFrameImpl::GetRenderWidget() {
729 return render_view_
.get();
732 #if defined(ENABLE_PLUGINS)
733 void RenderFrameImpl::PepperPluginCreated(RendererPpapiHost
* host
) {
734 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
,
735 DidCreatePepperPlugin(host
));
736 if (host
->GetPluginName() == kFlashPluginName
) {
737 RenderThread::Get()->RecordAction(
738 base::UserMetricsAction("FrameLoadWithFlash"));
742 void RenderFrameImpl::PepperDidChangeCursor(
743 PepperPluginInstanceImpl
* instance
,
744 const blink::WebCursorInfo
& cursor
) {
745 // Update the cursor appearance immediately if the requesting plugin is the
746 // one which receives the last mouse event. Otherwise, the new cursor won't be
747 // picked up until the plugin gets the next input event. That is bad if, e.g.,
748 // the plugin would like to set an invisible cursor when there isn't any user
749 // input for a while.
750 if (instance
== render_view_
->pepper_last_mouse_event_target())
751 GetRenderWidget()->didChangeCursor(cursor
);
754 void RenderFrameImpl::PepperDidReceiveMouseEvent(
755 PepperPluginInstanceImpl
* instance
) {
756 render_view_
->set_pepper_last_mouse_event_target(instance
);
759 void RenderFrameImpl::PepperTextInputTypeChanged(
760 PepperPluginInstanceImpl
* instance
) {
761 if (instance
!= render_view_
->focused_pepper_plugin())
764 GetRenderWidget()->UpdateTextInputType();
766 FocusedNodeChangedForAccessibility(WebNode());
769 void RenderFrameImpl::PepperCaretPositionChanged(
770 PepperPluginInstanceImpl
* instance
) {
771 if (instance
!= render_view_
->focused_pepper_plugin())
773 GetRenderWidget()->UpdateSelectionBounds();
776 void RenderFrameImpl::PepperCancelComposition(
777 PepperPluginInstanceImpl
* instance
) {
778 if (instance
!= render_view_
->focused_pepper_plugin())
780 Send(new InputHostMsg_ImeCancelComposition(render_view_
->GetRoutingID()));;
781 #if defined(OS_MACOSX) || defined(USE_AURA)
782 GetRenderWidget()->UpdateCompositionInfo(true);
786 void RenderFrameImpl::PepperSelectionChanged(
787 PepperPluginInstanceImpl
* instance
) {
788 if (instance
!= render_view_
->focused_pepper_plugin())
790 SyncSelectionIfRequired();
793 RenderWidgetFullscreenPepper
* RenderFrameImpl::CreatePepperFullscreenContainer(
794 PepperPluginInstanceImpl
* plugin
) {
796 if (render_view_
->webview() && render_view_
->webview()->mainFrame())
797 active_url
= GURL(render_view_
->webview()->mainFrame()->document().url());
798 RenderWidgetFullscreenPepper
* widget
= RenderWidgetFullscreenPepper::Create(
799 GetRenderWidget()->routing_id(), GetRenderWidget()->compositor_deps(),
800 plugin
, active_url
, GetRenderWidget()->screenInfo());
801 widget
->show(blink::WebNavigationPolicyIgnore
);
805 bool RenderFrameImpl::IsPepperAcceptingCompositionEvents() const {
806 if (!render_view_
->focused_pepper_plugin())
808 return render_view_
->focused_pepper_plugin()->
809 IsPluginAcceptingCompositionEvents();
812 void RenderFrameImpl::PluginCrashed(const base::FilePath
& plugin_path
,
813 base::ProcessId plugin_pid
) {
814 // TODO(jam): dispatch this IPC in RenderFrameHost and switch to use
815 // routing_id_ as a result.
816 Send(new FrameHostMsg_PluginCrashed(routing_id_
, plugin_path
, plugin_pid
));
819 void RenderFrameImpl::SimulateImeSetComposition(
820 const base::string16
& text
,
821 const std::vector
<blink::WebCompositionUnderline
>& underlines
,
824 render_view_
->OnImeSetComposition(
825 text
, underlines
, selection_start
, selection_end
);
828 void RenderFrameImpl::SimulateImeConfirmComposition(
829 const base::string16
& text
,
830 const gfx::Range
& replacement_range
) {
831 render_view_
->OnImeConfirmComposition(text
, replacement_range
, false);
834 void RenderFrameImpl::OnImeSetComposition(
835 const base::string16
& text
,
836 const std::vector
<blink::WebCompositionUnderline
>& underlines
,
839 // When a PPAPI plugin has focus, we bypass WebKit.
840 if (!IsPepperAcceptingCompositionEvents()) {
841 pepper_composition_text_
= text
;
843 // TODO(kinaba) currently all composition events are sent directly to
844 // plugins. Use DOM event mechanism after WebKit is made aware about
845 // plugins that support composition.
846 // The code below mimics the behavior of WebCore::Editor::setComposition.
848 // Empty -> nonempty: composition started.
849 if (pepper_composition_text_
.empty() && !text
.empty()) {
850 render_view_
->focused_pepper_plugin()->HandleCompositionStart(
853 // Nonempty -> empty: composition canceled.
854 if (!pepper_composition_text_
.empty() && text
.empty()) {
855 render_view_
->focused_pepper_plugin()->HandleCompositionEnd(
858 pepper_composition_text_
= text
;
859 // Nonempty: composition is ongoing.
860 if (!pepper_composition_text_
.empty()) {
861 render_view_
->focused_pepper_plugin()->HandleCompositionUpdate(
862 pepper_composition_text_
, underlines
, selection_start
,
868 void RenderFrameImpl::OnImeConfirmComposition(
869 const base::string16
& text
,
870 const gfx::Range
& replacement_range
,
871 bool keep_selection
) {
872 // When a PPAPI plugin has focus, we bypass WebKit.
873 // Here, text.empty() has a special meaning. It means to commit the last
874 // update of composition text (see
875 // RenderWidgetHost::ImeConfirmComposition()).
876 const base::string16
& last_text
= text
.empty() ? pepper_composition_text_
879 // last_text is empty only when both text and pepper_composition_text_ is.
881 if (last_text
.empty())
884 if (!IsPepperAcceptingCompositionEvents()) {
885 base::i18n::UTF16CharIterator
iterator(&last_text
);
887 while (iterator
.Advance()) {
888 blink::WebKeyboardEvent char_event
;
889 char_event
.type
= blink::WebInputEvent::Char
;
890 char_event
.timeStampSeconds
= base::Time::Now().ToDoubleT();
891 char_event
.modifiers
= 0;
892 char_event
.windowsKeyCode
= last_text
[i
];
893 char_event
.nativeKeyCode
= last_text
[i
];
895 const int32 char_start
= i
;
896 for (; i
< iterator
.array_pos(); ++i
) {
897 char_event
.text
[i
- char_start
] = last_text
[i
];
898 char_event
.unmodifiedText
[i
- char_start
] = last_text
[i
];
901 if (GetRenderWidget()->webwidget())
902 GetRenderWidget()->webwidget()->handleInputEvent(char_event
);
905 // Mimics the order of events sent by WebKit.
906 // See WebCore::Editor::setComposition() for the corresponding code.
907 render_view_
->focused_pepper_plugin()->HandleCompositionEnd(last_text
);
908 render_view_
->focused_pepper_plugin()->HandleTextInput(last_text
);
910 pepper_composition_text_
.clear();
912 #endif // defined(ENABLE_PLUGINS)
914 MediaStreamDispatcher
* RenderFrameImpl::GetMediaStreamDispatcher() {
915 if (!web_user_media_client_
)
916 InitializeUserMediaClient();
917 return web_user_media_client_
?
918 web_user_media_client_
->media_stream_dispatcher() : NULL
;
921 bool RenderFrameImpl::Send(IPC::Message
* message
) {
926 if (is_swapped_out_
) {
927 if (!SwappedOutMessages::CanSendWhileSwappedOut(message
)) {
933 return RenderThread::Get()->Send(message
);
936 #if defined(OS_MACOSX) || defined(OS_ANDROID)
937 void RenderFrameImpl::DidHideExternalPopupMenu() {
938 // We need to clear external_popup_menu_ as soon as ExternalPopupMenu::close
939 // is called. Otherwise, createExternalPopupMenu() for new popup will fail.
940 external_popup_menu_
.reset();
944 bool RenderFrameImpl::OnMessageReceived(const IPC::Message
& msg
) {
945 // TODO(kenrb): document() should not be null, but as a transitional step
946 // we have RenderFrameProxy 'wrapping' a RenderFrameImpl, passing messages
947 // to this method. This happens for a top-level remote frame, where a
948 // document-less RenderFrame is replaced by a RenderFrameProxy but kept
949 // around and is still able to receive messages.
950 if (!frame_
->document().isNull())
951 GetContentClient()->SetActiveURL(frame_
->document().url());
953 ObserverListBase
<RenderFrameObserver
>::Iterator
it(observers_
);
954 RenderFrameObserver
* observer
;
955 while ((observer
= it
.GetNext()) != NULL
) {
956 if (observer
->OnMessageReceived(msg
))
961 IPC_BEGIN_MESSAGE_MAP(RenderFrameImpl
, msg
)
962 IPC_MESSAGE_HANDLER(FrameMsg_Navigate
, OnNavigate
)
963 IPC_MESSAGE_HANDLER(FrameMsg_BeforeUnload
, OnBeforeUnload
)
964 IPC_MESSAGE_HANDLER(FrameMsg_SwapOut
, OnSwapOut
)
965 IPC_MESSAGE_HANDLER(FrameMsg_Stop
, OnStop
)
966 IPC_MESSAGE_HANDLER(FrameMsg_ContextMenuClosed
, OnContextMenuClosed
)
967 IPC_MESSAGE_HANDLER(FrameMsg_CustomContextMenuAction
,
968 OnCustomContextMenuAction
)
969 IPC_MESSAGE_HANDLER(InputMsg_Undo
, OnUndo
)
970 IPC_MESSAGE_HANDLER(InputMsg_Redo
, OnRedo
)
971 IPC_MESSAGE_HANDLER(InputMsg_Cut
, OnCut
)
972 IPC_MESSAGE_HANDLER(InputMsg_Copy
, OnCopy
)
973 IPC_MESSAGE_HANDLER(InputMsg_Paste
, OnPaste
)
974 IPC_MESSAGE_HANDLER(InputMsg_PasteAndMatchStyle
, OnPasteAndMatchStyle
)
975 IPC_MESSAGE_HANDLER(InputMsg_Delete
, OnDelete
)
976 IPC_MESSAGE_HANDLER(InputMsg_SelectAll
, OnSelectAll
)
977 IPC_MESSAGE_HANDLER(InputMsg_SelectRange
, OnSelectRange
)
978 IPC_MESSAGE_HANDLER(InputMsg_Unselect
, OnUnselect
)
979 IPC_MESSAGE_HANDLER(InputMsg_MoveRangeSelectionExtent
,
980 OnMoveRangeSelectionExtent
)
981 IPC_MESSAGE_HANDLER(InputMsg_Replace
, OnReplace
)
982 IPC_MESSAGE_HANDLER(InputMsg_ReplaceMisspelling
, OnReplaceMisspelling
)
983 IPC_MESSAGE_HANDLER(InputMsg_ExtendSelectionAndDelete
,
984 OnExtendSelectionAndDelete
)
985 IPC_MESSAGE_HANDLER(InputMsg_SetCompositionFromExistingText
,
986 OnSetCompositionFromExistingText
)
987 IPC_MESSAGE_HANDLER(InputMsg_ExecuteNoValueEditCommand
,
988 OnExecuteNoValueEditCommand
)
989 IPC_MESSAGE_HANDLER(FrameMsg_CSSInsertRequest
, OnCSSInsertRequest
)
990 IPC_MESSAGE_HANDLER(FrameMsg_JavaScriptExecuteRequest
,
991 OnJavaScriptExecuteRequest
)
992 IPC_MESSAGE_HANDLER(FrameMsg_JavaScriptExecuteRequestForTests
,
993 OnJavaScriptExecuteRequestForTests
)
994 IPC_MESSAGE_HANDLER(FrameMsg_VisualStateRequest
,
995 OnVisualStateRequest
)
996 IPC_MESSAGE_HANDLER(FrameMsg_SetEditableSelectionOffsets
,
997 OnSetEditableSelectionOffsets
)
998 IPC_MESSAGE_HANDLER(FrameMsg_SetupTransitionView
, OnSetupTransitionView
)
999 IPC_MESSAGE_HANDLER(FrameMsg_BeginExitTransition
, OnBeginExitTransition
)
1000 IPC_MESSAGE_HANDLER(FrameMsg_RevertExitTransition
, OnRevertExitTransition
)
1001 IPC_MESSAGE_HANDLER(FrameMsg_HideTransitionElements
,
1002 OnHideTransitionElements
)
1003 IPC_MESSAGE_HANDLER(FrameMsg_ShowTransitionElements
,
1004 OnShowTransitionElements
)
1005 IPC_MESSAGE_HANDLER(FrameMsg_Reload
, OnReload
)
1006 IPC_MESSAGE_HANDLER(FrameMsg_TextSurroundingSelectionRequest
,
1007 OnTextSurroundingSelectionRequest
)
1008 IPC_MESSAGE_HANDLER(FrameMsg_AddStyleSheetByURL
,
1009 OnAddStyleSheetByURL
)
1010 IPC_MESSAGE_HANDLER(FrameMsg_SetAccessibilityMode
,
1011 OnSetAccessibilityMode
)
1012 IPC_MESSAGE_HANDLER(FrameMsg_DisownOpener
, OnDisownOpener
)
1013 IPC_MESSAGE_HANDLER(FrameMsg_CommitNavigation
, OnCommitNavigation
)
1014 #if defined(OS_ANDROID)
1015 IPC_MESSAGE_HANDLER(FrameMsg_SelectPopupMenuItems
, OnSelectPopupMenuItems
)
1016 #elif defined(OS_MACOSX)
1017 IPC_MESSAGE_HANDLER(FrameMsg_SelectPopupMenuItem
, OnSelectPopupMenuItem
)
1018 IPC_MESSAGE_HANDLER(InputMsg_CopyToFindPboard
, OnCopyToFindPboard
)
1020 IPC_END_MESSAGE_MAP()
1025 void RenderFrameImpl::OnNavigate(const FrameMsg_Navigate_Params
& params
) {
1026 TRACE_EVENT2("navigation", "RenderFrameImpl::OnNavigate",
1028 "url", params
.common_params
.url
.possibly_invalid_spec());
1031 RenderViewImpl::IsReload(params
.common_params
.navigation_type
);
1032 bool is_history_navigation
= params
.commit_params
.page_state
.IsValid();
1033 WebURLRequest::CachePolicy cache_policy
=
1034 WebURLRequest::UseProtocolCachePolicy
;
1035 if (!RenderFrameImpl::PrepareRenderViewForNavigation(
1036 params
.common_params
.url
, true, is_history_navigation
,
1037 params
.current_history_list_offset
, &is_reload
, &cache_policy
)) {
1038 Send(new FrameHostMsg_DidDropNavigation(routing_id_
));
1042 render_view_
->history_list_offset_
= params
.current_history_list_offset
;
1043 render_view_
->history_list_length_
= params
.current_history_list_length
;
1044 if (params
.should_clear_history_list
) {
1045 CHECK_EQ(-1, render_view_
->history_list_offset_
);
1046 CHECK_EQ(0, render_view_
->history_list_length_
);
1049 GetContentClient()->SetActiveURL(params
.common_params
.url
);
1051 WebFrame
* frame
= frame_
;
1052 if (!params
.frame_to_navigate
.empty()) {
1053 // TODO(nasko): Move this lookup to the browser process.
1054 frame
= render_view_
->webview()->findFrameByName(
1055 WebString::fromUTF8(params
.frame_to_navigate
));
1056 CHECK(frame
) << "Invalid frame name passed: " << params
.frame_to_navigate
;
1059 if (is_reload
&& !render_view_
->history_controller()->GetCurrentEntry()) {
1060 // We cannot reload if we do not have any history state. This happens, for
1061 // example, when recovering from a crash.
1063 cache_policy
= WebURLRequest::ReloadIgnoringCacheData
;
1066 render_view_
->pending_navigation_params_
.reset(
1067 new FrameMsg_Navigate_Params(params
));
1069 // If we are reloading, then WebKit will use the history state of the current
1070 // page, so we should just ignore any given history state. Otherwise, if we
1071 // have history state, then we need to navigate to it, which corresponds to a
1072 // back/forward navigation event.
1074 bool reload_original_url
=
1075 (params
.common_params
.navigation_type
==
1076 FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL
);
1077 bool ignore_cache
= (params
.common_params
.navigation_type
==
1078 FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE
);
1080 if (reload_original_url
)
1081 frame
->reloadWithOverrideURL(params
.common_params
.url
, true);
1083 frame
->reload(ignore_cache
);
1084 } else if (is_history_navigation
) {
1085 // We must know the page ID of the page we are navigating back to.
1086 DCHECK_NE(params
.page_id
, -1);
1087 scoped_ptr
<HistoryEntry
> entry
=
1088 PageStateToHistoryEntry(params
.commit_params
.page_state
);
1090 // Ensure we didn't save the swapped out URL in UpdateState, since the
1091 // browser should never be telling us to navigate to swappedout://.
1092 CHECK(entry
->root().urlString() != WebString::fromUTF8(kSwappedOutURL
));
1093 render_view_
->history_controller()->GoToEntry(entry
.Pass(), cache_policy
);
1095 } else if (!params
.base_url_for_data_url
.is_empty()) {
1096 // A loadData request with a specified base URL.
1097 std::string mime_type
, charset
, data
;
1098 if (net::DataURL::Parse(
1099 params
.common_params
.url
, &mime_type
, &charset
, &data
)) {
1101 WebData(data
.c_str(), data
.length()),
1102 WebString::fromUTF8(mime_type
),
1103 WebString::fromUTF8(charset
),
1104 params
.base_url_for_data_url
,
1105 params
.history_url_for_data_url
,
1108 CHECK(false) << "Invalid URL passed: "
1109 << params
.common_params
.url
.possibly_invalid_spec();
1112 // Navigate to the given URL.
1113 WebURLRequest request
=
1114 CreateURLRequestForNavigation(params
.common_params
,
1115 scoped_ptr
<StreamOverrideParameters
>(),
1116 frame
->isViewSourceModeEnabled());
1118 if (!params
.extra_headers
.empty()) {
1119 for (net::HttpUtil::HeadersIterator
i(params
.extra_headers
.begin(),
1120 params
.extra_headers
.end(),
1123 request
.addHTTPHeaderField(WebString::fromUTF8(i
.name()),
1124 WebString::fromUTF8(i
.values()));
1128 if (params
.is_post
) {
1129 request
.setHTTPMethod(WebString::fromUTF8("POST"));
1132 WebHTTPBody http_body
;
1133 http_body
.initialize();
1134 const char* data
= NULL
;
1135 if (params
.browser_initiated_post_data
.size()) {
1136 data
= reinterpret_cast<const char*>(
1137 ¶ms
.browser_initiated_post_data
.front());
1139 http_body
.appendData(
1140 WebData(data
, params
.browser_initiated_post_data
.size()));
1141 request
.setHTTPBody(http_body
);
1144 // A session history navigation should have been accompanied by state.
1145 CHECK_EQ(params
.page_id
, -1);
1147 // Record this before starting the load, we need a lower bound of this time
1148 // to sanitize the navigationStart override set below.
1149 base::TimeTicks renderer_navigation_start
= base::TimeTicks::Now();
1150 frame
->loadRequest(request
);
1152 UpdateFrameNavigationTiming(
1153 frame
, params
.commit_params
.browser_navigation_start
,
1154 renderer_navigation_start
);
1157 // In case LoadRequest failed before DidCreateDataSource was called.
1158 render_view_
->pending_navigation_params_
.reset();
1161 void RenderFrameImpl::NavigateToSwappedOutURL() {
1162 // We use loadRequest instead of loadHTMLString because the former commits
1163 // synchronously. Otherwise a new navigation can interrupt the navigation
1164 // to kSwappedOutURL. If that happens to be to the page we had been
1165 // showing, then WebKit will never send a commit and we'll be left spinning.
1166 // Set the is_swapped_out_ bit to true, so IPC filtering is in effect and
1167 // the navigation to swappedout:// is not announced to the browser side.
1168 is_swapped_out_
= true;
1169 GURL
swappedOutURL(kSwappedOutURL
);
1170 WebURLRequest
request(swappedOutURL
);
1171 frame_
->loadRequest(request
);
1174 void RenderFrameImpl::BindServiceRegistry(
1175 mojo::InterfaceRequest
<mojo::ServiceProvider
> services
,
1176 mojo::ServiceProviderPtr exposed_services
) {
1177 service_registry_
.Bind(services
.Pass());
1178 service_registry_
.BindRemoteServiceProvider(exposed_services
.Pass());
1181 ManifestManager
* RenderFrameImpl::manifest_manager() {
1182 return manifest_manager_
;
1185 void RenderFrameImpl::OnBeforeUnload() {
1186 TRACE_EVENT1("navigation", "RenderFrameImpl::OnBeforeUnload",
1188 // TODO(creis): Right now, this is only called on the main frame. Make the
1189 // browser process send dispatchBeforeUnloadEvent to every frame that needs
1191 CHECK(!frame_
->parent());
1193 base::TimeTicks before_unload_start_time
= base::TimeTicks::Now();
1194 bool proceed
= frame_
->dispatchBeforeUnloadEvent();
1195 base::TimeTicks before_unload_end_time
= base::TimeTicks::Now();
1196 Send(new FrameHostMsg_BeforeUnload_ACK(routing_id_
, proceed
,
1197 before_unload_start_time
,
1198 before_unload_end_time
));
1201 void RenderFrameImpl::OnSwapOut(
1202 int proxy_routing_id
,
1204 const FrameReplicationState
& replicated_frame_state
) {
1205 TRACE_EVENT1("navigation", "RenderFrameImpl::OnSwapOut", "id", routing_id_
);
1206 RenderFrameProxy
* proxy
= NULL
;
1207 bool is_site_per_process
= base::CommandLine::ForCurrentProcess()->HasSwitch(
1208 switches::kSitePerProcess
);
1209 bool is_main_frame
= !frame_
->parent();
1211 // Only run unload if we're not swapped out yet, but send the ack either way.
1212 if (!is_swapped_out_
) {
1213 // Swap this RenderFrame out so the frame can navigate to a page rendered by
1214 // a different process. This involves running the unload handler and
1215 // clearing the page. We also allow this process to exit if there are no
1216 // other active RenderFrames in it.
1218 // Send an UpdateState message before we get swapped out.
1219 render_view_
->SyncNavigationState();
1221 // If we need a proxy to replace this, create it now so its routing id is
1222 // registered for receiving IPC messages.
1223 if (proxy_routing_id
!= MSG_ROUTING_NONE
) {
1224 proxy
= RenderFrameProxy::CreateProxyToReplaceFrame(this,
1228 // Synchronously run the unload handler before sending the ACK.
1229 // TODO(creis): Call dispatchUnloadEvent unconditionally here to support
1230 // unload on subframes as well.
1232 frame_
->dispatchUnloadEvent();
1234 // Swap out and stop sending any IPC messages that are not ACKs.
1236 render_view_
->SetSwappedOut(true);
1237 is_swapped_out_
= true;
1239 // Now that we're swapped out and filtering IPC messages, stop loading to
1240 // ensure that no other in-progress navigation continues. We do this here
1241 // to avoid sending a DidStopLoading message to the browser process.
1242 // TODO(creis): Should we be stopping all frames here and using
1243 // StopAltErrorPageFetcher with RenderView::OnStop, or just stopping this
1247 // Transfer settings such as initial drawing parameters to the remote frame,
1248 // if one is created, that will replace this frame.
1249 if (!is_main_frame
&& proxy
)
1250 proxy
->web_frame()->initializeFromFrame(frame_
);
1252 // Replace the page with a blank dummy URL. The unload handler will not be
1253 // run a second time, thanks to a check in FrameLoader::stopLoading.
1254 // TODO(creis): Need to add a better way to do this that avoids running the
1255 // beforeunload handler. For now, we just run it a second time silently.
1256 if (!is_site_per_process
|| is_main_frame
)
1257 NavigateToSwappedOutURL();
1259 // Let WebKit know that this view is hidden so it can drop resources and
1260 // stop compositing.
1261 // TODO(creis): Support this for subframes as well.
1262 if (is_main_frame
) {
1263 render_view_
->webview()->setVisibilityState(
1264 blink::WebPageVisibilityStateHidden
, false);
1268 // It is now safe to show modal dialogs again.
1269 // TODO(creis): Deal with modal dialogs from subframes.
1271 render_view_
->suppress_dialogs_until_swap_out_
= false;
1273 Send(new FrameHostMsg_SwapOut_ACK(routing_id_
));
1275 // Now that all of the cleanup is complete and the browser side is notified,
1276 // start using the RenderFrameProxy, if one is created.
1278 if (!is_main_frame
) {
1279 frame_
->swap(proxy
->web_frame());
1282 proxy
->OnDidStartLoading();
1284 if (is_site_per_process
) {
1285 // TODO(nasko): delete the frame here, since we've replaced it with a
1289 set_render_frame_proxy(proxy
);
1293 // In --site-per-process, initialize the WebRemoteFrame with the replication
1294 // state passed by the process that is now rendering the frame.
1295 // TODO(alexmos): We cannot yet do this for swapped-out main frames, because
1296 // in that case we leave the LocalFrame as the main frame visible to Blink
1297 // and don't call swap() above. Because swap() is what creates a RemoteFrame
1298 // in proxy->web_frame(), the RemoteFrame will not exist for main frames.
1299 // When we do an unconditional swap for all frames, we can remove
1300 // !is_main_frame below.
1301 if (is_site_per_process
&& proxy
&& !is_main_frame
)
1302 proxy
->SetReplicatedState(replicated_frame_state
);
1304 // Safe to exit if no one else is using the process.
1306 render_view_
->WasSwappedOut();
1309 void RenderFrameImpl::OnContextMenuClosed(
1310 const CustomContextMenuContext
& custom_context
) {
1311 if (custom_context
.request_id
) {
1312 // External request, should be in our map.
1313 ContextMenuClient
* client
=
1314 pending_context_menus_
.Lookup(custom_context
.request_id
);
1316 client
->OnMenuClosed(custom_context
.request_id
);
1317 pending_context_menus_
.Remove(custom_context
.request_id
);
1320 if (custom_context
.link_followed
.is_valid()) {
1322 DomUtils::ExtractParentAnchorNode(context_menu_node_
),
1323 custom_context
.link_followed
);
1325 // Internal request, forward to WebKit.
1326 context_menu_node_
.reset();
1330 void RenderFrameImpl::OnCustomContextMenuAction(
1331 const CustomContextMenuContext
& custom_context
,
1333 if (custom_context
.request_id
) {
1334 // External context menu request, look in our map.
1335 ContextMenuClient
* client
=
1336 pending_context_menus_
.Lookup(custom_context
.request_id
);
1338 client
->OnMenuAction(custom_context
.request_id
, action
);
1340 // Internal request, forward to WebKit.
1341 render_view_
->webview()->performCustomContextMenuAction(action
);
1345 void RenderFrameImpl::OnUndo() {
1346 frame_
->executeCommand(WebString::fromUTF8("Undo"), GetFocusedElement());
1349 void RenderFrameImpl::OnRedo() {
1350 frame_
->executeCommand(WebString::fromUTF8("Redo"), GetFocusedElement());
1353 void RenderFrameImpl::OnCut() {
1354 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1355 frame_
->executeCommand(WebString::fromUTF8("Cut"), GetFocusedElement());
1358 void RenderFrameImpl::OnCopy() {
1359 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1360 WebNode current_node
= context_menu_node_
.isNull() ?
1361 GetFocusedElement() : context_menu_node_
;
1362 frame_
->executeCommand(WebString::fromUTF8("Copy"), current_node
);
1365 void RenderFrameImpl::OnPaste() {
1366 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1367 frame_
->executeCommand(WebString::fromUTF8("Paste"), GetFocusedElement());
1370 void RenderFrameImpl::OnPasteAndMatchStyle() {
1371 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1372 frame_
->executeCommand(
1373 WebString::fromUTF8("PasteAndMatchStyle"), GetFocusedElement());
1376 #if defined(OS_MACOSX)
1377 void RenderFrameImpl::OnCopyToFindPboard() {
1378 // Since the find pasteboard supports only plain text, this can be simpler
1379 // than the |OnCopy()| case.
1380 if (frame_
->hasSelection()) {
1381 base::string16 selection
= frame_
->selectionAsText();
1382 RenderThread::Get()->Send(
1383 new ClipboardHostMsg_FindPboardWriteStringAsync(selection
));
1388 void RenderFrameImpl::OnDelete() {
1389 frame_
->executeCommand(WebString::fromUTF8("Delete"), GetFocusedElement());
1392 void RenderFrameImpl::OnSelectAll() {
1393 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1394 frame_
->executeCommand(WebString::fromUTF8("SelectAll"), GetFocusedElement());
1397 void RenderFrameImpl::OnSelectRange(const gfx::Point
& base
,
1398 const gfx::Point
& extent
) {
1399 // This IPC is dispatched by RenderWidgetHost, so use its routing id.
1400 Send(new InputHostMsg_SelectRange_ACK(GetRenderWidget()->routing_id()));
1402 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1403 frame_
->selectRange(base
, extent
);
1406 void RenderFrameImpl::OnUnselect() {
1407 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1408 frame_
->executeCommand(WebString::fromUTF8("Unselect"), GetFocusedElement());
1411 void RenderFrameImpl::OnMoveRangeSelectionExtent(const gfx::Point
& point
) {
1412 // This IPC is dispatched by RenderWidgetHost, so use its routing id.
1413 Send(new InputHostMsg_MoveRangeSelectionExtent_ACK(
1414 GetRenderWidget()->routing_id()));
1416 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1417 frame_
->moveRangeSelectionExtent(point
);
1420 void RenderFrameImpl::OnReplace(const base::string16
& text
) {
1421 if (!frame_
->hasSelection())
1422 frame_
->selectWordAroundCaret();
1424 frame_
->replaceSelection(text
);
1427 void RenderFrameImpl::OnReplaceMisspelling(const base::string16
& text
) {
1428 if (!frame_
->hasSelection())
1431 frame_
->replaceMisspelledRange(text
);
1434 void RenderFrameImpl::OnCSSInsertRequest(const std::string
& css
) {
1435 frame_
->document().insertStyleSheet(WebString::fromUTF8(css
));
1438 void RenderFrameImpl::OnJavaScriptExecuteRequest(
1439 const base::string16
& jscript
,
1441 bool notify_result
) {
1442 TRACE_EVENT_INSTANT0("test_tracing", "OnJavaScriptExecuteRequest",
1443 TRACE_EVENT_SCOPE_THREAD
);
1445 v8::HandleScope
handle_scope(v8::Isolate::GetCurrent());
1446 v8::Handle
<v8::Value
> result
=
1447 frame_
->executeScriptAndReturnValue(WebScriptSource(jscript
));
1449 HandleJavascriptExecutionResult(jscript
, id
, notify_result
, result
);
1452 void RenderFrameImpl::OnJavaScriptExecuteRequestForTests(
1453 const base::string16
& jscript
,
1455 bool notify_result
) {
1456 TRACE_EVENT_INSTANT0("test_tracing", "OnJavaScriptExecuteRequestForTests",
1457 TRACE_EVENT_SCOPE_THREAD
);
1459 v8::HandleScope
handle_scope(v8::Isolate::GetCurrent());
1460 v8::Handle
<v8::Value
> result
=
1461 frame_
->executeScriptAndReturnValueForTests(WebScriptSource(jscript
));
1463 HandleJavascriptExecutionResult(jscript
, id
, notify_result
, result
);
1466 void RenderFrameImpl::HandleJavascriptExecutionResult(
1467 const base::string16
& jscript
,
1470 v8::Handle
<v8::Value
> result
) {
1471 if (notify_result
) {
1472 base::ListValue list
;
1473 if (!result
.IsEmpty()) {
1474 v8::Local
<v8::Context
> context
= frame_
->mainWorldScriptContext();
1475 v8::Context::Scope
context_scope(context
);
1476 V8ValueConverterImpl converter
;
1477 converter
.SetDateAllowed(true);
1478 converter
.SetRegExpAllowed(true);
1479 base::Value
* result_value
= converter
.FromV8Value(result
, context
);
1480 list
.Set(0, result_value
? result_value
: base::Value::CreateNullValue());
1482 list
.Set(0, base::Value::CreateNullValue());
1484 Send(new FrameHostMsg_JavaScriptExecuteResponse(routing_id_
, id
, list
));
1488 void RenderFrameImpl::OnVisualStateRequest(uint64 id
) {
1489 GetRenderWidget()->QueueMessage(
1490 new FrameHostMsg_VisualStateResponse(routing_id_
, id
),
1491 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE
);
1494 void RenderFrameImpl::OnSetEditableSelectionOffsets(int start
, int end
) {
1495 base::AutoReset
<bool> handling_select_range(&handling_select_range_
, true);
1496 if (!GetRenderWidget()->ShouldHandleImeEvent())
1498 ImeEventGuard
guard(GetRenderWidget());
1499 frame_
->setEditableSelectionOffsets(start
, end
);
1502 void RenderFrameImpl::OnSetCompositionFromExistingText(
1504 const std::vector
<blink::WebCompositionUnderline
>& underlines
) {
1505 if (!GetRenderWidget()->ShouldHandleImeEvent())
1507 ImeEventGuard
guard(GetRenderWidget());
1508 frame_
->setCompositionFromExistingText(start
, end
, underlines
);
1511 void RenderFrameImpl::OnExecuteNoValueEditCommand(const std::string
& name
) {
1512 frame_
->executeCommand(WebString::fromUTF8(name
), GetFocusedElement());
1515 void RenderFrameImpl::OnExtendSelectionAndDelete(int before
, int after
) {
1516 if (!GetRenderWidget()->ShouldHandleImeEvent())
1518 ImeEventGuard
guard(GetRenderWidget());
1519 frame_
->extendSelectionAndDelete(before
, after
);
1522 void RenderFrameImpl::OnSetAccessibilityMode(AccessibilityMode new_mode
) {
1523 if (accessibility_mode_
== new_mode
)
1525 accessibility_mode_
= new_mode
;
1526 if (renderer_accessibility_
) {
1527 // Note: this isn't called automatically by the destructor because
1528 // there'd be no point in calling it in frame teardown, only if there's
1529 // an accessibility mode change but the frame is persisting.
1530 renderer_accessibility_
->DisableAccessibility();
1532 delete renderer_accessibility_
;
1533 renderer_accessibility_
= NULL
;
1535 if (accessibility_mode_
== AccessibilityModeOff
)
1538 if (accessibility_mode_
& AccessibilityModeFlagFullTree
)
1539 renderer_accessibility_
= new RendererAccessibility(this);
1542 void RenderFrameImpl::OnDisownOpener() {
1543 // TODO(creis): We should only see this for main frames for now. To support
1544 // disowning the opener on subframes, we will need to move WebContentsImpl's
1545 // opener_ to FrameTreeNode.
1546 CHECK(!frame_
->parent());
1548 if (frame_
->opener())
1549 frame_
->setOpener(NULL
);
1552 #if defined(OS_ANDROID)
1553 void RenderFrameImpl::OnSelectPopupMenuItems(
1555 const std::vector
<int>& selected_indices
) {
1556 // It is possible to receive more than one of these calls if the user presses
1557 // a select faster than it takes for the show-select-popup IPC message to make
1558 // it to the browser UI thread. Ignore the extra-messages.
1559 // TODO(jcivelli): http:/b/5793321 Implement a better fix, as detailed in bug.
1560 if (!external_popup_menu_
)
1563 external_popup_menu_
->DidSelectItems(canceled
, selected_indices
);
1564 external_popup_menu_
.reset();
1568 #if defined(OS_MACOSX)
1569 void RenderFrameImpl::OnSelectPopupMenuItem(int selected_index
) {
1570 if (external_popup_menu_
== NULL
)
1572 external_popup_menu_
->DidSelectItem(selected_index
);
1573 external_popup_menu_
.reset();
1577 void RenderFrameImpl::OnReload(bool ignore_cache
) {
1578 frame_
->reload(ignore_cache
);
1581 void RenderFrameImpl::OnTextSurroundingSelectionRequest(size_t max_length
) {
1582 blink::WebSurroundingText surroundingText
;
1583 surroundingText
.initialize(frame_
->selectionRange(), max_length
);
1585 if (surroundingText
.isNull()) {
1586 // |surroundingText| might not be correctly initialized, for example if
1587 // |frame_->selectionRange().isNull()|, in other words, if there was no
1589 Send(new FrameHostMsg_TextSurroundingSelectionResponse(
1590 routing_id_
, base::string16(), 0, 0));
1594 Send(new FrameHostMsg_TextSurroundingSelectionResponse(
1596 surroundingText
.textContent(),
1597 surroundingText
.startOffsetInTextContent(),
1598 surroundingText
.endOffsetInTextContent()));
1601 void RenderFrameImpl::OnAddStyleSheetByURL(const std::string
& url
) {
1602 frame_
->addStyleSheetByURL(WebString::fromUTF8(url
));
1605 void RenderFrameImpl::OnSetupTransitionView(const std::string
& markup
) {
1606 frame_
->document().setIsTransitionDocument(true);
1607 frame_
->navigateToSandboxedMarkup(WebData(markup
.data(), markup
.length()));
1610 void RenderFrameImpl::OnBeginExitTransition(const std::string
& css_selector
,
1611 bool exit_to_native_app
) {
1612 frame_
->document().setIsTransitionDocument(true);
1613 frame_
->document().beginExitTransition(WebString::fromUTF8(css_selector
),
1614 exit_to_native_app
);
1617 void RenderFrameImpl::OnRevertExitTransition() {
1618 frame_
->document().setIsTransitionDocument(false);
1619 frame_
->document().revertExitTransition();
1622 void RenderFrameImpl::OnHideTransitionElements(
1623 const std::string
& css_selector
) {
1624 frame_
->document().hideTransitionElements(WebString::fromUTF8(css_selector
));
1627 void RenderFrameImpl::OnShowTransitionElements(
1628 const std::string
& css_selector
) {
1629 frame_
->document().showTransitionElements(WebString::fromUTF8(css_selector
));
1632 bool RenderFrameImpl::RunJavaScriptMessage(JavaScriptMessageType type
,
1633 const base::string16
& message
,
1634 const base::string16
& default_value
,
1635 const GURL
& frame_url
,
1636 base::string16
* result
) {
1637 // Don't allow further dialogs if we are waiting to swap out, since the
1638 // PageGroupLoadDeferrer in our stack prevents it.
1639 if (render_view()->suppress_dialogs_until_swap_out_
)
1642 bool success
= false;
1643 base::string16 result_temp
;
1645 result
= &result_temp
;
1647 render_view()->SendAndRunNestedMessageLoop(
1648 new FrameHostMsg_RunJavaScriptMessage(
1649 routing_id_
, message
, default_value
, frame_url
, type
, &success
,
1654 void RenderFrameImpl::LoadNavigationErrorPage(
1655 const WebURLRequest
& failed_request
,
1656 const WebURLError
& error
,
1658 std::string error_html
;
1659 GetContentClient()->renderer()->GetNavigationErrorStrings(
1660 render_view(), frame_
, failed_request
, error
, &error_html
, NULL
);
1662 frame_
->loadHTMLString(error_html
,
1663 GURL(kUnreachableWebDataURL
),
1664 error
.unreachableURL
,
1668 void RenderFrameImpl::DidCommitCompositorFrame() {
1670 RenderFrameObserver
, observers_
, DidCommitCompositorFrame());
1673 RenderView
* RenderFrameImpl::GetRenderView() {
1674 return render_view_
.get();
1677 int RenderFrameImpl::GetRoutingID() {
1681 blink::WebLocalFrame
* RenderFrameImpl::GetWebFrame() {
1686 WebElement
RenderFrameImpl::GetFocusedElement() const {
1687 WebDocument doc
= frame_
->document();
1689 return doc
.focusedElement();
1691 return WebElement();
1694 WebPreferences
& RenderFrameImpl::GetWebkitPreferences() {
1695 return render_view_
->GetWebkitPreferences();
1698 int RenderFrameImpl::ShowContextMenu(ContextMenuClient
* client
,
1699 const ContextMenuParams
& params
) {
1700 DCHECK(client
); // A null client means "internal" when we issue callbacks.
1701 ContextMenuParams
our_params(params
);
1702 our_params
.custom_context
.request_id
= pending_context_menus_
.Add(client
);
1703 Send(new FrameHostMsg_ContextMenu(routing_id_
, our_params
));
1704 return our_params
.custom_context
.request_id
;
1707 void RenderFrameImpl::CancelContextMenu(int request_id
) {
1708 DCHECK(pending_context_menus_
.Lookup(request_id
));
1709 pending_context_menus_
.Remove(request_id
);
1712 blink::WebNode
RenderFrameImpl::GetContextMenuNode() const {
1713 return context_menu_node_
;
1716 blink::WebPlugin
* RenderFrameImpl::CreatePlugin(
1717 blink::WebFrame
* frame
,
1718 const WebPluginInfo
& info
,
1719 const blink::WebPluginParams
& params
,
1720 scoped_ptr
<content::PluginInstanceThrottler
> throttler
) {
1721 DCHECK_EQ(frame_
, frame
);
1722 #if defined(ENABLE_PLUGINS)
1723 if (info
.type
== WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN
) {
1724 scoped_ptr
<BrowserPluginDelegate
> browser_plugin_delegate(
1725 GetContentClient()->renderer()->CreateBrowserPluginDelegate(
1726 this, params
.mimeType
.utf8(), GURL(params
.url
)));
1727 return BrowserPluginManager::Get()->CreateBrowserPlugin(
1728 this, browser_plugin_delegate
.Pass());
1731 bool pepper_plugin_was_registered
= false;
1732 scoped_refptr
<PluginModule
> pepper_module(PluginModule::Create(
1733 this, info
, &pepper_plugin_was_registered
));
1734 if (pepper_plugin_was_registered
) {
1735 if (pepper_module
.get()) {
1736 return new PepperWebPluginImpl(
1737 pepper_module
.get(), params
, this,
1739 static_cast<PluginInstanceThrottlerImpl
*>(throttler
.release())));
1742 #if defined(OS_CHROMEOS)
1743 LOG(WARNING
) << "Pepper module/plugin creation failed.";
1746 // TODO(jam): change to take RenderFrame.
1747 return new WebPluginImpl(frame
, params
, info
.path
, render_view_
, this);
1754 void RenderFrameImpl::LoadURLExternally(blink::WebLocalFrame
* frame
,
1755 const blink::WebURLRequest
& request
,
1756 blink::WebNavigationPolicy policy
) {
1757 DCHECK(!frame_
|| frame_
== frame
);
1758 loadURLExternally(frame
, request
, policy
, WebString());
1761 void RenderFrameImpl::ExecuteJavaScript(const base::string16
& javascript
) {
1762 OnJavaScriptExecuteRequest(javascript
, 0, false);
1765 ServiceRegistry
* RenderFrameImpl::GetServiceRegistry() {
1766 return &service_registry_
;
1769 #if defined(ENABLE_PLUGINS)
1770 void RenderFrameImpl::RegisterPeripheralPlugin(
1771 const GURL
& content_origin
,
1772 const base::Closure
& unthrottle_callback
) {
1773 return plugin_power_saver_helper_
->RegisterPeripheralPlugin(
1774 content_origin
, unthrottle_callback
);
1776 #endif // defined(ENABLE_PLUGINS)
1778 bool RenderFrameImpl::IsFTPDirectoryListing() {
1779 WebURLResponseExtraDataImpl
* extra_data
=
1780 GetExtraDataFromResponse(frame_
->dataSource()->response());
1781 return extra_data
? extra_data
->is_ftp_directory_listing() : false;
1784 void RenderFrameImpl::AttachGuest(int element_instance_id
) {
1785 BrowserPluginManager::Get()->Attach(element_instance_id
);
1788 void RenderFrameImpl::DetachGuest(int element_instance_id
) {
1789 BrowserPluginManager::Get()->Detach(element_instance_id
);
1792 void RenderFrameImpl::SetSelectedText(const base::string16
& selection_text
,
1794 const gfx::Range
& range
) {
1795 // Use the routing id of Render Widget Host.
1796 Send(new ViewHostMsg_SelectionChanged(GetRenderWidget()->routing_id(),
1802 void RenderFrameImpl::EnsureMojoBuiltinsAreAvailable(
1803 v8::Isolate
* isolate
,
1804 v8::Handle
<v8::Context
> context
) {
1805 gin::ModuleRegistry
* registry
= gin::ModuleRegistry::From(context
);
1806 if (registry
->available_modules().count(mojo::js::Core::kModuleName
))
1809 v8::HandleScope
handle_scope(isolate
);
1810 registry
->AddBuiltinModule(
1811 isolate
, mojo::js::Core::kModuleName
, mojo::js::Core::GetModule(isolate
));
1812 registry
->AddBuiltinModule(isolate
,
1813 mojo::js::Support::kModuleName
,
1814 mojo::js::Support::GetModule(isolate
));
1815 registry
->AddBuiltinModule(
1817 ServiceRegistryJsWrapper::kModuleName
,
1818 ServiceRegistryJsWrapper::Create(isolate
, &service_registry_
).ToV8());
1821 // blink::WebFrameClient implementation ----------------------------------------
1823 blink::WebPluginPlaceholder
* RenderFrameImpl::createPluginPlaceholder(
1824 blink::WebLocalFrame
* frame
,
1825 const blink::WebPluginParams
& params
) {
1826 DCHECK_EQ(frame_
, frame
);
1827 return GetContentClient()
1829 ->CreatePluginPlaceholder(this, frame
, params
)
1833 blink::WebPlugin
* RenderFrameImpl::createPlugin(
1834 blink::WebLocalFrame
* frame
,
1835 const blink::WebPluginParams
& params
) {
1836 DCHECK_EQ(frame_
, frame
);
1837 blink::WebPlugin
* plugin
= NULL
;
1838 if (GetContentClient()->renderer()->OverrideCreatePlugin(
1839 this, frame
, params
, &plugin
)) {
1843 if (base::UTF16ToUTF8(params
.mimeType
) == kBrowserPluginMimeType
) {
1844 scoped_ptr
<BrowserPluginDelegate
> browser_plugin_delegate(
1845 GetContentClient()->renderer()->CreateBrowserPluginDelegate(this,
1846 kBrowserPluginMimeType
, GURL(params
.url
)));
1847 return BrowserPluginManager::Get()->CreateBrowserPlugin(
1848 this, browser_plugin_delegate
.Pass());
1851 #if defined(ENABLE_PLUGINS)
1853 std::string mime_type
;
1855 Send(new FrameHostMsg_GetPluginInfo(
1856 routing_id_
, params
.url
, frame
->top()->document().url(),
1857 params
.mimeType
.utf8(), &found
, &info
, &mime_type
));
1861 WebPluginParams params_to_use
= params
;
1862 params_to_use
.mimeType
= WebString::fromUTF8(mime_type
);
1863 return CreatePlugin(frame
, info
, params_to_use
, nullptr /* throttler */);
1866 #endif // defined(ENABLE_PLUGINS)
1869 blink::WebMediaPlayer
* RenderFrameImpl::createMediaPlayer(
1870 blink::WebLocalFrame
* frame
,
1871 const blink::WebURL
& url
,
1872 blink::WebMediaPlayerClient
* client
) {
1873 return createMediaPlayer(frame
, url
, client
, nullptr);
1876 blink::WebMediaPlayer
* RenderFrameImpl::createMediaPlayer(
1877 blink::WebLocalFrame
* frame
,
1878 const blink::WebURL
& url
,
1879 blink::WebMediaPlayerClient
* client
,
1880 blink::WebContentDecryptionModule
* initial_cdm
) {
1881 #if defined(VIDEO_HOLE)
1882 if (!contains_media_player_
) {
1883 render_view_
->RegisterVideoHoleFrame(this);
1884 contains_media_player_
= true;
1886 #endif // defined(VIDEO_HOLE)
1888 blink::WebMediaStream
web_stream(
1889 blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url
));
1890 if (!web_stream
.isNull())
1891 return CreateWebMediaPlayerForMediaStream(url
, client
);
1893 if (!media_permission_dispatcher_
)
1894 media_permission_dispatcher_
= new MediaPermissionDispatcher(this);
1896 #if defined(OS_ANDROID)
1897 return CreateAndroidWebMediaPlayer(url
, client
, media_permission_dispatcher_
,
1900 scoped_refptr
<media::MediaLog
> media_log(new RenderMediaLog());
1903 RenderThreadImpl
* render_thread
= RenderThreadImpl::current();
1904 media::WebMediaPlayerParams
params(
1905 base::Bind(&ContentRendererClient::DeferMediaLoad
,
1906 base::Unretained(GetContentClient()->renderer()),
1907 static_cast<RenderFrame
*>(this)),
1908 render_thread
->GetAudioRendererMixerManager()->CreateInput(
1909 render_view_
->routing_id_
, routing_id_
),
1910 media_log
, render_thread
->GetMediaThreadTaskRunner(),
1911 render_thread
->compositor_message_loop_proxy(),
1912 base::Bind(&GetSharedMainThreadContext3D
), media_permission_dispatcher_
,
1915 #if defined(ENABLE_PEPPER_CDMS)
1916 scoped_ptr
<media::CdmFactory
> cdm_factory(
1917 new RenderCdmFactory(base::Bind(&PepperCdmWrapperImpl::Create
, frame
)));
1918 #elif defined(ENABLE_BROWSER_CDMS)
1919 scoped_ptr
<media::CdmFactory
> cdm_factory(
1920 new RenderCdmFactory(GetCdmManager()));
1922 scoped_ptr
<media::CdmFactory
> cdm_factory(new RenderCdmFactory());
1925 #if defined(ENABLE_MEDIA_MOJO_RENDERER)
1926 scoped_ptr
<media::RendererFactory
> media_renderer_factory(
1927 new media::MojoRendererFactory(make_scoped_ptr(
1928 new MediaRendererServiceProvider(GetServiceRegistry()))));
1930 scoped_ptr
<media::RendererFactory
> media_renderer_factory
=
1931 GetContentClient()->renderer()->CreateMediaRendererFactory(this,
1934 if (!media_renderer_factory
.get()) {
1935 media_renderer_factory
.reset(new media::DefaultRendererFactory(
1936 media_log
, render_thread
->GetGpuFactories(),
1937 *render_thread
->GetAudioHardwareConfig()));
1939 #endif // defined(ENABLE_MEDIA_MOJO_RENDERER)
1941 return new media::WebMediaPlayerImpl(
1942 frame
, client
, weak_factory_
.GetWeakPtr(), media_renderer_factory
.Pass(),
1943 cdm_factory
.Pass(), params
);
1944 #endif // defined(OS_ANDROID)
1947 blink::WebApplicationCacheHost
* RenderFrameImpl::createApplicationCacheHost(
1948 blink::WebLocalFrame
* frame
,
1949 blink::WebApplicationCacheHostClient
* client
) {
1950 if (!frame
|| !frame
->view())
1952 DCHECK(!frame_
|| frame_
== frame
);
1953 return new RendererWebApplicationCacheHostImpl(
1954 RenderViewImpl::FromWebView(frame
->view()), client
,
1955 RenderThreadImpl::current()->appcache_dispatcher()->backend_proxy());
1958 blink::WebWorkerPermissionClientProxy
*
1959 RenderFrameImpl::createWorkerPermissionClientProxy(
1960 blink::WebLocalFrame
* frame
) {
1961 if (!frame
|| !frame
->view())
1963 DCHECK(!frame_
|| frame_
== frame
);
1964 return GetContentClient()->renderer()->CreateWorkerPermissionClientProxy(
1968 WebExternalPopupMenu
* RenderFrameImpl::createExternalPopupMenu(
1969 const WebPopupMenuInfo
& popup_menu_info
,
1970 WebExternalPopupMenuClient
* popup_menu_client
) {
1971 #if defined(OS_MACOSX) || defined(OS_ANDROID)
1972 // An IPC message is sent to the browser to build and display the actual
1973 // popup. The user could have time to click a different select by the time
1974 // the popup is shown. In that case external_popup_menu_ is non NULL.
1975 // By returning NULL in that case, we instruct Blink to cancel that new
1976 // popup. So from the user perspective, only the first one will show, and
1977 // will have to close the first one before another one can be shown.
1978 if (external_popup_menu_
)
1980 external_popup_menu_
.reset(
1981 new ExternalPopupMenu(this, popup_menu_info
, popup_menu_client
));
1982 if (render_view_
->screen_metrics_emulator_
) {
1983 render_view_
->SetExternalPopupOriginAdjustmentsForEmulation(
1984 external_popup_menu_
.get(),
1985 render_view_
->screen_metrics_emulator_
.get());
1987 return external_popup_menu_
.get();
1993 blink::WebCookieJar
* RenderFrameImpl::cookieJar(blink::WebLocalFrame
* frame
) {
1994 DCHECK(!frame_
|| frame_
== frame
);
1995 return &cookie_jar_
;
1998 blink::WebServiceWorkerProvider
* RenderFrameImpl::createServiceWorkerProvider(
1999 blink::WebLocalFrame
* frame
) {
2000 DCHECK(!frame_
|| frame_
== frame
);
2001 // At this point we should have non-null data source.
2002 DCHECK(frame
->dataSource());
2003 if (!ChildThreadImpl::current())
2004 return NULL
; // May be null in some tests.
2005 ServiceWorkerNetworkProvider
* provider
=
2006 ServiceWorkerNetworkProvider::FromDocumentState(
2007 DocumentState::FromDataSource(frame
->dataSource()));
2008 return new WebServiceWorkerProviderImpl(
2009 ChildThreadImpl::current()->thread_safe_sender(),
2010 provider
? provider
->context() : NULL
);
2013 void RenderFrameImpl::didAccessInitialDocument(blink::WebLocalFrame
* frame
) {
2014 DCHECK(!frame_
|| frame_
== frame
);
2015 // If the request hasn't yet committed, notify the browser process that it is
2016 // no longer safe to show the pending URL of the main frame, since a URL spoof
2017 // is now possible. (If the request has committed, the browser already knows.)
2018 if (!frame
->parent()) {
2019 DocumentState
* document_state
=
2020 DocumentState::FromDataSource(frame
->dataSource());
2021 NavigationState
* navigation_state
= document_state
->navigation_state();
2023 if (!navigation_state
->request_committed()) {
2024 Send(new FrameHostMsg_DidAccessInitialDocument(routing_id_
));
2029 blink::WebFrame
* RenderFrameImpl::createChildFrame(
2030 blink::WebLocalFrame
* parent
,
2031 const blink::WebString
& name
,
2032 blink::WebSandboxFlags sandbox_flags
) {
2033 // Synchronously notify the browser of a child frame creation to get the
2034 // routing_id for the RenderFrame.
2035 int child_routing_id
= MSG_ROUTING_NONE
;
2036 Send(new FrameHostMsg_CreateChildFrame(
2037 routing_id_
, base::UTF16ToUTF8(name
),
2038 WebToContentSandboxFlags(sandbox_flags
), &child_routing_id
));
2040 // Allocation of routing id failed, so we can't create a child frame. This can
2041 // happen if this RenderFrameImpl's IPCs are being filtered when in swapped
2042 // out state or synchronous IPC message above has failed.
2043 if (child_routing_id
== MSG_ROUTING_NONE
) {
2044 NOTREACHED() << "Failed to allocate routing id for child frame.";
2048 // Create the RenderFrame and WebLocalFrame, linking the two.
2049 RenderFrameImpl
* child_render_frame
= RenderFrameImpl::Create(
2050 render_view_
.get(), child_routing_id
);
2051 blink::WebLocalFrame
* web_frame
= WebLocalFrame::create(child_render_frame
);
2052 child_render_frame
->SetWebFrame(web_frame
);
2054 // Add the frame to the frame tree and initialize it.
2055 parent
->appendChild(web_frame
);
2056 child_render_frame
->Initialize();
2061 void RenderFrameImpl::didDisownOpener(blink::WebLocalFrame
* frame
) {
2062 DCHECK(!frame_
|| frame_
== frame
);
2063 // We only need to notify the browser if the active, top-level frame clears
2064 // its opener. We can ignore cases where a swapped out frame clears its
2065 // opener after hearing about it from the browser, and the browser does not
2066 // (yet) care about subframe openers.
2067 if (is_swapped_out_
|| frame
->parent())
2070 // Notify WebContents and all its swapped out RenderViews.
2071 Send(new FrameHostMsg_DidDisownOpener(routing_id_
));
2074 void RenderFrameImpl::frameDetached(blink::WebFrame
* frame
) {
2075 // NOTE: This function is called on the frame that is being detached and not
2076 // the parent frame. This is different from createChildFrame() which is
2077 // called on the parent frame.
2078 CHECK(!is_detaching_
);
2079 DCHECK(!frame_
|| frame_
== frame
);
2081 bool is_subframe
= !!frame
->parent();
2083 Send(new FrameHostMsg_Detach(routing_id_
));
2085 // The |is_detaching_| flag disables Send(). FrameHostMsg_Detach must be
2086 // sent before setting |is_detaching_| to true. In contrast, Observers
2087 // should only be notified afterwards so they cannot call back into here and
2088 // have IPCs fired off.
2089 is_detaching_
= true;
2091 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, FrameDetached());
2092 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2093 FrameDetached(frame
));
2095 // We need to clean up subframes by removing them from the map and deleting
2096 // the RenderFrameImpl. In contrast, the main frame is owned by its
2097 // containing RenderViewHost (so that they have the same lifetime), so only
2098 // removal from the map is needed and no deletion.
2099 FrameMap::iterator it
= g_frame_map
.Get().find(frame
);
2100 CHECK(it
!= g_frame_map
.Get().end());
2101 CHECK_EQ(it
->second
, this);
2102 g_frame_map
.Get().erase(it
);
2105 frame
->parent()->removeChild(frame
);
2107 // |frame| is invalid after here.
2112 // Object is invalid after this point.
2116 void RenderFrameImpl::frameFocused() {
2117 Send(new FrameHostMsg_FrameFocused(routing_id_
));
2120 void RenderFrameImpl::willClose(blink::WebFrame
* frame
) {
2121 DCHECK(!frame_
|| frame_
== frame
);
2123 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, FrameWillClose());
2124 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2125 FrameWillClose(frame
));
2128 void RenderFrameImpl::didChangeName(blink::WebLocalFrame
* frame
,
2129 const blink::WebString
& name
) {
2130 DCHECK(!frame_
|| frame_
== frame
);
2131 if (!render_view_
->renderer_preferences_
.report_frame_name_changes
)
2134 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, DidChangeName(name
));
2137 void RenderFrameImpl::didMatchCSS(
2138 blink::WebLocalFrame
* frame
,
2139 const blink::WebVector
<blink::WebString
>& newly_matching_selectors
,
2140 const blink::WebVector
<blink::WebString
>& stopped_matching_selectors
) {
2141 DCHECK(!frame_
|| frame_
== frame
);
2143 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2145 newly_matching_selectors
,
2146 stopped_matching_selectors
));
2149 bool RenderFrameImpl::shouldReportDetailedMessageForSource(
2150 const blink::WebString
& source
) {
2151 return GetContentClient()->renderer()->ShouldReportDetailedMessageForSource(
2155 void RenderFrameImpl::didAddMessageToConsole(
2156 const blink::WebConsoleMessage
& message
,
2157 const blink::WebString
& source_name
,
2158 unsigned source_line
,
2159 const blink::WebString
& stack_trace
) {
2160 logging::LogSeverity log_severity
= logging::LOG_VERBOSE
;
2161 switch (message
.level
) {
2162 case blink::WebConsoleMessage::LevelDebug
:
2163 log_severity
= logging::LOG_VERBOSE
;
2165 case blink::WebConsoleMessage::LevelLog
:
2166 case blink::WebConsoleMessage::LevelInfo
:
2167 log_severity
= logging::LOG_INFO
;
2169 case blink::WebConsoleMessage::LevelWarning
:
2170 log_severity
= logging::LOG_WARNING
;
2172 case blink::WebConsoleMessage::LevelError
:
2173 log_severity
= logging::LOG_ERROR
;
2179 if (shouldReportDetailedMessageForSource(source_name
)) {
2181 RenderFrameObserver
, observers_
,
2182 DetailedConsoleMessageAdded(message
.text
,
2186 static_cast<int32
>(log_severity
)));
2189 Send(new FrameHostMsg_AddMessageToConsole(routing_id_
,
2190 static_cast<int32
>(log_severity
),
2192 static_cast<int32
>(source_line
),
2196 void RenderFrameImpl::loadURLExternally(
2197 blink::WebLocalFrame
* frame
,
2198 const blink::WebURLRequest
& request
,
2199 blink::WebNavigationPolicy policy
,
2200 const blink::WebString
& suggested_name
) {
2201 DCHECK(!frame_
|| frame_
== frame
);
2202 Referrer
referrer(RenderViewImpl::GetReferrerFromRequest(frame
, request
));
2203 if (policy
== blink::WebNavigationPolicyDownload
) {
2204 render_view_
->Send(new ViewHostMsg_DownloadUrl(render_view_
->GetRoutingID(),
2205 request
.url(), referrer
,
2208 OpenURL(frame
, request
.url(), referrer
, policy
);
2212 blink::WebNavigationPolicy
RenderFrameImpl::decidePolicyForNavigation(
2213 const NavigationPolicyInfo
& info
) {
2214 DCHECK(!frame_
|| frame_
== info
.frame
);
2215 return DecidePolicyForNavigation(this, info
);
2218 blink::WebHistoryItem
RenderFrameImpl::historyItemForNewChildFrame(
2219 blink::WebFrame
* frame
) {
2220 DCHECK(!frame_
|| frame_
== frame
);
2221 return render_view_
->history_controller()->GetItemForNewChildFrame(this);
2224 void RenderFrameImpl::willSendSubmitEvent(blink::WebLocalFrame
* frame
,
2225 const blink::WebFormElement
& form
) {
2226 DCHECK(!frame_
|| frame_
== frame
);
2228 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, WillSendSubmitEvent(form
));
2231 void RenderFrameImpl::willSubmitForm(blink::WebLocalFrame
* frame
,
2232 const blink::WebFormElement
& form
) {
2233 DCHECK(!frame_
|| frame_
== frame
);
2234 DocumentState
* document_state
=
2235 DocumentState::FromDataSource(frame
->provisionalDataSource());
2236 NavigationState
* navigation_state
= document_state
->navigation_state();
2237 InternalDocumentStateData
* internal_data
=
2238 InternalDocumentStateData::FromDocumentState(document_state
);
2240 if (ui::PageTransitionCoreTypeIs(navigation_state
->transition_type(),
2241 ui::PAGE_TRANSITION_LINK
)) {
2242 navigation_state
->set_transition_type(ui::PAGE_TRANSITION_FORM_SUBMIT
);
2245 // Save these to be processed when the ensuing navigation is committed.
2246 WebSearchableFormData
web_searchable_form_data(form
);
2247 internal_data
->set_searchable_form_url(web_searchable_form_data
.url());
2248 internal_data
->set_searchable_form_encoding(
2249 web_searchable_form_data
.encoding().utf8());
2251 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, WillSubmitForm(form
));
2254 void RenderFrameImpl::didCreateDataSource(blink::WebLocalFrame
* frame
,
2255 blink::WebDataSource
* datasource
) {
2256 DCHECK(!frame_
|| frame_
== frame
);
2258 // TODO(nasko): Move implementation here. Needed state:
2259 // * pending_navigation_params_
2262 // * PopulateDocumentStateFromPending
2263 // * CreateNavigationStateFromPending
2264 render_view_
->didCreateDataSource(frame
, datasource
);
2266 // Create the serviceworker's per-document network observing object if it
2267 // does not exist (When navigation happens within a page, the provider already
2269 if (!ServiceWorkerNetworkProvider::FromDocumentState(
2270 DocumentState::FromDataSource(datasource
))) {
2271 scoped_ptr
<ServiceWorkerNetworkProvider
>
2272 network_provider(new ServiceWorkerNetworkProvider(
2273 routing_id_
, SERVICE_WORKER_PROVIDER_FOR_CONTROLLEE
));
2274 ServiceWorkerNetworkProvider::AttachToDocumentState(
2275 DocumentState::FromDataSource(datasource
),
2276 network_provider
.Pass());
2280 void RenderFrameImpl::didStartProvisionalLoad(blink::WebLocalFrame
* frame
,
2281 bool is_transition_navigation
,
2282 double triggering_event_time
) {
2283 DCHECK(!frame_
|| frame_
== frame
);
2284 WebDataSource
* ds
= frame
->provisionalDataSource();
2286 // In fast/loader/stop-provisional-loads.html, we abort the load before this
2287 // callback is invoked.
2291 TRACE_EVENT2("navigation", "RenderFrameImpl::didStartProvisionalLoad",
2292 "id", routing_id_
, "url", ds
->request().url().string().utf8());
2293 DocumentState
* document_state
= DocumentState::FromDataSource(ds
);
2295 // We should only navigate to swappedout:// when is_swapped_out_ is true.
2296 CHECK((ds
->request().url() != GURL(kSwappedOutURL
)) ||
2298 "Heard swappedout:// when not swapped out.";
2300 // Update the request time if WebKit has better knowledge of it.
2301 if (document_state
->request_time().is_null() &&
2302 triggering_event_time
!= 0.0) {
2303 document_state
->set_request_time(Time::FromDoubleT(triggering_event_time
));
2306 // Start time is only set after request time.
2307 document_state
->set_start_load_time(Time::Now());
2309 bool is_top_most
= !frame
->parent();
2311 render_view_
->set_navigation_gesture(
2312 WebUserGestureIndicator::isProcessingUserGesture() ?
2313 NavigationGestureUser
: NavigationGestureAuto
);
2314 } else if (ds
->replacesCurrentHistoryItem()) {
2315 // Subframe navigations that don't add session history items must be
2316 // marked with AUTO_SUBFRAME. See also didFailProvisionalLoad for how we
2317 // handle loading of error pages.
2318 document_state
->navigation_state()->set_transition_type(
2319 ui::PAGE_TRANSITION_AUTO_SUBFRAME
);
2322 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2323 DidStartProvisionalLoad(frame
));
2324 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, DidStartProvisionalLoad());
2326 Send(new FrameHostMsg_DidStartProvisionalLoadForFrame(
2327 routing_id_
, ds
->request().url(), is_transition_navigation
));
2330 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
2331 blink::WebLocalFrame
* frame
) {
2332 DCHECK(!frame_
|| frame_
== frame
);
2333 render_view_
->history_controller()->RemoveChildrenForRedirect(this);
2336 void RenderFrameImpl::didFailProvisionalLoad(blink::WebLocalFrame
* frame
,
2337 const blink::WebURLError
& error
) {
2338 TRACE_EVENT1("navigation", "RenderFrameImpl::didFailProvisionalLoad",
2340 DCHECK(!frame_
|| frame_
== frame
);
2341 WebDataSource
* ds
= frame
->provisionalDataSource();
2344 const WebURLRequest
& failed_request
= ds
->request();
2346 // Notify the browser that we failed a provisional load with an error.
2348 // Note: It is important this notification occur before DidStopLoading so the
2349 // SSL manager can react to the provisional load failure before being
2350 // notified the load stopped.
2352 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2353 DidFailProvisionalLoad(frame
, error
));
2354 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
,
2355 DidFailProvisionalLoad(error
));
2357 bool show_repost_interstitial
=
2358 (error
.reason
== net::ERR_CACHE_MISS
&&
2359 EqualsASCII(failed_request
.httpMethod(), "POST"));
2361 FrameHostMsg_DidFailProvisionalLoadWithError_Params params
;
2362 params
.error_code
= error
.reason
;
2363 GetContentClient()->renderer()->GetNavigationErrorStrings(
2369 ¶ms
.error_description
);
2370 params
.url
= error
.unreachableURL
;
2371 params
.showing_repost_interstitial
= show_repost_interstitial
;
2372 Send(new FrameHostMsg_DidFailProvisionalLoadWithError(
2373 routing_id_
, params
));
2375 // Don't display an error page if this is simply a cancelled load. Aside
2376 // from being dumb, WebCore doesn't expect it and it will cause a crash.
2377 if (error
.reason
== net::ERR_ABORTED
)
2380 // Don't display "client blocked" error page if browser has asked us not to.
2381 if (error
.reason
== net::ERR_BLOCKED_BY_CLIENT
&&
2382 render_view_
->renderer_preferences_
.disable_client_blocked_error_page
) {
2386 // Allow the embedder to suppress an error page.
2387 if (GetContentClient()->renderer()->ShouldSuppressErrorPage(this,
2388 error
.unreachableURL
)) {
2392 if (RenderThreadImpl::current() &&
2393 RenderThreadImpl::current()->layout_test_mode()) {
2397 // Make sure we never show errors in view source mode.
2398 frame
->enableViewSourceMode(false);
2400 DocumentState
* document_state
= DocumentState::FromDataSource(ds
);
2401 NavigationState
* navigation_state
= document_state
->navigation_state();
2403 // If this is a failed back/forward/reload navigation, then we need to do a
2404 // 'replace' load. This is necessary to avoid messing up session history.
2405 // Otherwise, we do a normal load, which simulates a 'go' navigation as far
2406 // as session history is concerned.
2408 // AUTO_SUBFRAME loads should always be treated as loads that do not advance
2411 // TODO(davidben): This should also take the failed navigation's replacement
2412 // state into account, if a location.replace() failed.
2414 navigation_state
->pending_page_id() != -1 ||
2415 ui::PageTransitionCoreTypeIs(navigation_state
->transition_type(),
2416 ui::PAGE_TRANSITION_AUTO_SUBFRAME
);
2418 // If we failed on a browser initiated request, then make sure that our error
2419 // page load is regarded as the same browser initiated request.
2420 if (!navigation_state
->is_content_initiated()) {
2421 render_view_
->pending_navigation_params_
.reset(
2422 new FrameMsg_Navigate_Params
);
2423 render_view_
->pending_navigation_params_
->page_id
=
2424 navigation_state
->pending_page_id();
2425 render_view_
->pending_navigation_params_
->pending_history_list_offset
=
2426 navigation_state
->pending_history_list_offset();
2427 render_view_
->pending_navigation_params_
->should_clear_history_list
=
2428 navigation_state
->history_list_was_cleared();
2429 render_view_
->pending_navigation_params_
->common_params
.transition
=
2430 navigation_state
->transition_type();
2431 render_view_
->pending_navigation_params_
->request_time
=
2432 document_state
->request_time();
2433 render_view_
->pending_navigation_params_
->should_replace_current_entry
=
2437 // Load an error page.
2438 LoadNavigationErrorPage(failed_request
, error
, replace
);
2441 void RenderFrameImpl::didCommitProvisionalLoad(
2442 blink::WebLocalFrame
* frame
,
2443 const blink::WebHistoryItem
& item
,
2444 blink::WebHistoryCommitType commit_type
) {
2445 TRACE_EVENT2("navigation", "RenderFrameImpl::didCommitProvisionalLoad",
2447 "url", GetLoadingUrl().possibly_invalid_spec());
2448 DCHECK(!frame_
|| frame_
== frame
);
2449 DocumentState
* document_state
=
2450 DocumentState::FromDataSource(frame
->dataSource());
2451 NavigationState
* navigation_state
= document_state
->navigation_state();
2453 if (proxy_routing_id_
!= MSG_ROUTING_NONE
) {
2454 RenderFrameProxy
* proxy
=
2455 RenderFrameProxy::FromRoutingID(proxy_routing_id_
);
2457 proxy
->web_frame()->swap(frame_
);
2458 proxy_routing_id_
= MSG_ROUTING_NONE
;
2461 // When we perform a new navigation, we need to update the last committed
2462 // session history entry with state for the page we are leaving. Do this
2463 // before updating the HistoryController state.
2464 render_view_
->UpdateSessionHistory(frame
);
2466 render_view_
->history_controller()->UpdateForCommit(this, item
, commit_type
,
2467 navigation_state
->was_within_same_page());
2469 InternalDocumentStateData
* internal_data
=
2470 InternalDocumentStateData::FromDocumentState(document_state
);
2472 if (document_state
->commit_load_time().is_null())
2473 document_state
->set_commit_load_time(Time::Now());
2475 if (internal_data
->must_reset_scroll_and_scale_state()) {
2476 render_view_
->webview()->resetScrollAndScaleState();
2477 internal_data
->set_must_reset_scroll_and_scale_state(false);
2479 internal_data
->set_use_error_page(false);
2481 bool is_new_navigation
= commit_type
== blink::WebStandardCommit
;
2482 if (is_new_navigation
) {
2483 // We bump our Page ID to correspond with the new session history entry.
2484 render_view_
->page_id_
= render_view_
->next_page_id_
++;
2486 // Don't update history list values for kSwappedOutURL, since
2487 // we don't want to forget the entry that was there, and since we will
2488 // never come back to kSwappedOutURL. Note that we have to call
2489 // UpdateSessionHistory and update page_id_ even in this case, so that
2490 // the current entry gets a state update and so that we don't send a
2491 // state update to the wrong entry when we swap back in.
2492 DCHECK(render_view_
->history_list_length_
> 0 ||
2493 !navigation_state
->should_replace_current_entry());
2494 if (GetLoadingUrl() != GURL(kSwappedOutURL
) &&
2495 !navigation_state
->should_replace_current_entry()) {
2496 // Advance our offset in session history, applying the length limit.
2497 // There is now no forward history.
2498 render_view_
->history_list_offset_
++;
2499 if (render_view_
->history_list_offset_
>= kMaxSessionHistoryEntries
)
2500 render_view_
->history_list_offset_
= kMaxSessionHistoryEntries
- 1;
2501 render_view_
->history_list_length_
=
2502 render_view_
->history_list_offset_
+ 1;
2505 // Inspect the navigation_state on this frame to see if the navigation
2506 // corresponds to a session history navigation... Note: |frame| may or
2507 // may not be the toplevel frame, but for the case of capturing session
2508 // history, the first committed frame suffices. We keep track of whether
2509 // we've seen this commit before so that only capture session history once
2512 // Note that we need to check if the page ID changed. In the case of a
2513 // reload, the page ID doesn't change, and UpdateSessionHistory gets the
2514 // previous URL and the current page ID, which would be wrong.
2515 if (navigation_state
->pending_page_id() != -1 &&
2516 navigation_state
->pending_page_id() != render_view_
->page_id_
&&
2517 !navigation_state
->request_committed()) {
2518 // This is a successful session history navigation!
2519 render_view_
->page_id_
= navigation_state
->pending_page_id();
2521 render_view_
->history_list_offset_
=
2522 navigation_state
->pending_history_list_offset();
2527 new FrameHostMsg_DidAssignPageId(routing_id_
, render_view_
->page_id_
));
2528 CHECK(sent
); // http://crbug.com/407376
2530 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers_
,
2531 DidCommitProvisionalLoad(frame
, is_new_navigation
));
2532 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
,
2533 DidCommitProvisionalLoad(is_new_navigation
));
2535 if (!frame
->parent()) { // Only for top frames.
2536 RenderThreadImpl
* render_thread_impl
= RenderThreadImpl::current();
2537 if (render_thread_impl
) { // Can be NULL in tests.
2538 render_thread_impl
->histogram_customizer()->
2539 RenderViewNavigatedToHost(GURL(GetLoadingUrl()).host(),
2540 RenderViewImpl::GetRenderViewCount());
2544 // Remember that we've already processed this request, so we don't update
2545 // the session history again. We do this regardless of whether this is
2546 // a session history navigation, because if we attempted a session history
2547 // navigation without valid HistoryItem state, WebCore will think it is a
2549 navigation_state
->set_request_committed(true);
2551 SendDidCommitProvisionalLoad(frame
, commit_type
);
2553 // Check whether we have new encoding name.
2554 UpdateEncoding(frame
, frame
->view()->pageEncoding().utf8());
2557 void RenderFrameImpl::didCreateNewDocument(blink::WebLocalFrame
* frame
) {
2558 DCHECK(!frame_
|| frame_
== frame
);
2560 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2561 DidCreateNewDocument(frame
));
2564 void RenderFrameImpl::didClearWindowObject(blink::WebLocalFrame
* frame
) {
2565 DCHECK(!frame_
|| frame_
== frame
);
2566 // TODO(nasko): Move implementation here. Needed state:
2567 // * enabled_bindings_
2568 // * dom_automation_controller_
2569 // * stats_collection_controller_
2571 render_view_
->didClearWindowObject(frame
);
2573 if (render_view_
->GetEnabledBindings() & BINDINGS_POLICY_DOM_AUTOMATION
)
2574 DomAutomationController::Install(this, frame
);
2576 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, DidClearWindowObject());
2579 void RenderFrameImpl::didCreateDocumentElement(blink::WebLocalFrame
* frame
) {
2580 DCHECK(!frame_
|| frame_
== frame
);
2582 // Notify the browser about non-blank documents loading in the top frame.
2583 GURL url
= frame
->document().url();
2584 if (url
.is_valid() && url
.spec() != url::kAboutBlankURL
) {
2585 // TODO(nasko): Check if webview()->mainFrame() is the same as the
2586 // frame->tree()->top().
2587 blink::WebFrame
* main_frame
= render_view_
->webview()->mainFrame();
2588 if (frame
== main_frame
) {
2589 // For now, don't remember plugin zoom values. We don't want to mix them
2590 // with normal web content (i.e. a fixed layout plugin would usually want
2592 render_view_
->Send(new ViewHostMsg_DocumentAvailableInMainFrame(
2593 render_view_
->GetRoutingID(),
2594 main_frame
->document().isPluginDocument()));
2598 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2599 DidCreateDocumentElement(frame
));
2602 void RenderFrameImpl::didReceiveTitle(blink::WebLocalFrame
* frame
,
2603 const blink::WebString
& title
,
2604 blink::WebTextDirection direction
) {
2605 DCHECK(!frame_
|| frame_
== frame
);
2606 // Ignore all but top level navigations.
2607 if (!frame
->parent()) {
2608 base::string16 title16
= title
;
2609 base::trace_event::TraceLog::GetInstance()->UpdateProcessLabel(
2610 routing_id_
, base::UTF16ToUTF8(title16
));
2612 base::string16 shortened_title
= title16
.substr(0, kMaxTitleChars
);
2613 Send(new FrameHostMsg_UpdateTitle(routing_id_
,
2614 shortened_title
, direction
));
2617 // Also check whether we have new encoding name.
2618 UpdateEncoding(frame
, frame
->view()->pageEncoding().utf8());
2621 void RenderFrameImpl::didChangeIcon(blink::WebLocalFrame
* frame
,
2622 blink::WebIconURL::Type icon_type
) {
2623 DCHECK(!frame_
|| frame_
== frame
);
2624 // TODO(nasko): Investigate wheather implementation should move here.
2625 render_view_
->didChangeIcon(frame
, icon_type
);
2628 void RenderFrameImpl::didFinishDocumentLoad(blink::WebLocalFrame
* frame
) {
2629 TRACE_EVENT1("navigation", "RenderFrameImpl::didFinishDocumentLoad",
2631 DCHECK(!frame_
|| frame_
== frame
);
2632 WebDataSource
* ds
= frame
->dataSource();
2633 DocumentState
* document_state
= DocumentState::FromDataSource(ds
);
2634 document_state
->set_finish_document_load_time(Time::Now());
2636 Send(new FrameHostMsg_DidFinishDocumentLoad(routing_id_
));
2638 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2639 DidFinishDocumentLoad(frame
));
2640 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, DidFinishDocumentLoad());
2642 // Check whether we have new encoding name.
2643 UpdateEncoding(frame
, frame
->view()->pageEncoding().utf8());
2646 void RenderFrameImpl::didHandleOnloadEvents(blink::WebLocalFrame
* frame
) {
2647 DCHECK(!frame_
|| frame_
== frame
);
2648 if (!frame
->parent()) {
2649 FrameMsg_UILoadMetricsReportType::Value report_type
=
2650 static_cast<FrameMsg_UILoadMetricsReportType::Value
>(
2651 frame
->dataSource()->request().inputPerfMetricReportPolicy());
2652 base::TimeTicks ui_timestamp
= base::TimeTicks() +
2653 base::TimeDelta::FromSecondsD(
2654 frame
->dataSource()->request().uiStartTime());
2656 Send(new FrameHostMsg_DocumentOnLoadCompleted(
2657 routing_id_
, report_type
, ui_timestamp
));
2661 void RenderFrameImpl::didFailLoad(blink::WebLocalFrame
* frame
,
2662 const blink::WebURLError
& error
) {
2663 TRACE_EVENT1("navigation", "RenderFrameImpl::didFailLoad",
2665 DCHECK(!frame_
|| frame_
== frame
);
2666 // TODO(nasko): Move implementation here. No state needed.
2667 WebDataSource
* ds
= frame
->dataSource();
2670 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2671 DidFailLoad(frame
, error
));
2673 const WebURLRequest
& failed_request
= ds
->request();
2674 base::string16 error_description
;
2675 GetContentClient()->renderer()->GetNavigationErrorStrings(
2681 &error_description
);
2682 Send(new FrameHostMsg_DidFailLoadWithError(routing_id_
,
2683 failed_request
.url(),
2685 error_description
));
2688 void RenderFrameImpl::didFinishLoad(blink::WebLocalFrame
* frame
) {
2689 TRACE_EVENT1("navigation", "RenderFrameImpl::didFinishLoad",
2691 DCHECK(!frame_
|| frame_
== frame
);
2692 WebDataSource
* ds
= frame
->dataSource();
2693 DocumentState
* document_state
= DocumentState::FromDataSource(ds
);
2694 if (document_state
->finish_load_time().is_null()) {
2695 if (!frame
->parent()) {
2696 TRACE_EVENT_INSTANT0("WebCore", "LoadFinished",
2697 TRACE_EVENT_SCOPE_PROCESS
);
2699 document_state
->set_finish_load_time(Time::Now());
2702 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers(),
2703 DidFinishLoad(frame
));
2704 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, DidFinishLoad());
2706 // Don't send this message while the frame is swapped out.
2707 if (is_swapped_out())
2710 Send(new FrameHostMsg_DidFinishLoad(routing_id_
,
2711 ds
->request().url()));
2714 void RenderFrameImpl::didNavigateWithinPage(blink::WebLocalFrame
* frame
,
2715 const blink::WebHistoryItem
& item
,
2716 blink::WebHistoryCommitType commit_type
) {
2717 TRACE_EVENT1("navigation", "RenderFrameImpl::didNavigateWithinPage",
2719 DCHECK(!frame_
|| frame_
== frame
);
2720 // If this was a reference fragment navigation that we initiated, then we
2721 // could end up having a non-null pending navigation params. We just need to
2722 // update the ExtraData on the datasource so that others who read the
2723 // ExtraData will get the new NavigationState. Similarly, if we did not
2724 // initiate this navigation, then we need to take care to reset any pre-
2725 // existing navigation state to a content-initiated navigation state.
2726 // DidCreateDataSource conveniently takes care of this for us.
2727 didCreateDataSource(frame
, frame
->dataSource());
2729 DocumentState
* document_state
=
2730 DocumentState::FromDataSource(frame
->dataSource());
2731 NavigationState
* new_state
= document_state
->navigation_state();
2732 new_state
->set_was_within_same_page(true);
2734 didCommitProvisionalLoad(frame
, item
, commit_type
);
2737 void RenderFrameImpl::didUpdateCurrentHistoryItem(blink::WebLocalFrame
* frame
) {
2738 DCHECK(!frame_
|| frame_
== frame
);
2739 // TODO(nasko): Move implementation here. Needed methods:
2740 // * StartNavStateSyncTimerIfNecessary
2741 render_view_
->didUpdateCurrentHistoryItem(frame
);
2744 void RenderFrameImpl::addNavigationTransitionData(
2745 const blink::WebTransitionElementData
& data
) {
2746 FrameHostMsg_AddNavigationTransitionData_Params params
;
2747 params
.render_frame_id
= routing_id_
;
2748 params
.allowed_destination_host_pattern
=
2750 params
.selector
= data
.selector
.utf8();
2751 params
.markup
= data
.markup
.utf8();
2752 params
.elements
.resize(data
.elements
.size());
2753 for (size_t i
= 0; i
< data
.elements
.size(); i
++) {
2754 params
.elements
[i
].id
= data
.elements
[i
].id
.utf8();
2755 params
.elements
[i
].rect
= gfx::Rect(data
.elements
[i
].rect
);
2758 Send(new FrameHostMsg_AddNavigationTransitionData(params
));
2761 void RenderFrameImpl::didChangeThemeColor() {
2762 if (frame_
->parent())
2765 Send(new FrameHostMsg_DidChangeThemeColor(
2766 routing_id_
, frame_
->document().themeColor()));
2769 void RenderFrameImpl::requestNotificationPermission(
2770 const blink::WebSecurityOrigin
& origin
,
2771 blink::WebNotificationPermissionCallback
* callback
) {
2772 if (!notification_permission_dispatcher_
) {
2773 notification_permission_dispatcher_
=
2774 new NotificationPermissionDispatcher(this);
2777 notification_permission_dispatcher_
->RequestPermission(origin
, callback
);
2780 void RenderFrameImpl::didChangeSelection(bool is_empty_selection
) {
2781 if (!GetRenderWidget()->handling_input_event() && !handling_select_range_
)
2784 if (is_empty_selection
)
2785 selection_text_
.clear();
2787 // UpdateTextInputType should be called before SyncSelectionIfRequired.
2788 // UpdateTextInputType may send TextInputTypeChanged to notify the focus
2789 // was changed, and SyncSelectionIfRequired may send SelectionChanged
2790 // to notify the selection was changed. Focus change should be notified
2791 // before selection change.
2792 GetRenderWidget()->UpdateTextInputType();
2793 SyncSelectionIfRequired();
2794 #if defined(OS_ANDROID)
2795 GetRenderWidget()->UpdateTextInputState(RenderWidget::NO_SHOW_IME
,
2796 RenderWidget::FROM_NON_IME
);
2800 blink::WebColorChooser
* RenderFrameImpl::createColorChooser(
2801 blink::WebColorChooserClient
* client
,
2802 const blink::WebColor
& initial_color
,
2803 const blink::WebVector
<blink::WebColorSuggestion
>& suggestions
) {
2804 RendererWebColorChooserImpl
* color_chooser
=
2805 new RendererWebColorChooserImpl(this, client
);
2806 std::vector
<ColorSuggestion
> color_suggestions
;
2807 for (size_t i
= 0; i
< suggestions
.size(); i
++) {
2808 color_suggestions
.push_back(ColorSuggestion(suggestions
[i
]));
2810 color_chooser
->Open(static_cast<SkColor
>(initial_color
), color_suggestions
);
2811 return color_chooser
;
2814 void RenderFrameImpl::runModalAlertDialog(const blink::WebString
& message
) {
2815 RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_ALERT
,
2818 frame_
->document().url(),
2822 bool RenderFrameImpl::runModalConfirmDialog(const blink::WebString
& message
) {
2823 return RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_CONFIRM
,
2826 frame_
->document().url(),
2830 bool RenderFrameImpl::runModalPromptDialog(
2831 const blink::WebString
& message
,
2832 const blink::WebString
& default_value
,
2833 blink::WebString
* actual_value
) {
2834 base::string16 result
;
2835 bool ok
= RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_PROMPT
,
2838 frame_
->document().url(),
2841 actual_value
->assign(result
);
2845 bool RenderFrameImpl::runModalBeforeUnloadDialog(
2847 const blink::WebString
& message
) {
2848 // If we are swapping out, we have already run the beforeunload handler.
2849 // TODO(creis): Fix OnSwapOut to clear the frame without running beforeunload
2850 // at all, to avoid running it twice.
2851 if (is_swapped_out_
)
2854 // Don't allow further dialogs if we are waiting to swap out, since the
2855 // PageGroupLoadDeferrer in our stack prevents it.
2856 if (render_view()->suppress_dialogs_until_swap_out_
)
2859 bool success
= false;
2860 // This is an ignored return value, but is included so we can accept the same
2861 // response as RunJavaScriptMessage.
2862 base::string16 ignored_result
;
2863 render_view()->SendAndRunNestedMessageLoop(
2864 new FrameHostMsg_RunBeforeUnloadConfirm(
2865 routing_id_
, frame_
->document().url(), message
, is_reload
,
2866 &success
, &ignored_result
));
2870 void RenderFrameImpl::showContextMenu(const blink::WebContextMenuData
& data
) {
2871 ContextMenuParams params
= ContextMenuParamsBuilder::Build(data
);
2872 params
.source_type
= GetRenderWidget()->context_menu_source_type();
2873 GetRenderWidget()->OnShowHostContextMenu(¶ms
);
2874 if (GetRenderWidget()->has_host_context_menu_location()) {
2875 params
.x
= GetRenderWidget()->host_context_menu_location().x();
2876 params
.y
= GetRenderWidget()->host_context_menu_location().y();
2879 // Serializing a GURL longer than kMaxURLChars will fail, so don't do
2880 // it. We replace it with an empty GURL so the appropriate items are disabled
2881 // in the context menu.
2882 // TODO(jcivelli): http://crbug.com/45160 This prevents us from saving large
2883 // data encoded images. We should have a way to save them.
2884 if (params
.src_url
.spec().size() > GetMaxURLChars())
2885 params
.src_url
= GURL();
2886 context_menu_node_
= data
.node
;
2888 #if defined(OS_ANDROID)
2889 gfx::Rect start_rect
;
2891 GetRenderWidget()->GetSelectionBounds(&start_rect
, &end_rect
);
2892 params
.selection_start
= gfx::Point(start_rect
.x(), start_rect
.bottom());
2893 params
.selection_end
= gfx::Point(end_rect
.right(), end_rect
.bottom());
2896 Send(new FrameHostMsg_ContextMenu(routing_id_
, params
));
2899 void RenderFrameImpl::clearContextMenu() {
2900 context_menu_node_
.reset();
2903 void RenderFrameImpl::willSendRequest(
2904 blink::WebLocalFrame
* frame
,
2905 unsigned identifier
,
2906 blink::WebURLRequest
& request
,
2907 const blink::WebURLResponse
& redirect_response
) {
2908 DCHECK(!frame_
|| frame_
== frame
);
2909 // The request my be empty during tests.
2910 if (request
.url().isEmpty())
2913 // Set the first party for cookies url if it has not been set yet (new
2914 // requests). For redirects, it is updated by WebURLLoaderImpl.
2915 if (request
.firstPartyForCookies().isEmpty()) {
2916 if (request
.frameType() == blink::WebURLRequest::FrameTypeTopLevel
) {
2917 request
.setFirstPartyForCookies(request
.url());
2919 // TODO(nasko): When the top-level frame is remote, there is no document.
2920 // This is broken and should be fixed to propagate the first party.
2921 WebFrame
* top
= frame
->top();
2922 if (top
->isWebLocalFrame()) {
2923 request
.setFirstPartyForCookies(
2924 frame
->top()->document().firstPartyForCookies());
2929 WebFrame
* top_frame
= frame
->top();
2930 // TODO(nasko): Hack around asking about top-frame data source. This means
2931 // for out-of-process iframes we are treating the current frame as the
2932 // top-level frame, which is wrong.
2933 if (!top_frame
|| top_frame
->isWebRemoteFrame())
2935 WebDataSource
* provisional_data_source
= top_frame
->provisionalDataSource();
2936 WebDataSource
* top_data_source
= top_frame
->dataSource();
2937 WebDataSource
* data_source
=
2938 provisional_data_source
? provisional_data_source
: top_data_source
;
2940 DocumentState
* document_state
= DocumentState::FromDataSource(data_source
);
2941 DCHECK(document_state
);
2942 InternalDocumentStateData
* internal_data
=
2943 InternalDocumentStateData::FromDocumentState(document_state
);
2944 NavigationState
* navigation_state
= document_state
->navigation_state();
2945 ui::PageTransition transition_type
= navigation_state
->transition_type();
2946 WebDataSource
* frame_ds
= frame
->provisionalDataSource();
2947 if (frame_ds
&& frame_ds
->isClientRedirect()) {
2948 transition_type
= ui::PageTransitionFromInt(
2949 transition_type
| ui::PAGE_TRANSITION_CLIENT_REDIRECT
);
2952 GURL
request_url(request
.url());
2954 if (GetContentClient()->renderer()->WillSendRequest(
2958 request
.firstPartyForCookies(),
2960 request
.setURL(WebURL(new_url
));
2963 if (internal_data
->is_cache_policy_override_set())
2964 request
.setCachePolicy(internal_data
->cache_policy_override());
2966 // The request's extra data may indicate that we should set a custom user
2967 // agent. This needs to be done here, after WebKit is through with setting the
2968 // user agent on its own. Similarly, it may indicate that we should set an
2969 // X-Requested-With header. This must be done here to avoid breaking CORS
2971 // PlzNavigate: there may also be a stream url associated with the request.
2972 WebString custom_user_agent
;
2973 WebString requested_with
;
2974 scoped_ptr
<StreamOverrideParameters
> stream_override
;
2975 if (request
.extraData()) {
2976 RequestExtraData
* old_extra_data
=
2977 static_cast<RequestExtraData
*>(request
.extraData());
2979 custom_user_agent
= old_extra_data
->custom_user_agent();
2980 if (!custom_user_agent
.isNull()) {
2981 if (custom_user_agent
.isEmpty())
2982 request
.clearHTTPHeaderField("User-Agent");
2984 request
.setHTTPHeaderField("User-Agent", custom_user_agent
);
2987 requested_with
= old_extra_data
->requested_with();
2988 if (!requested_with
.isNull()) {
2989 if (requested_with
.isEmpty())
2990 request
.clearHTTPHeaderField("X-Requested-With");
2992 request
.setHTTPHeaderField("X-Requested-With", requested_with
);
2994 stream_override
= old_extra_data
->TakeStreamOverrideOwnership();
2997 // Add the default accept header for frame request if it has not been set
2999 if ((request
.frameType() == blink::WebURLRequest::FrameTypeTopLevel
||
3000 request
.frameType() == blink::WebURLRequest::FrameTypeNested
) &&
3001 request
.httpHeaderField(WebString::fromUTF8(kAcceptHeader
)).isEmpty()) {
3002 request
.setHTTPHeaderField(WebString::fromUTF8(kAcceptHeader
),
3003 WebString::fromUTF8(kDefaultAcceptHeader
));
3006 // Add an empty HTTP origin header for non GET methods if none is currently
3008 request
.addHTTPOriginIfNeeded(WebString());
3010 // Attach |should_replace_current_entry| state to requests so that, should
3011 // this navigation later require a request transfer, all state is preserved
3012 // when it is re-created in the new process.
3013 bool should_replace_current_entry
= false;
3014 if (navigation_state
->is_content_initiated()) {
3015 should_replace_current_entry
= data_source
->replacesCurrentHistoryItem();
3017 // If the navigation is browser-initiated, the NavigationState contains the
3018 // correct value instead of the WebDataSource.
3020 // TODO(davidben): Avoid this awkward duplication of state. See comment on
3021 // NavigationState::should_replace_current_entry().
3022 should_replace_current_entry
=
3023 navigation_state
->should_replace_current_entry();
3026 int provider_id
= kInvalidServiceWorkerProviderId
;
3027 if (request
.frameType() == blink::WebURLRequest::FrameTypeTopLevel
||
3028 request
.frameType() == blink::WebURLRequest::FrameTypeNested
) {
3029 // |provisionalDataSource| may be null in some content::ResourceFetcher
3030 // use cases, we don't hook those requests.
3031 if (frame
->provisionalDataSource()) {
3032 ServiceWorkerNetworkProvider
* provider
=
3033 ServiceWorkerNetworkProvider::FromDocumentState(
3034 DocumentState::FromDataSource(frame
->provisionalDataSource()));
3035 provider_id
= provider
->provider_id();
3037 } else if (frame
->dataSource()) {
3038 ServiceWorkerNetworkProvider
* provider
=
3039 ServiceWorkerNetworkProvider::FromDocumentState(
3040 DocumentState::FromDataSource(frame
->dataSource()));
3041 provider_id
= provider
->provider_id();
3044 WebFrame
* parent
= frame
->parent();
3045 int parent_routing_id
= MSG_ROUTING_NONE
;
3047 parent_routing_id
= -1;
3048 } else if (parent
->isWebLocalFrame()) {
3049 parent_routing_id
= FromWebFrame(parent
)->GetRoutingID();
3051 parent_routing_id
= RenderFrameProxy::FromWebFrame(parent
)->routing_id();
3054 RequestExtraData
* extra_data
= new RequestExtraData();
3055 extra_data
->set_visibility_state(render_view_
->visibilityState());
3056 extra_data
->set_custom_user_agent(custom_user_agent
);
3057 extra_data
->set_requested_with(requested_with
);
3058 extra_data
->set_render_frame_id(routing_id_
);
3059 extra_data
->set_is_main_frame(!parent
);
3060 extra_data
->set_frame_origin(
3061 GURL(frame
->document().securityOrigin().toString()));
3062 extra_data
->set_parent_is_main_frame(parent
&& !parent
->parent());
3063 extra_data
->set_parent_render_frame_id(parent_routing_id
);
3064 extra_data
->set_allow_download(navigation_state
->allow_download());
3065 extra_data
->set_transition_type(transition_type
);
3066 extra_data
->set_should_replace_current_entry(should_replace_current_entry
);
3067 extra_data
->set_transferred_request_child_id(
3068 navigation_state
->transferred_request_child_id());
3069 extra_data
->set_transferred_request_request_id(
3070 navigation_state
->transferred_request_request_id());
3071 extra_data
->set_service_worker_provider_id(provider_id
);
3072 extra_data
->set_stream_override(stream_override
.Pass());
3073 request
.setExtraData(extra_data
);
3075 DocumentState
* top_document_state
=
3076 DocumentState::FromDataSource(top_data_source
);
3077 if (top_document_state
) {
3078 // TODO(gavinp): separate out prefetching and prerender field trials
3079 // if the rel=prerender rel type is sticking around.
3080 if (request
.requestContext() == WebURLRequest::RequestContextPrefetch
)
3081 top_document_state
->set_was_prefetcher(true);
3084 // This is an instance where we embed a copy of the routing id
3085 // into the data portion of the message. This can cause problems if we
3086 // don't register this id on the browser side, since the download manager
3087 // expects to find a RenderViewHost based off the id.
3088 request
.setRequestorID(render_view_
->GetRoutingID());
3089 request
.setHasUserGesture(WebUserGestureIndicator::isProcessingUserGesture());
3091 if (!navigation_state
->extra_headers().empty()) {
3092 for (net::HttpUtil::HeadersIterator
i(
3093 navigation_state
->extra_headers().begin(),
3094 navigation_state
->extra_headers().end(), "\n");
3096 if (LowerCaseEqualsASCII(i
.name(), "referer")) {
3097 WebString referrer
= WebSecurityPolicy::generateReferrerHeader(
3098 blink::WebReferrerPolicyDefault
,
3100 WebString::fromUTF8(i
.values()));
3101 request
.setHTTPReferrer(referrer
, blink::WebReferrerPolicyDefault
);
3103 request
.setHTTPHeaderField(WebString::fromUTF8(i
.name()),
3104 WebString::fromUTF8(i
.values()));
3109 if (!render_view_
->renderer_preferences_
.enable_referrers
)
3110 request
.setHTTPReferrer(WebString(), blink::WebReferrerPolicyDefault
);
3113 void RenderFrameImpl::didReceiveResponse(
3114 blink::WebLocalFrame
* frame
,
3115 unsigned identifier
,
3116 const blink::WebURLResponse
& response
) {
3117 DCHECK(!frame_
|| frame_
== frame
);
3118 // Only do this for responses that correspond to a provisional data source
3119 // of the top-most frame. If we have a provisional data source, then we
3120 // can't have any sub-resources yet, so we know that this response must
3121 // correspond to a frame load.
3122 if (!frame
->provisionalDataSource() || frame
->parent())
3125 // If we are in view source mode, then just let the user see the source of
3126 // the server's error page.
3127 if (frame
->isViewSourceModeEnabled())
3130 DocumentState
* document_state
=
3131 DocumentState::FromDataSource(frame
->provisionalDataSource());
3132 int http_status_code
= response
.httpStatusCode();
3134 // Record page load flags.
3135 WebURLResponseExtraDataImpl
* extra_data
= GetExtraDataFromResponse(response
);
3137 document_state
->set_was_fetched_via_spdy(
3138 extra_data
->was_fetched_via_spdy());
3139 document_state
->set_was_npn_negotiated(
3140 extra_data
->was_npn_negotiated());
3141 document_state
->set_npn_negotiated_protocol(
3142 extra_data
->npn_negotiated_protocol());
3143 document_state
->set_was_alternate_protocol_available(
3144 extra_data
->was_alternate_protocol_available());
3145 document_state
->set_connection_info(
3146 extra_data
->connection_info());
3147 document_state
->set_was_fetched_via_proxy(
3148 extra_data
->was_fetched_via_proxy());
3149 document_state
->set_proxy_server(
3150 extra_data
->proxy_server());
3152 InternalDocumentStateData
* internal_data
=
3153 InternalDocumentStateData::FromDocumentState(document_state
);
3154 internal_data
->set_http_status_code(http_status_code
);
3155 // Whether or not the http status code actually corresponds to an error is
3156 // only checked when the page is done loading, if |use_error_page| is
3158 internal_data
->set_use_error_page(true);
3161 void RenderFrameImpl::didFinishResourceLoad(blink::WebLocalFrame
* frame
,
3162 unsigned identifier
) {
3163 DCHECK(!frame_
|| frame_
== frame
);
3164 InternalDocumentStateData
* internal_data
=
3165 InternalDocumentStateData::FromDataSource(frame
->dataSource());
3166 if (!internal_data
->use_error_page())
3169 // Do not show error page when DevTools is attached.
3170 if (render_view_
->devtools_agent_
->IsAttached())
3173 // Display error page, if appropriate.
3174 std::string error_domain
= "http";
3175 int http_status_code
= internal_data
->http_status_code();
3176 if (GetContentClient()->renderer()->HasErrorPage(
3177 http_status_code
, &error_domain
)) {
3179 error
.unreachableURL
= frame
->document().url();
3180 error
.domain
= WebString::fromUTF8(error_domain
);
3181 error
.reason
= http_status_code
;
3182 LoadNavigationErrorPage(frame
->dataSource()->request(), error
, true);
3186 void RenderFrameImpl::didLoadResourceFromMemoryCache(
3187 blink::WebLocalFrame
* frame
,
3188 const blink::WebURLRequest
& request
,
3189 const blink::WebURLResponse
& response
) {
3190 DCHECK(!frame_
|| frame_
== frame
);
3191 // The recipients of this message have no use for data: URLs: they don't
3192 // affect the page's insecure content list and are not in the disk cache. To
3193 // prevent large (1M+) data: URLs from crashing in the IPC system, we simply
3194 // filter them out here.
3195 GURL
url(request
.url());
3196 if (url
.SchemeIs(url::kDataScheme
))
3199 // Let the browser know we loaded a resource from the memory cache. This
3200 // message is needed to display the correct SSL indicators.
3201 render_view_
->Send(new ViewHostMsg_DidLoadResourceFromMemoryCache(
3202 render_view_
->GetRoutingID(),
3204 response
.securityInfo(),
3205 request
.httpMethod().utf8(),
3206 response
.mimeType().utf8(),
3207 WebURLRequestToResourceType(request
)));
3210 void RenderFrameImpl::didDisplayInsecureContent(blink::WebLocalFrame
* frame
) {
3211 DCHECK(!frame_
|| frame_
== frame
);
3212 render_view_
->Send(new ViewHostMsg_DidDisplayInsecureContent(
3213 render_view_
->GetRoutingID()));
3216 void RenderFrameImpl::didRunInsecureContent(
3217 blink::WebLocalFrame
* frame
,
3218 const blink::WebSecurityOrigin
& origin
,
3219 const blink::WebURL
& target
) {
3220 DCHECK(!frame_
|| frame_
== frame
);
3221 render_view_
->Send(new ViewHostMsg_DidRunInsecureContent(
3222 render_view_
->GetRoutingID(),
3223 origin
.toString().utf8(),
3227 void RenderFrameImpl::didAbortLoading(blink::WebLocalFrame
* frame
) {
3228 DCHECK(!frame_
|| frame_
== frame
);
3229 #if defined(ENABLE_PLUGINS)
3230 if (frame
!= render_view_
->webview()->mainFrame())
3232 PluginChannelHost::Broadcast(
3233 new PluginHostMsg_DidAbortLoading(render_view_
->GetRoutingID()));
3237 void RenderFrameImpl::didCreateScriptContext(blink::WebLocalFrame
* frame
,
3238 v8::Handle
<v8::Context
> context
,
3239 int extension_group
,
3241 DCHECK(!frame_
|| frame_
== frame
);
3242 GetContentClient()->renderer()->DidCreateScriptContext(
3243 frame
, context
, extension_group
, world_id
);
3246 void RenderFrameImpl::willReleaseScriptContext(blink::WebLocalFrame
* frame
,
3247 v8::Handle
<v8::Context
> context
,
3249 DCHECK(!frame_
|| frame_
== frame
);
3251 FOR_EACH_OBSERVER(RenderFrameObserver
,
3253 WillReleaseScriptContext(context
, world_id
));
3256 void RenderFrameImpl::didFirstVisuallyNonEmptyLayout(
3257 blink::WebLocalFrame
* frame
) {
3258 DCHECK(!frame_
|| frame_
== frame
);
3259 if (frame
->parent())
3262 InternalDocumentStateData
* data
=
3263 InternalDocumentStateData::FromDataSource(frame
->dataSource());
3264 data
->set_did_first_visually_non_empty_layout(true);
3266 #if defined(OS_ANDROID)
3267 GetRenderWidget()->DidChangeBodyBackgroundColor(
3268 render_view_
->webwidget_
->backgroundColor());
3271 GetRenderWidget()->QueueMessage(
3272 new FrameHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_
),
3273 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE
);
3276 void RenderFrameImpl::didChangeScrollOffset(blink::WebLocalFrame
* frame
) {
3277 DCHECK(!frame_
|| frame_
== frame
);
3278 // TODO(nasko): Move implementation here. Needed methods:
3279 // * StartNavStateSyncTimerIfNecessary
3280 render_view_
->didChangeScrollOffset(frame
);
3282 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, DidChangeScrollOffset());
3285 void RenderFrameImpl::willInsertBody(blink::WebLocalFrame
* frame
) {
3286 DCHECK(!frame_
|| frame_
== frame
);
3287 if (!frame
->parent()) {
3288 render_view_
->Send(new ViewHostMsg_WillInsertBody(
3289 render_view_
->GetRoutingID()));
3293 void RenderFrameImpl::reportFindInPageMatchCount(int request_id
,
3295 bool final_update
) {
3296 int active_match_ordinal
= -1; // -1 = don't update active match ordinal
3298 active_match_ordinal
= 0;
3300 render_view_
->Send(new ViewHostMsg_Find_Reply(
3301 render_view_
->GetRoutingID(), request_id
, count
,
3302 gfx::Rect(), active_match_ordinal
, final_update
));
3305 void RenderFrameImpl::reportFindInPageSelection(
3307 int active_match_ordinal
,
3308 const blink::WebRect
& selection_rect
) {
3309 render_view_
->Send(new ViewHostMsg_Find_Reply(
3310 render_view_
->GetRoutingID(), request_id
, -1, selection_rect
,
3311 active_match_ordinal
, false));
3314 void RenderFrameImpl::requestStorageQuota(
3315 blink::WebLocalFrame
* frame
,
3316 blink::WebStorageQuotaType type
,
3317 unsigned long long requested_size
,
3318 blink::WebStorageQuotaCallbacks callbacks
) {
3319 DCHECK(!frame_
|| frame_
== frame
);
3320 WebSecurityOrigin origin
= frame
->document().securityOrigin();
3321 if (origin
.isUnique()) {
3322 // Unique origins cannot store persistent state.
3323 callbacks
.didFail(blink::WebStorageQuotaErrorAbort
);
3326 ChildThreadImpl::current()->quota_dispatcher()->RequestStorageQuota(
3327 render_view_
->GetRoutingID(),
3328 GURL(origin
.toString()),
3329 static_cast<storage::StorageType
>(type
),
3331 QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks
));
3334 void RenderFrameImpl::willOpenWebSocket(blink::WebSocketHandle
* handle
) {
3335 WebSocketBridge
* impl
= static_cast<WebSocketBridge
*>(handle
);
3336 impl
->set_render_frame_id(routing_id_
);
3339 blink::WebGeolocationClient
* RenderFrameImpl::geolocationClient() {
3340 if (!geolocation_dispatcher_
)
3341 geolocation_dispatcher_
= new GeolocationDispatcher(this);
3342 return geolocation_dispatcher_
;
3345 blink::WebPresentationClient
* RenderFrameImpl::presentationClient() {
3346 if (!presentation_dispatcher_
)
3347 presentation_dispatcher_
= new PresentationDispatcher(this);
3348 return presentation_dispatcher_
;
3351 blink::WebPushClient
* RenderFrameImpl::pushClient() {
3352 if (!push_messaging_dispatcher_
)
3353 push_messaging_dispatcher_
= new PushMessagingDispatcher(this);
3354 return push_messaging_dispatcher_
;
3357 void RenderFrameImpl::willStartUsingPeerConnectionHandler(
3358 blink::WebLocalFrame
* frame
,
3359 blink::WebRTCPeerConnectionHandler
* handler
) {
3360 DCHECK(!frame_
|| frame_
== frame
);
3361 #if defined(ENABLE_WEBRTC)
3362 static_cast<RTCPeerConnectionHandler
*>(handler
)->associateWithFrame(frame
);
3366 blink::WebUserMediaClient
* RenderFrameImpl::userMediaClient() {
3367 if (!web_user_media_client_
)
3368 InitializeUserMediaClient();
3369 return web_user_media_client_
;
3372 blink::WebEncryptedMediaClient
* RenderFrameImpl::encryptedMediaClient() {
3373 if (!web_encrypted_media_client_
) {
3374 #if defined(ENABLE_PEPPER_CDMS)
3375 scoped_ptr
<media::CdmFactory
> cdm_factory(
3376 new RenderCdmFactory(base::Bind(PepperCdmWrapperImpl::Create
, frame_
)));
3377 #elif defined(ENABLE_BROWSER_CDMS)
3378 scoped_ptr
<media::CdmFactory
> cdm_factory(
3379 new RenderCdmFactory(GetCdmManager()));
3381 scoped_ptr
<media::CdmFactory
> cdm_factory(new RenderCdmFactory());
3384 if (!media_permission_dispatcher_
)
3385 media_permission_dispatcher_
= new MediaPermissionDispatcher(this);
3387 web_encrypted_media_client_
.reset(new media::WebEncryptedMediaClientImpl(
3388 cdm_factory
.Pass(), media_permission_dispatcher_
));
3390 return web_encrypted_media_client_
.get();
3393 blink::WebMIDIClient
* RenderFrameImpl::webMIDIClient() {
3394 if (!midi_dispatcher_
)
3395 midi_dispatcher_
= new MidiDispatcher(this);
3396 return midi_dispatcher_
;
3399 bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
3400 blink::WebLocalFrame
* source_frame
,
3401 blink::WebFrame
* target_frame
,
3402 blink::WebSecurityOrigin target_origin
,
3403 blink::WebDOMMessageEvent event
) {
3404 DCHECK(!frame_
|| frame_
== target_frame
);
3406 if (!is_swapped_out_
)
3409 ViewMsg_PostMessage_Params params
;
3410 params
.is_data_raw_string
= false;
3411 params
.data
= event
.data().toString();
3412 params
.source_origin
= event
.origin();
3413 if (!target_origin
.isNull())
3414 params
.target_origin
= target_origin
.toString();
3416 blink::WebMessagePortChannelArray channels
= event
.releaseChannels();
3417 if (!channels
.isEmpty()) {
3418 std::vector
<int> message_port_ids(channels
.size());
3419 // Extract the port IDs from the channel array.
3420 for (size_t i
= 0; i
< channels
.size(); ++i
) {
3421 WebMessagePortChannelImpl
* webchannel
=
3422 static_cast<WebMessagePortChannelImpl
*>(channels
[i
]);
3423 message_port_ids
[i
] = webchannel
->message_port_id();
3424 webchannel
->QueueMessages();
3425 DCHECK_NE(message_port_ids
[i
], MSG_ROUTING_NONE
);
3427 params
.message_port_ids
= message_port_ids
;
3430 // Include the routing ID for the source frame (if one exists), which the
3431 // browser process will translate into the routing ID for the equivalent
3432 // frame in the target process.
3433 params
.source_routing_id
= MSG_ROUTING_NONE
;
3435 RenderViewImpl
* source_view
=
3436 RenderViewImpl::FromWebView(source_frame
->view());
3438 params
.source_routing_id
= source_view
->routing_id();
3441 Send(new ViewHostMsg_RouteMessageEvent(render_view_
->routing_id_
, params
));
3445 blink::WebString
RenderFrameImpl::userAgentOverride(blink::WebLocalFrame
* frame
,
3446 const blink::WebURL
& url
) {
3447 DCHECK(!frame_
|| frame_
== frame
);
3448 std::string user_agent_override_for_url
=
3449 GetContentClient()->renderer()->GetUserAgentOverrideForURL(GURL(url
));
3450 if (!user_agent_override_for_url
.empty())
3451 return WebString::fromUTF8(user_agent_override_for_url
);
3453 if (!render_view_
->webview() || !render_view_
->webview()->mainFrame() ||
3454 render_view_
->renderer_preferences_
.user_agent_override
.empty()) {
3455 return blink::WebString();
3458 // TODO(nasko): When the top-level frame is remote, there is no WebDataSource
3459 // associated with it, so the checks below are not valid. Temporarily
3460 // return early and fix properly as part of https://crbug.com/426555.
3461 if (render_view_
->webview()->mainFrame()->isWebRemoteFrame())
3462 return blink::WebString();
3464 // If we're in the middle of committing a load, the data source we need
3465 // will still be provisional.
3466 WebFrame
* main_frame
= render_view_
->webview()->mainFrame();
3467 WebDataSource
* data_source
= NULL
;
3468 if (main_frame
->provisionalDataSource())
3469 data_source
= main_frame
->provisionalDataSource();
3471 data_source
= main_frame
->dataSource();
3473 InternalDocumentStateData
* internal_data
= data_source
?
3474 InternalDocumentStateData::FromDataSource(data_source
) : NULL
;
3475 if (internal_data
&& internal_data
->is_overriding_user_agent())
3476 return WebString::fromUTF8(
3477 render_view_
->renderer_preferences_
.user_agent_override
);
3478 return blink::WebString();
3481 blink::WebString
RenderFrameImpl::doNotTrackValue(blink::WebLocalFrame
* frame
) {
3482 DCHECK(!frame_
|| frame_
== frame
);
3483 if (render_view_
->renderer_preferences_
.enable_do_not_track
)
3484 return WebString::fromUTF8("1");
3488 bool RenderFrameImpl::allowWebGL(blink::WebLocalFrame
* frame
,
3489 bool default_value
) {
3490 DCHECK(!frame_
|| frame_
== frame
);
3494 bool blocked
= true;
3495 render_view_
->Send(new ViewHostMsg_Are3DAPIsBlocked(
3496 render_view_
->GetRoutingID(),
3497 GURL(frame
->top()->document().securityOrigin().toString()),
3498 THREE_D_API_TYPE_WEBGL
,
3503 void RenderFrameImpl::didLoseWebGLContext(blink::WebLocalFrame
* frame
,
3504 int arb_robustness_status_code
) {
3505 DCHECK(!frame_
|| frame_
== frame
);
3506 render_view_
->Send(new ViewHostMsg_DidLose3DContext(
3507 GURL(frame
->top()->document().securityOrigin().toString()),
3508 THREE_D_API_TYPE_WEBGL
,
3509 arb_robustness_status_code
));
3512 blink::WebScreenOrientationClient
*
3513 RenderFrameImpl::webScreenOrientationClient() {
3514 if (!screen_orientation_dispatcher_
)
3515 screen_orientation_dispatcher_
= new ScreenOrientationDispatcher(this);
3516 return screen_orientation_dispatcher_
;
3519 bool RenderFrameImpl::isControlledByServiceWorker(WebDataSource
& data_source
) {
3520 ServiceWorkerNetworkProvider
* provider
=
3521 ServiceWorkerNetworkProvider::FromDocumentState(
3522 DocumentState::FromDataSource(&data_source
));
3523 return provider
->context()->controller_handle_id() !=
3524 kInvalidServiceWorkerHandleId
;
3527 int64_t RenderFrameImpl::serviceWorkerID(WebDataSource
& data_source
) {
3528 ServiceWorkerNetworkProvider
* provider
=
3529 ServiceWorkerNetworkProvider::FromDocumentState(
3530 DocumentState::FromDataSource(&data_source
));
3532 if (provider
->context()->controller())
3533 return provider
->context()->controller()->version_id();
3534 return kInvalidServiceWorkerVersionId
;
3537 void RenderFrameImpl::postAccessibilityEvent(const blink::WebAXObject
& obj
,
3538 blink::WebAXEvent event
) {
3539 HandleWebAccessibilityEvent(obj
, event
);
3542 void RenderFrameImpl::handleAccessibilityFindInPageResult(
3545 const blink::WebAXObject
& start_object
,
3547 const blink::WebAXObject
& end_object
,
3549 if (renderer_accessibility_
) {
3550 renderer_accessibility_
->HandleAccessibilityFindInPageResult(
3551 identifier
, match_index
, start_object
, start_offset
,
3552 end_object
, end_offset
);
3556 void RenderFrameImpl::didChangeManifest(blink::WebLocalFrame
* frame
) {
3557 DCHECK(!frame_
|| frame_
== frame
);
3559 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, DidChangeManifest());
3562 bool RenderFrameImpl::enterFullscreen() {
3563 Send(new FrameHostMsg_ToggleFullscreen(routing_id_
, true));
3567 bool RenderFrameImpl::exitFullscreen() {
3568 Send(new FrameHostMsg_ToggleFullscreen(routing_id_
, false));
3572 void RenderFrameImpl::suddenTerminationDisablerChanged(
3574 blink::WebFrameClient::SuddenTerminationDisablerType type
) {
3576 case blink::WebFrameClient::BeforeUnloadHandler
:
3577 Send(new FrameHostMsg_BeforeUnloadHandlersPresent(
3578 routing_id_
, present
));
3580 case blink::WebFrameClient::UnloadHandler
:
3581 Send(new FrameHostMsg_UnloadHandlersPresent(
3582 routing_id_
, present
));
3589 void RenderFrameImpl::DidPlay(blink::WebMediaPlayer
* player
) {
3590 Send(new FrameHostMsg_MediaPlayingNotification(
3591 routing_id_
, reinterpret_cast<int64
>(player
), player
->hasVideo(),
3592 player
->hasAudio(), player
->isRemote()));
3595 void RenderFrameImpl::DidPause(blink::WebMediaPlayer
* player
) {
3596 Send(new FrameHostMsg_MediaPausedNotification(
3597 routing_id_
, reinterpret_cast<int64
>(player
)));
3600 void RenderFrameImpl::PlayerGone(blink::WebMediaPlayer
* player
) {
3604 void RenderFrameImpl::AddObserver(RenderFrameObserver
* observer
) {
3605 observers_
.AddObserver(observer
);
3608 void RenderFrameImpl::RemoveObserver(RenderFrameObserver
* observer
) {
3609 observer
->RenderFrameGone();
3610 observers_
.RemoveObserver(observer
);
3613 void RenderFrameImpl::OnStop() {
3615 frame_
->stopLoading();
3616 if (!frame_
->parent())
3617 FOR_EACH_OBSERVER(RenderViewObserver
, render_view_
->observers_
, OnStop());
3619 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, OnStop());
3622 void RenderFrameImpl::WasHidden() {
3623 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, WasHidden());
3626 void RenderFrameImpl::WasShown() {
3627 // TODO(kenrb): Need to figure out how to do this better. Should
3628 // VisibilityState remain a page-level concept or move to frames?
3629 // The semantics of 'Show' might have to change here.
3630 if (render_widget_
) {
3631 render_view()->webview()->setVisibilityState(
3632 blink::WebPageVisibilityStateVisible
, false);
3634 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, WasShown());
3637 bool RenderFrameImpl::IsHidden() {
3638 return GetRenderWidget()->is_hidden();
3641 // Tell the embedding application that the URL of the active page has changed.
3642 void RenderFrameImpl::SendDidCommitProvisionalLoad(
3643 blink::WebFrame
* frame
,
3644 blink::WebHistoryCommitType commit_type
) {
3645 DCHECK(!frame_
|| frame_
== frame
);
3646 WebDataSource
* ds
= frame
->dataSource();
3649 const WebURLRequest
& request
= ds
->request();
3650 const WebURLResponse
& response
= ds
->response();
3652 DocumentState
* document_state
= DocumentState::FromDataSource(ds
);
3653 NavigationState
* navigation_state
= document_state
->navigation_state();
3654 InternalDocumentStateData
* internal_data
=
3655 InternalDocumentStateData::FromDocumentState(document_state
);
3657 FrameHostMsg_DidCommitProvisionalLoad_Params params
;
3658 params
.http_status_code
= response
.httpStatusCode();
3659 params
.url_is_unreachable
= ds
->hasUnreachableURL();
3660 params
.is_post
= false;
3661 params
.post_id
= -1;
3662 params
.page_id
= render_view_
->page_id_
;
3663 // We need to track the RenderViewHost routing_id because of downstream
3664 // dependencies (crbug.com/392171 DownloadRequestHandle, SaveFileManager,
3665 // ResourceDispatcherHostImpl, MediaStreamUIProxy,
3666 // SpeechRecognitionDispatcherHost and possibly others). They look up the view
3667 // based on the ID stored in the resource requests. Once those dependencies
3668 // are unwound or moved to RenderFrameHost (crbug.com/304341) we can move the
3669 // client to be based on the routing_id of the RenderFrameHost.
3670 params
.render_view_routing_id
= render_view_
->routing_id();
3671 params
.socket_address
.set_host(response
.remoteIPAddress().utf8());
3672 params
.socket_address
.set_port(response
.remotePort());
3673 WebURLResponseExtraDataImpl
* extra_data
= GetExtraDataFromResponse(response
);
3675 params
.was_fetched_via_proxy
= extra_data
->was_fetched_via_proxy();
3676 params
.was_within_same_page
= navigation_state
->was_within_same_page();
3677 params
.security_info
= response
.securityInfo();
3679 // Set the URL to be displayed in the browser UI to the user.
3680 params
.url
= GetLoadingUrl();
3681 DCHECK(!is_swapped_out_
|| params
.url
== GURL(kSwappedOutURL
));
3683 // Set the origin of the frame. This will be replicated to the corresponding
3684 // RenderFrameProxies in other processes.
3685 // TODO(alexmos): Origins for URLs with non-standard schemes are excluded due
3686 // to https://crbug.com/439608 and will be replicated as unique origins.
3687 if (!is_swapped_out_
) {
3688 WebString
serialized_origin(frame
->document().securityOrigin().toString());
3689 if (GURL(serialized_origin
).IsStandard())
3690 params
.origin
= url::Origin(serialized_origin
.utf8());
3693 if (frame
->document().baseURL() != params
.url
)
3694 params
.base_url
= frame
->document().baseURL();
3696 GetRedirectChain(ds
, ¶ms
.redirects
);
3697 params
.should_update_history
= !ds
->hasUnreachableURL() &&
3698 !response
.isMultipartPayload() && (response
.httpStatusCode() != 404);
3700 params
.searchable_form_url
= internal_data
->searchable_form_url();
3701 params
.searchable_form_encoding
= internal_data
->searchable_form_encoding();
3703 params
.gesture
= render_view_
->navigation_gesture_
;
3704 render_view_
->navigation_gesture_
= NavigationGestureUnknown
;
3706 // Make navigation state a part of the DidCommitProvisionalLoad message so
3707 // that committed entry has it at all times.
3708 HistoryEntry
* entry
= render_view_
->history_controller()->GetCurrentEntry();
3710 params
.page_state
= HistoryEntryToPageState(entry
);
3712 params
.page_state
= PageState::CreateFromURL(request
.url());
3714 if (!frame
->parent()) {
3715 // Top-level navigation.
3717 // Reset the zoom limits in case a plugin had changed them previously. This
3718 // will also call us back which will cause us to send a message to
3719 // update WebContentsImpl.
3720 render_view_
->webview()->zoomLimitsChanged(
3721 ZoomFactorToZoomLevel(kMinimumZoomFactor
),
3722 ZoomFactorToZoomLevel(kMaximumZoomFactor
));
3724 // Set zoom level, but don't do it for full-page plugin since they don't use
3725 // the same zoom settings.
3726 HostZoomLevels::iterator host_zoom
=
3727 render_view_
->host_zoom_levels_
.find(GURL(request
.url()));
3728 if (render_view_
->webview()->mainFrame()->document().isPluginDocument()) {
3729 // Reset the zoom levels for plugins.
3730 render_view_
->webview()->setZoomLevel(0);
3732 // If the zoom level is not found, then do nothing. In-page navigation
3733 // relies on not changing the zoom level in this case.
3734 if (host_zoom
!= render_view_
->host_zoom_levels_
.end())
3735 render_view_
->webview()->setZoomLevel(host_zoom
->second
);
3738 if (host_zoom
!= render_view_
->host_zoom_levels_
.end()) {
3739 // This zoom level was merely recorded transiently for this load. We can
3740 // erase it now. If at some point we reload this page, the browser will
3741 // send us a new, up-to-date zoom level.
3742 render_view_
->host_zoom_levels_
.erase(host_zoom
);
3745 // Update contents MIME type for main frame.
3746 params
.contents_mime_type
= ds
->response().mimeType().utf8();
3748 params
.transition
= navigation_state
->transition_type();
3749 if (!ui::PageTransitionIsMainFrame(params
.transition
)) {
3750 // If the main frame does a load, it should not be reported as a subframe
3751 // navigation. This can occur in the following case:
3752 // 1. You're on a site with frames.
3753 // 2. You do a subframe navigation. This is stored with transition type
3755 // 3. You navigate to some non-frame site, say, google.com.
3756 // 4. You navigate back to the page from step 2. Since it was initially
3757 // MANUAL_SUBFRAME, it will be that same transition type here.
3758 // We don't want that, because any navigation that changes the toplevel
3759 // frame should be tracked as a toplevel navigation (this allows us to
3760 // update the URL bar, etc).
3761 params
.transition
= ui::PAGE_TRANSITION_LINK
;
3764 // If the page contained a client redirect (meta refresh, document.loc...),
3765 // set the referrer and transition appropriately.
3766 if (ds
->isClientRedirect()) {
3768 Referrer(params
.redirects
[0], ds
->request().referrerPolicy());
3769 params
.transition
= ui::PageTransitionFromInt(
3770 params
.transition
| ui::PAGE_TRANSITION_CLIENT_REDIRECT
);
3772 params
.referrer
= RenderViewImpl::GetReferrerFromRequest(
3773 frame
, ds
->request());
3776 base::string16 method
= request
.httpMethod();
3777 if (EqualsASCII(method
, "POST")) {
3778 params
.is_post
= true;
3779 params
.post_id
= ExtractPostId(entry
);
3782 // Send the user agent override back.
3783 params
.is_overriding_user_agent
= internal_data
->is_overriding_user_agent();
3785 // Track the URL of the original request. We use the first entry of the
3786 // redirect chain if it exists because the chain may have started in another
3788 params
.original_request_url
= GetOriginalRequestURL(ds
);
3790 params
.history_list_was_cleared
=
3791 navigation_state
->history_list_was_cleared();
3793 params
.report_type
= static_cast<FrameMsg_UILoadMetricsReportType::Value
>(
3794 frame
->dataSource()->request().inputPerfMetricReportPolicy());
3795 params
.ui_timestamp
= base::TimeTicks() + base::TimeDelta::FromSecondsD(
3796 frame
->dataSource()->request().uiStartTime());
3798 // Save some histogram data so we can compute the average memory used per
3799 // page load of the glyphs.
3800 UMA_HISTOGRAM_COUNTS_10000("Memory.GlyphPagesPerLoad",
3801 blink::WebGlyphCache::pageCount());
3803 // This message needs to be sent before any of allowScripts(),
3804 // allowImages(), allowPlugins() is called for the new page, so that when
3805 // these functions send a ViewHostMsg_ContentBlocked message, it arrives
3806 // after the FrameHostMsg_DidCommitProvisionalLoad message.
3807 Send(new FrameHostMsg_DidCommitProvisionalLoad(routing_id_
, params
));
3809 // Subframe navigation: the type depends on whether this navigation
3810 // generated a new session history entry. When they do generate a session
3811 // history entry, it means the user initiated the navigation and we should
3813 if (commit_type
== blink::WebStandardCommit
)
3814 params
.transition
= ui::PAGE_TRANSITION_MANUAL_SUBFRAME
;
3816 params
.transition
= ui::PAGE_TRANSITION_AUTO_SUBFRAME
;
3818 DCHECK(!navigation_state
->history_list_was_cleared());
3819 params
.history_list_was_cleared
= false;
3820 params
.report_type
= FrameMsg_UILoadMetricsReportType::NO_REPORT
;
3822 // Don't send this message while the subframe is swapped out.
3823 if (!is_swapped_out())
3824 Send(new FrameHostMsg_DidCommitProvisionalLoad(routing_id_
, params
));
3827 // If we end up reusing this WebRequest (for example, due to a #ref click),
3828 // we don't want the transition type to persist. Just clear it.
3829 navigation_state
->set_transition_type(ui::PAGE_TRANSITION_LINK
);
3832 void RenderFrameImpl::didStartLoading(bool to_different_document
) {
3833 TRACE_EVENT1("navigation", "RenderFrameImpl::didStartLoading",
3835 render_view_
->FrameDidStartLoading(frame_
);
3836 Send(new FrameHostMsg_DidStartLoading(routing_id_
, to_different_document
));
3839 void RenderFrameImpl::didStopLoading() {
3840 TRACE_EVENT1("navigation", "RenderFrameImpl::didStopLoading",
3842 render_view_
->FrameDidStopLoading(frame_
);
3843 Send(new FrameHostMsg_DidStopLoading(routing_id_
));
3846 void RenderFrameImpl::didChangeLoadProgress(double load_progress
) {
3847 Send(new FrameHostMsg_DidChangeLoadProgress(routing_id_
, load_progress
));
3850 void RenderFrameImpl::HandleWebAccessibilityEvent(
3851 const blink::WebAXObject
& obj
, blink::WebAXEvent event
) {
3852 if (renderer_accessibility_
)
3853 renderer_accessibility_
->HandleWebAccessibilityEvent(obj
, event
);
3856 void RenderFrameImpl::FocusedNodeChanged(const WebNode
& node
) {
3857 FOR_EACH_OBSERVER(RenderFrameObserver
, observers_
, FocusedNodeChanged(node
));
3860 void RenderFrameImpl::FocusedNodeChangedForAccessibility(const WebNode
& node
) {
3861 if (renderer_accessibility())
3862 renderer_accessibility()->AccessibilityFocusedNodeChanged(node
);
3866 void RenderFrameImpl::OnCommitNavigation(
3867 const ResourceResponseHead
& response
,
3868 const GURL
& stream_url
,
3869 const CommonNavigationParams
& common_params
,
3870 const CommitNavigationParams
& commit_params
) {
3871 CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
3872 switches::kEnableBrowserSideNavigation
));
3873 bool is_reload
= false;
3874 bool is_history_navigation
= commit_params
.page_state
.IsValid();
3875 WebURLRequest::CachePolicy cache_policy
=
3876 WebURLRequest::UseProtocolCachePolicy
;
3877 if (!RenderFrameImpl::PrepareRenderViewForNavigation(
3878 common_params
.url
, false /* check_for_stale_navigation */,
3879 is_history_navigation
, -1 /* current_history_list_offset; TODO(clamy)*/,
3880 &is_reload
, &cache_policy
)) {
3884 GetContentClient()->SetActiveURL(common_params
.url
);
3886 // Create a WebURLRequest that blink can use to get access to the body of the
3887 // response through a stream in the browser. Blink will then commit the
3889 // TODO(clamy): Have the navigation commit directly, without going through
3890 // loading a WebURLRequest.
3891 scoped_ptr
<StreamOverrideParameters
> stream_override(
3892 new StreamOverrideParameters());
3893 stream_override
->stream_url
= stream_url
;
3894 stream_override
->response
= response
;
3895 WebURLRequest request
=
3896 CreateURLRequestForNavigation(common_params
,
3897 stream_override
.Pass(),
3898 frame_
->isViewSourceModeEnabled());
3900 // Make sure that blink loader will not try to use browser side navigation for
3901 // this request (since it already went to the browser).
3902 request
.setCheckForBrowserSideNavigation(false);
3904 // Record this before starting the load. A lower bound of this time is needed
3905 // to sanitize the navigationStart override set below.
3906 base::TimeTicks renderer_navigation_start
= base::TimeTicks::Now();
3907 frame_
->loadRequest(request
);
3908 UpdateFrameNavigationTiming(
3909 frame_
, commit_params
.browser_navigation_start
,
3910 renderer_navigation_start
);
3913 WebNavigationPolicy
RenderFrameImpl::DecidePolicyForNavigation(
3914 RenderFrame
* render_frame
,
3915 const NavigationPolicyInfo
& info
) {
3917 // The handlenavigation API is deprecated and will be removed once
3918 // crbug.com/325351 is resolved.
3919 if (info
.urlRequest
.url() != GURL(kSwappedOutURL
) &&
3920 GetContentClient()->renderer()->HandleNavigation(
3922 static_cast<DocumentState
*>(info
.extraData
),
3923 render_view_
->opener_id_
,
3926 info
.navigationType
,
3929 return blink::WebNavigationPolicyIgnore
;
3933 Referrer
referrer(RenderViewImpl::GetReferrerFromRequest(info
.frame
,
3935 const base::CommandLine
& command_line
=
3936 *base::CommandLine::ForCurrentProcess();
3938 bool is_subframe
= !!info
.frame
->parent();
3940 if (command_line
.HasSwitch(switches::kSitePerProcess
) && is_subframe
) {
3941 // There's no reason to ignore navigations on subframes, since the swap out
3942 // logic no longer applies.
3944 if (is_swapped_out_
) {
3945 if (info
.urlRequest
.url() != GURL(kSwappedOutURL
)) {
3946 // Targeted links may try to navigate a swapped out frame. Allow the
3947 // browser process to navigate the tab instead. Note that it is also
3948 // possible for non-targeted navigations (from this view) to arrive
3949 // here just after we are swapped out. It's ok to send them to the
3950 // browser, as long as they're for the top level frame.
3951 // TODO(creis): Ensure this supports targeted form submissions when
3952 // fixing http://crbug.com/101395.
3953 if (info
.frame
->parent() == NULL
) {
3954 OpenURL(info
.frame
, info
.urlRequest
.url(), referrer
,
3955 info
.defaultPolicy
);
3956 return blink::WebNavigationPolicyIgnore
; // Suppress the load here.
3959 // We should otherwise ignore in-process iframe navigations, if they
3960 // arrive just after we are swapped out.
3961 return blink::WebNavigationPolicyIgnore
;
3964 // Allow kSwappedOutURL to complete.
3965 return info
.defaultPolicy
;
3969 // Webkit is asking whether to navigate to a new URL.
3970 // This is fine normally, except if we're showing UI from one security
3971 // context and they're trying to navigate to a different context.
3972 const GURL
& url
= info
.urlRequest
.url();
3974 // A content initiated navigation may have originated from a link-click,
3975 // script, drag-n-drop operation, etc.
3976 bool is_content_initiated
= static_cast<DocumentState
*>(info
.extraData
)->
3977 navigation_state()->is_content_initiated();
3980 // If --enable-strict-site-isolation is enabled, send all top-level
3981 // navigations to the browser to let it swap processes when crossing site
3982 // boundaries. This is currently expected to break some script calls and
3983 // navigations, such as form submissions.
3984 bool force_swap_due_to_flag
=
3985 command_line
.HasSwitch(switches::kEnableStrictSiteIsolation
);
3986 if (force_swap_due_to_flag
&&
3987 !info
.frame
->parent() && (is_content_initiated
|| info
.isRedirect
)) {
3988 WebString origin_str
= info
.frame
->document().securityOrigin().toString();
3989 GURL
frame_url(origin_str
.utf8().data());
3990 // TODO(cevans): revisit whether this site check is still necessary once
3991 // crbug.com/101395 is fixed.
3992 bool same_domain_or_host
=
3993 net::registry_controlled_domains::SameDomainOrHost(
3996 net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES
);
3997 // Only keep same-site (domain + scheme) and data URLs in the same process.
3999 (same_domain_or_host
&& frame_url
.scheme() == url
.scheme()) ||
4000 url
.SchemeIs(url::kDataScheme
);
4001 if (!is_same_site
) {
4002 OpenURL(info
.frame
, url
, referrer
, info
.defaultPolicy
);
4003 return blink::WebNavigationPolicyIgnore
;
4007 // If the browser is interested, then give it a chance to look at the request.
4008 if (is_content_initiated
) {
4010 ((info
.navigationType
== blink::WebNavigationTypeFormSubmitted
) ||
4011 (info
.navigationType
== blink::WebNavigationTypeFormResubmitted
)) &&
4012 EqualsASCII(info
.urlRequest
.httpMethod(), "POST");
4013 bool browser_handles_request
=
4014 render_view_
->renderer_preferences_
4015 .browser_handles_non_local_top_level_requests
4016 && IsNonLocalTopLevelNavigation(url
, info
.frame
, info
.navigationType
,
4018 if (!browser_handles_request
) {
4019 browser_handles_request
= IsTopLevelNavigation(info
.frame
) &&
4020 render_view_
->renderer_preferences_
4021 .browser_handles_all_top_level_requests
;
4024 if (browser_handles_request
) {
4025 OpenURL(info
.frame
, url
, referrer
, info
.defaultPolicy
);
4026 return blink::WebNavigationPolicyIgnore
; // Suppress the load here.
4030 // Use the frame's original request's URL rather than the document's URL for
4031 // subsequent checks. For a popup, the document's URL may become the opener
4032 // window's URL if the opener has called document.write().
4033 // See http://crbug.com/93517.
4034 GURL
old_url(info
.frame
->dataSource()->request().url());
4036 // Detect when we're crossing a permission-based boundary (e.g. into or out of
4037 // an extension or app origin, leaving a WebUI page, etc). We only care about
4038 // top-level navigations (not iframes). But we sometimes navigate to
4039 // about:blank to clear a tab, and we want to still allow that.
4041 // Note: this is known to break POST submissions when crossing process
4042 // boundaries until http://crbug.com/101395 is fixed. This is better for
4043 // security than loading a WebUI, extension or app page in the wrong process.
4044 // POST requests don't work because this mechanism does not preserve form
4045 // POST data. We will need to send the request's httpBody data up to the
4046 // browser process, and issue a special POST navigation in WebKit (via
4047 // FrameLoader::loadFrameRequest). See ResourceDispatcher and WebURLLoaderImpl
4048 // for examples of how to send the httpBody data.
4049 if (!info
.frame
->parent() && is_content_initiated
&&
4050 !url
.SchemeIs(url::kAboutScheme
)) {
4051 bool send_referrer
= false;
4053 // All navigations to or from WebUI URLs or within WebUI-enabled
4054 // RenderProcesses must be handled by the browser process so that the
4055 // correct bindings and data sources can be registered.
4056 // Similarly, navigations to view-source URLs or within ViewSource mode
4057 // must be handled by the browser process (except for reloads - those are
4058 // safe to leave within the renderer).
4059 // Lastly, access to file:// URLs from non-file:// URL pages must be
4060 // handled by the browser so that ordinary renderer processes don't get
4061 // blessed with file permissions.
4062 int cumulative_bindings
= RenderProcess::current()->GetEnabledBindings();
4063 bool is_initial_navigation
= render_view_
->page_id_
== -1;
4064 bool should_fork
= HasWebUIScheme(url
) || HasWebUIScheme(old_url
) ||
4065 (cumulative_bindings
& BINDINGS_POLICY_WEB_UI
) ||
4066 url
.SchemeIs(kViewSourceScheme
) ||
4067 (info
.frame
->isViewSourceModeEnabled() &&
4068 info
.navigationType
!= blink::WebNavigationTypeReload
);
4070 if (!should_fork
&& url
.SchemeIs(url::kFileScheme
)) {
4071 // Fork non-file to file opens. Check the opener URL if this is the
4072 // initial navigation in a newly opened window.
4073 GURL
source_url(old_url
);
4074 if (is_initial_navigation
&& source_url
.is_empty() &&
4075 info
.frame
->opener())
4076 source_url
= info
.frame
->opener()->top()->document().url();
4077 DCHECK(!source_url
.is_empty());
4078 should_fork
= !source_url
.SchemeIs(url::kFileScheme
);
4082 // Give the embedder a chance.
4083 should_fork
= GetContentClient()->renderer()->ShouldFork(
4084 info
.frame
, url
, info
.urlRequest
.httpMethod().utf8(),
4085 is_initial_navigation
, info
.isRedirect
, &send_referrer
);
4089 OpenURL(info
.frame
, url
, send_referrer
? referrer
: Referrer(),
4090 info
.defaultPolicy
);
4091 return blink::WebNavigationPolicyIgnore
; // Suppress the load here.
4095 // Detect when a page is "forking" a new tab that can be safely rendered in
4096 // its own process. This is done by sites like Gmail that try to open links
4097 // in new windows without script connections back to the original page. We
4098 // treat such cases as browser navigations (in which we will create a new
4099 // renderer for a cross-site navigation), rather than WebKit navigations.
4101 // We use the following heuristic to decide whether to fork a new page in its
4103 // The parent page must open a new tab to about:blank, set the new tab's
4104 // window.opener to null, and then redirect the tab to a cross-site URL using
4107 // TODO(creis): Deprecate this logic once we can rely on rel=noreferrer
4110 // Must start from a tab showing about:blank, which is later redirected.
4111 old_url
== GURL(url::kAboutBlankURL
) &&
4112 // Must be the first real navigation of the tab.
4113 render_view_
->historyBackListCount() < 1 &&
4114 render_view_
->historyForwardListCount() < 1 &&
4115 // The parent page must have set the child's window.opener to null before
4116 // redirecting to the desired URL.
4117 info
.frame
->opener() == NULL
&&
4118 // Must be a top-level frame.
4119 info
.frame
->parent() == NULL
&&
4120 // Must not have issued the request from this page.
4121 is_content_initiated
&&
4122 // Must be targeted at the current tab.
4123 info
.defaultPolicy
== blink::WebNavigationPolicyCurrentTab
&&
4124 // Must be a JavaScript navigation, which appears as "other".
4125 info
.navigationType
== blink::WebNavigationTypeOther
;
4128 // Open the URL via the browser, not via WebKit.
4129 OpenURL(info
.frame
, url
, Referrer(), info
.defaultPolicy
);
4130 return blink::WebNavigationPolicyIgnore
;
4133 // PlzNavigate: send the request to the browser if needed.
4134 if (base::CommandLine::ForCurrentProcess()->HasSwitch(
4135 switches::kEnableBrowserSideNavigation
) &&
4136 info
.urlRequest
.checkForBrowserSideNavigation()) {
4137 BeginNavigation(&info
.urlRequest
);
4138 return blink::WebNavigationPolicyIgnore
;
4141 return info
.defaultPolicy
;
4144 void RenderFrameImpl::OpenURL(WebFrame
* frame
,
4146 const Referrer
& referrer
,
4147 WebNavigationPolicy policy
) {
4148 DCHECK_EQ(frame_
, frame
);
4150 FrameHostMsg_OpenURL_Params params
;
4152 params
.referrer
= referrer
;
4153 params
.disposition
= RenderViewImpl::NavigationPolicyToDisposition(policy
);
4154 WebDataSource
* ds
= frame
->provisionalDataSource();
4156 DocumentState
* document_state
= DocumentState::FromDataSource(ds
);
4157 NavigationState
* navigation_state
= document_state
->navigation_state();
4158 if (navigation_state
->is_content_initiated()) {
4159 params
.should_replace_current_entry
=
4160 ds
->replacesCurrentHistoryItem() &&
4161 render_view_
->history_list_length_
;
4163 // This is necessary to preserve the should_replace_current_entry value on
4164 // cross-process redirects, in the event it was set by a previous process.
4166 // TODO(davidben): Avoid this awkward duplication of state. See comment on
4167 // NavigationState::should_replace_current_entry().
4168 params
.should_replace_current_entry
=
4169 navigation_state
->should_replace_current_entry();
4172 params
.should_replace_current_entry
= false;
4174 params
.user_gesture
= WebUserGestureIndicator::isProcessingUserGesture();
4175 if (GetContentClient()->renderer()->AllowPopup())
4176 params
.user_gesture
= true;
4178 if (policy
== blink::WebNavigationPolicyNewBackgroundTab
||
4179 policy
== blink::WebNavigationPolicyNewForegroundTab
||
4180 policy
== blink::WebNavigationPolicyNewWindow
||
4181 policy
== blink::WebNavigationPolicyNewPopup
) {
4182 WebUserGestureIndicator::consumeUserGesture();
4185 Send(new FrameHostMsg_OpenURL(routing_id_
, params
));
4188 void RenderFrameImpl::UpdateEncoding(WebFrame
* frame
,
4189 const std::string
& encoding_name
) {
4190 // Only update main frame's encoding_name.
4191 if (!frame
->parent())
4192 Send(new FrameHostMsg_UpdateEncoding(routing_id_
, encoding_name
));
4195 void RenderFrameImpl::SyncSelectionIfRequired() {
4196 base::string16 text
;
4199 #if defined(ENABLE_PLUGINS)
4200 if (render_view_
->focused_pepper_plugin_
) {
4201 render_view_
->focused_pepper_plugin_
->GetSurroundingText(&text
, &range
);
4202 offset
= 0; // Pepper API does not support offset reporting.
4203 // TODO(kinaba): cut as needed.
4207 size_t location
, length
;
4208 if (!GetRenderWidget()->webwidget()->caretOrSelectionRange(
4209 &location
, &length
)) {
4213 range
= gfx::Range(location
, location
+ length
);
4215 if (GetRenderWidget()->webwidget()->textInputInfo().type
!=
4216 blink::WebTextInputTypeNone
) {
4217 // If current focused element is editable, we will send 100 more chars
4218 // before and after selection. It is for input method surrounding text
4220 if (location
> kExtraCharsBeforeAndAfterSelection
)
4221 offset
= location
- kExtraCharsBeforeAndAfterSelection
;
4224 length
= location
+ length
- offset
+ kExtraCharsBeforeAndAfterSelection
;
4225 WebRange webrange
= WebRange::fromDocumentRange(frame_
, offset
, length
);
4226 if (!webrange
.isNull())
4227 text
= webrange
.toPlainText();
4230 text
= frame_
->selectionAsText();
4231 // http://crbug.com/101435
4232 // In some case, frame->selectionAsText() returned text's length is not
4233 // equal to the length returned from webwidget()->caretOrSelectionRange().
4234 // So we have to set the range according to text.length().
4235 range
.set_end(range
.start() + text
.length());
4239 // Sometimes we get repeated didChangeSelection calls from webkit when
4240 // the selection hasn't actually changed. We don't want to report these
4241 // because it will cause us to continually claim the X clipboard.
4242 if (selection_text_offset_
!= offset
||
4243 selection_range_
!= range
||
4244 selection_text_
!= text
) {
4245 selection_text_
= text
;
4246 selection_text_offset_
= offset
;
4247 selection_range_
= range
;
4248 SetSelectedText(text
, offset
, range
);
4250 GetRenderWidget()->UpdateSelectionBounds();
4253 void RenderFrameImpl::InitializeUserMediaClient() {
4254 if (!RenderThreadImpl::current()) // Will be NULL during unit tests.
4257 #if defined(OS_ANDROID)
4258 if (base::CommandLine::ForCurrentProcess()->HasSwitch(
4259 switches::kDisableWebRTC
))
4263 #if defined(ENABLE_WEBRTC)
4264 DCHECK(!web_user_media_client_
);
4265 web_user_media_client_
= new UserMediaClientImpl(
4267 RenderThreadImpl::current()->GetPeerConnectionDependencyFactory(),
4268 make_scoped_ptr(new MediaStreamDispatcher(this)).Pass());
4272 WebMediaPlayer
* RenderFrameImpl::CreateWebMediaPlayerForMediaStream(
4273 const blink::WebURL
& url
,
4274 WebMediaPlayerClient
* client
) {
4275 #if defined(ENABLE_WEBRTC)
4276 #if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
4278 (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON
) != 0;
4279 UMA_HISTOGRAM_BOOLEAN("Platform.WebRtcNEONFound", found_neon
);
4280 #endif // defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
4281 return new WebMediaPlayerMS(frame_
, client
, weak_factory_
.GetWeakPtr(),
4282 new RenderMediaLog(),
4283 CreateRendererFactory());
4286 #endif // defined(ENABLE_WEBRTC)
4289 scoped_ptr
<MediaStreamRendererFactory
>
4290 RenderFrameImpl::CreateRendererFactory() {
4291 #if defined(ENABLE_WEBRTC)
4292 return scoped_ptr
<MediaStreamRendererFactory
>(
4293 new MediaStreamRendererFactory());
4295 return scoped_ptr
<MediaStreamRendererFactory
>(
4296 static_cast<MediaStreamRendererFactory
*>(NULL
));
4300 bool RenderFrameImpl::PrepareRenderViewForNavigation(
4302 bool check_for_stale_navigation
,
4303 bool is_history_navigation
,
4304 int current_history_list_offset
,
4306 WebURLRequest::CachePolicy
* cache_policy
) {
4307 MaybeHandleDebugURL(url
);
4308 if (!render_view_
->webview())
4312 RenderViewObserver
, render_view_
->observers_
, Navigate(url
));
4314 // If this is a stale back/forward (due to a recent navigation the browser
4315 // didn't know about), ignore it. Only check if swapped in because if the
4316 // frame is swapped out, it won't commit before asking the browser.
4317 // TODO(clamy): remove check_for_stale_navigation
4318 if (check_for_stale_navigation
&&
4319 !render_view_
->is_swapped_out() && is_history_navigation
&&
4320 render_view_
->history_list_offset_
!= current_history_list_offset
) {
4324 if (!is_swapped_out_
|| frame_
->parent())
4327 // This is a swapped out main frame, so swap the renderer back in.
4328 // We marked the view as hidden when swapping the view out, so be sure to
4329 // reset the visibility state before navigating to the new URL.
4330 render_view_
->webview()->setVisibilityState(
4331 render_view_
->visibilityState(), false);
4333 // If this is an attempt to reload while we are swapped out, we should not
4334 // reload swappedout://, but the previous page, which is stored in
4335 // params.state. Setting is_reload to false will treat this like a back
4336 // navigation to accomplish that.
4338 *cache_policy
= WebURLRequest::ReloadIgnoringCacheData
;
4340 // We refresh timezone when a view is swapped in since timezone
4341 // can get out of sync when the system timezone is updated while
4342 // the view is swapped out.
4343 RenderThreadImpl::NotifyTimezoneChange();
4345 render_view_
->SetSwappedOut(false);
4346 is_swapped_out_
= false;
4350 void RenderFrameImpl::BeginNavigation(blink::WebURLRequest
* request
) {
4351 CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
4352 switches::kEnableBrowserSideNavigation
));
4354 // TODO(clamy): Execute the beforeunload event.
4356 // Note: At this stage, the goal is to apply all the modifications the
4357 // renderer wants to make to the request, and then send it to the browser, so
4358 // that the actual network request can be started. Ideally, all such
4359 // modifications should take place in willSendRequest, and in the
4360 // implementation of willSendRequest for the various InspectorAgents
4363 // TODO(clamy): Apply devtools override.
4364 // TODO(clamy): Make sure that navigation requests are not modified somewhere
4366 willSendRequest(frame_
, 0, *request
, blink::WebURLResponse());
4368 // TODO(clamy): Same-document navigations should not be sent back to the
4370 // TODO(clamy): Data urls should not be sent back to the browser either.
4371 Send(new FrameHostMsg_DidStartLoading(routing_id_
, true));
4372 Send(new FrameHostMsg_BeginNavigation(
4373 routing_id_
, MakeCommonNavigationParams(request
),
4374 BeginNavigationParams(request
->httpMethod().latin1(),
4375 GetWebURLRequestHeaders(*request
),
4376 GetLoadFlagsForWebURLRequest(*request
),
4377 request
->hasUserGesture()),
4378 GetRequestBodyForWebURLRequest(*request
)));
4381 GURL
RenderFrameImpl::GetLoadingUrl() const {
4382 WebDataSource
* ds
= frame_
->dataSource();
4383 if (ds
->hasUnreachableURL())
4384 return ds
->unreachableURL();
4386 const WebURLRequest
& request
= ds
->request();
4387 return request
.url();
4390 #if defined(OS_ANDROID)
4392 WebMediaPlayer
* RenderFrameImpl::CreateAndroidWebMediaPlayer(
4393 const blink::WebURL
& url
,
4394 WebMediaPlayerClient
* client
,
4395 media::MediaPermission
* media_permission
,
4396 blink::WebContentDecryptionModule
* initial_cdm
) {
4397 GpuChannelHost
* gpu_channel_host
=
4398 RenderThreadImpl::current()->EstablishGpuChannelSync(
4399 CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE
);
4400 if (!gpu_channel_host
) {
4401 LOG(ERROR
) << "Failed to establish GPU channel for media player";
4405 scoped_refptr
<StreamTextureFactory
> stream_texture_factory
;
4406 if (SynchronousCompositorFactory
* factory
=
4407 SynchronousCompositorFactory::GetInstance()) {
4408 stream_texture_factory
= factory
->CreateStreamTextureFactory(routing_id_
);
4410 scoped_refptr
<cc_blink::ContextProviderWebContext
> context_provider
=
4411 RenderThreadImpl::current()->SharedMainThreadContextProvider();
4413 if (!context_provider
.get()) {
4414 LOG(ERROR
) << "Failed to get context3d for media player";
4418 stream_texture_factory
= StreamTextureFactoryImpl::Create(
4419 context_provider
, gpu_channel_host
, routing_id_
);
4422 return new WebMediaPlayerAndroid(
4425 weak_factory_
.GetWeakPtr(),
4426 GetMediaPlayerManager(),
4430 stream_texture_factory
,
4431 RenderThreadImpl::current()->GetMediaThreadTaskRunner(),
4432 new RenderMediaLog());
4435 RendererMediaPlayerManager
* RenderFrameImpl::GetMediaPlayerManager() {
4436 if (!media_player_manager_
)
4437 media_player_manager_
= new RendererMediaPlayerManager(this);
4438 return media_player_manager_
;
4441 #endif // defined(OS_ANDROID)
4443 #if defined(ENABLE_BROWSER_CDMS)
4444 RendererCdmManager
* RenderFrameImpl::GetCdmManager() {
4446 cdm_manager_
= new RendererCdmManager(this);
4447 return cdm_manager_
;
4449 #endif // defined(ENABLE_BROWSER_CDMS)
4451 } // namespace content