#include "base/lazy_instance.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop_proxy.h"
+#include "base/metrics/field_trial.h"
#include "base/metrics/histogram.h"
#include "base/path_service.h"
#include "base/process/kill.h"
#include "cc/base/switches.h"
#include "content/child/appcache/appcache_dispatcher.h"
#include "content/child/appcache/web_application_cache_host_impl.h"
+#include "content/child/child_shared_bitmap_manager.h"
#include "content/child/child_thread.h"
#include "content/child/npapi/webplugin_delegate_impl.h"
#include "content/child/request_extra_data.h"
#include "content/child/webmessageportchannel_impl.h"
+#include "content/common/content_constants_internal.h"
#include "content/common/database_messages.h"
#include "content/common/dom_storage/dom_storage_types.h"
#include "content/common/drag_messages.h"
#include "content/public/common/three_d_api_types.h"
#include "content/public/common/url_constants.h"
#include "content/public/common/url_utils.h"
+#include "content/public/common/web_preferences.h"
#include "content/public/renderer/content_renderer_client.h"
#include "content/public/renderer/document_state.h"
-#include "content/public/renderer/history_item_serialization.h"
#include "content/public/renderer/navigation_state.h"
#include "content/public/renderer/render_view_observer.h"
#include "content/public/renderer/render_view_visitor.h"
-#include "content/public/renderer/web_preferences.h"
#include "content/renderer/accessibility/renderer_accessibility.h"
#include "content/renderer/accessibility/renderer_accessibility_complete.h"
#include "content/renderer/accessibility/renderer_accessibility_focus_only.h"
#include "content/renderer/disambiguation_popup_helper.h"
#include "content/renderer/dom_storage/webstoragenamespace_impl.h"
#include "content/renderer/drop_data_builder.h"
-#include "content/renderer/external_popup_menu.h"
-#include "content/renderer/geolocation_dispatcher.h"
#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/history_controller.h"
+#include "content/renderer/history_serialization.h"
#include "content/renderer/idle_user_detector.h"
-#include "content/renderer/image_loading_helper.h"
#include "content/renderer/ime_event_guard.h"
#include "content/renderer/input/input_handler_manager.h"
-#include "content/renderer/input_tag_speech_dispatcher.h"
#include "content/renderer/internal_document_state_data.h"
-#include "content/renderer/load_progress_tracker.h"
#include "content/renderer/media/audio_device_factory.h"
-#include "content/renderer/media/audio_renderer_mixer_manager.h"
-#include "content/renderer/media/media_stream_dependency_factory.h"
-#include "content/renderer/media/media_stream_dispatcher.h"
-#include "content/renderer/media/media_stream_impl.h"
-#include "content/renderer/media/midi_dispatcher.h"
-#include "content/renderer/media/render_media_log.h"
#include "content/renderer/media/video_capture_impl_manager.h"
-#include "content/renderer/media/webmediaplayer_impl.h"
-#include "content/renderer/media/webmediaplayer_ms.h"
-#include "content/renderer/media/webmediaplayer_params.h"
#include "content/renderer/memory_benchmarking_extension.h"
#include "content/renderer/mhtml_generator.h"
-#include "content/renderer/notification_provider.h"
+#include "content/renderer/net_info_helper.h"
#include "content/renderer/render_frame_impl.h"
+#include "content/renderer/render_frame_proxy.h"
#include "content/renderer/render_process.h"
#include "content/renderer/render_thread_impl.h"
#include "content/renderer/render_view_impl_params.h"
#include "content/renderer/render_view_mouse_lock_dispatcher.h"
#include "content/renderer/render_widget_fullscreen_pepper.h"
#include "content/renderer/renderer_webapplicationcachehost_impl.h"
-#include "content/renderer/renderer_webcolorchooser_impl.h"
#include "content/renderer/resizing_mode_selector.h"
#include "content/renderer/savable_resources.h"
#include "content/renderer/skia_benchmarking_extension.h"
#include "content/renderer/v8_value_converter_impl.h"
#include "content/renderer/web_ui_extension.h"
#include "content/renderer/web_ui_extension_data.h"
+#include "content/renderer/web_ui_mojo.h"
#include "content/renderer/websharedworker_proxy.h"
#include "media/audio/audio_output_device.h"
-#include "media/base/audio_renderer_mixer_input.h"
-#include "media/base/filter_collection.h"
#include "media/base/media_switches.h"
#include "media/filters/audio_renderer_impl.h"
#include "media/filters/gpu_video_accelerator_factories.h"
#include "net/base/net_errors.h"
#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
#include "net/http/http_util.h"
+#include "skia/ext/platform_canvas.h"
#include "third_party/WebKit/public/platform/WebCString.h"
+#include "third_party/WebKit/public/platform/WebConnectionType.h"
#include "third_party/WebKit/public/platform/WebDragData.h"
#include "third_party/WebKit/public/platform/WebHTTPBody.h"
#include "third_party/WebKit/public/platform/WebImage.h"
#include "third_party/WebKit/public/web/WebFrame.h"
#include "third_party/WebKit/public/web/WebGlyphCache.h"
#include "third_party/WebKit/public/web/WebHistoryItem.h"
+#include "third_party/WebKit/public/web/WebHitTestResult.h"
#include "third_party/WebKit/public/web/WebInputElement.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "third_party/WebKit/public/web/WebKit.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
#include "third_party/WebKit/public/web/WebMediaPlayerAction.h"
#include "third_party/WebKit/public/web/WebNavigationPolicy.h"
+#include "third_party/WebKit/public/web/WebNetworkStateNotifier.h"
#include "third_party/WebKit/public/web/WebNodeList.h"
#include "third_party/WebKit/public/web/WebPageSerializer.h"
#include "third_party/WebKit/public/web/WebPlugin.h"
#include "third_party/WebKit/public/web/WebPluginContainer.h"
#include "third_party/WebKit/public/web/WebPluginDocument.h"
#include "third_party/WebKit/public/web/WebRange.h"
+#include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
#include "third_party/WebKit/public/web/WebScriptSource.h"
#include "third_party/WebKit/public/web/WebSearchableFormData.h"
#include "third_party/WebKit/public/web/WebSecurityOrigin.h"
#include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
#include "third_party/WebKit/public/web/WebSettings.h"
#include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
-#include "third_party/WebKit/public/web/WebUserMediaClient.h"
#include "third_party/WebKit/public/web/WebView.h"
#include "third_party/WebKit/public/web/WebWindowFeatures.h"
#include "third_party/WebKit/public/web/default/WebRenderTheme.h"
+#include "third_party/icu/source/common/unicode/uchar.h"
+#include "third_party/icu/source/common/unicode/uscript.h"
#include "ui/base/clipboard/clipboard.h"
#include "ui/base/ui_base_switches_util.h"
#include "ui/events/latency_info.h"
#include "ui/gfx/size_conversions.h"
#include "ui/shell_dialogs/selected_file_info.h"
#include "v8/include/v8.h"
-#include "webkit/child/weburlresponse_extradata_impl.h"
#if defined(OS_ANDROID)
#include <cpu-features.h>
-#include "content/common/android/device_telephony_info.h"
-#include "content/common/gpu/client/context_provider_command_buffer.h"
#include "content/renderer/android/address_detector.h"
#include "content/renderer/android/content_detector.h"
#include "content/renderer/android/email_detector.h"
#include "content/renderer/android/phone_number_detector.h"
-#include "content/renderer/android/synchronous_compositor_factory.h"
-#include "content/renderer/media/android/renderer_media_player_manager.h"
-#include "content/renderer/media/android/stream_texture_factory_android_impl.h"
-#include "content/renderer/media/android/webmediaplayer_android.h"
-#include "skia/ext/platform_canvas.h"
+#include "net/android/network_library.h"
#include "third_party/WebKit/public/platform/WebFloatPoint.h"
#include "third_party/WebKit/public/platform/WebFloatRect.h"
-#include "third_party/WebKit/public/web/WebHitTestResult.h"
#include "ui/gfx/rect_f.h"
#elif defined(OS_WIN)
#if defined(ENABLE_WEBRTC)
#include "content/renderer/media/rtc_peer_connection_handler.h"
-#endif
-
-#if defined(USE_MOJO)
-#include "content/renderer/web_ui_mojo.h"
+#include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
#endif
using blink::WebAXObject;
using blink::WebDragOperation;
using blink::WebDragOperationsMask;
using blink::WebElement;
-using blink::WebExternalPopupMenu;
-using blink::WebExternalPopupMenuClient;
using blink::WebFileChooserCompletion;
using blink::WebFindOptions;
using blink::WebFormControlElement;
using blink::WebImage;
using blink::WebInputElement;
using blink::WebInputEvent;
-using blink::WebMediaPlayer;
+using blink::WebLocalFrame;
using blink::WebMediaPlayerAction;
-using blink::WebMediaPlayerClient;
using blink::WebMouseEvent;
using blink::WebNavigationPolicy;
using blink::WebNavigationType;
using blink::WebPluginContainer;
using blink::WebPluginDocument;
using blink::WebPoint;
-using blink::WebPopupMenuInfo;
using blink::WebRange;
using blink::WebRect;
using blink::WebReferrerPolicy;
using blink::WebView;
using blink::WebWidget;
using blink::WebWindowFeatures;
+using blink::WebNetworkStateNotifier;
+using blink::WebRuntimeFeatures;
using base::Time;
using base::TimeDelta;
-using webkit_glue::WebURLResponseExtraDataImpl;
#if defined(OS_ANDROID)
using blink::WebContentDetectionResult;
}
-static bool ShouldUseFixedPositionCompositing(float device_scale_factor) {
- // Compositing for fixed-position elements is dependent on
- // device_scale_factor if no flag is set. http://crbug.com/172738
+static bool PreferCompositingToLCDText(float device_scale_factor) {
const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-
- if (command_line.HasSwitch(switches::kDisableCompositingForFixedPosition))
+ if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
return false;
-
- if (command_line.HasSwitch(switches::kEnableCompositingForFixedPosition))
+ if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
return true;
-
- return DeviceScaleEnsuresTextQuality(device_scale_factor);
-}
-
-static bool ShouldUseAcceleratedCompositingForOverflowScroll(
- float device_scale_factor) {
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-
- if (command_line.HasSwitch(switches::kDisableAcceleratedOverflowScroll))
- return false;
-
- if (command_line.HasSwitch(switches::kEnableAcceleratedOverflowScroll))
- return true;
-
- return DeviceScaleEnsuresTextQuality(device_scale_factor);
-}
-
-static bool ShouldUseAcceleratedCompositingForScrollableFrames(
- float device_scale_factor) {
if (RenderThreadImpl::current() &&
!RenderThreadImpl::current()->is_lcd_text_enabled())
return true;
-
return DeviceScaleEnsuresTextQuality(device_scale_factor);
}
-static bool ShouldUseCompositedScrollingForFrames(
- float device_scale_factor) {
- if (RenderThreadImpl::current() &&
- !RenderThreadImpl::current()->is_lcd_text_enabled())
- return true;
-
- return DeviceScaleEnsuresTextQuality(device_scale_factor);
-}
-
-static bool ShouldUseUniversalAcceleratedCompositingForOverflowScroll() {
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-
- if (command_line.HasSwitch(
- switches::kDisableUniversalAcceleratedOverflowScroll))
- return false;
-
- if (command_line.HasSwitch(
- switches::kEnableUniversalAcceleratedOverflowScroll))
- return true;
-
- return false;
-}
-
static bool ShouldUseTransitionCompositing(float device_scale_factor) {
const CommandLine& command_line = *CommandLine::ForCurrentProcess();
return false;
}
-static bool ShouldUseAcceleratedFixedRootBackground(float device_scale_factor) {
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-
- if (command_line.HasSwitch(switches::kDisableAcceleratedFixedRootBackground))
- return false;
-
- if (command_line.HasSwitch(switches::kEnableAcceleratedFixedRootBackground))
- return true;
-
- return DeviceScaleEnsuresTextQuality(device_scale_factor);
-}
-
-static bool ShouldUseCompositingForGpuRasterizationHint() {
- return RenderThreadImpl::current() &&
- RenderThreadImpl::current()->is_gpu_rasterization_enabled();
-}
-
static FaviconURL::IconType ToFaviconType(blink::WebIconURL::Type type) {
switch (type) {
case blink::WebIconURL::TypeFavicon:
static void ConvertToFaviconSizes(
const blink::WebVector<blink::WebSize>& web_sizes,
std::vector<gfx::Size>* sizes) {
+ DCHECK(sizes->empty());
+ sizes->reserve(web_sizes.size());
for (size_t i = 0; i < web_sizes.size(); ++i)
sizes->push_back(gfx::Size(web_sizes[i]));
}
item_list.push_back(item);
}
+ for (std::vector<DropData::FileSystemFileInfo>::const_iterator it =
+ drop_data.file_system_files.begin();
+ it != drop_data.file_system_files.end();
+ ++it) {
+ WebDragData::Item item;
+ item.storageType = WebDragData::Item::StorageTypeFileSystemFile;
+ item.fileSystemURL = it->url;
+ item.fileSystemFileSize = it->size;
+ item_list.push_back(item);
+ }
+
for (std::map<base::string16, base::string16>::const_iterator it =
drop_data.custom_data.begin();
it != drop_data.custom_data.end();
return result;
}
+typedef void (*SetFontFamilyWrapper)(blink::WebSettings*,
+ const base::string16&,
+ UScriptCode);
+
+void SetStandardFontFamilyWrapper(WebSettings* settings,
+ const base::string16& font,
+ UScriptCode script) {
+ settings->setStandardFontFamily(font, script);
+}
+
+void SetFixedFontFamilyWrapper(WebSettings* settings,
+ const base::string16& font,
+ UScriptCode script) {
+ settings->setFixedFontFamily(font, script);
+}
+
+void SetSerifFontFamilyWrapper(WebSettings* settings,
+ const base::string16& font,
+ UScriptCode script) {
+ settings->setSerifFontFamily(font, script);
+}
+
+void SetSansSerifFontFamilyWrapper(WebSettings* settings,
+ const base::string16& font,
+ UScriptCode script) {
+ settings->setSansSerifFontFamily(font, script);
+}
+
+void SetCursiveFontFamilyWrapper(WebSettings* settings,
+ const base::string16& font,
+ UScriptCode script) {
+ settings->setCursiveFontFamily(font, script);
+}
+
+void SetFantasyFontFamilyWrapper(WebSettings* settings,
+ const base::string16& font,
+ UScriptCode script) {
+ settings->setFantasyFontFamily(font, script);
+}
+
+void SetPictographFontFamilyWrapper(WebSettings* settings,
+ const base::string16& font,
+ UScriptCode script) {
+ settings->setPictographFontFamily(font, script);
+}
+
+// If |scriptCode| is a member of a family of "similar" script codes, returns
+// the script code in that family that is used by WebKit for font selection
+// purposes. For example, USCRIPT_KATAKANA_OR_HIRAGANA and USCRIPT_JAPANESE are
+// considered equivalent for the purposes of font selection. WebKit uses the
+// script code USCRIPT_KATAKANA_OR_HIRAGANA. So, if |scriptCode| is
+// USCRIPT_JAPANESE, the function returns USCRIPT_KATAKANA_OR_HIRAGANA. WebKit
+// uses different scripts than the ones in Chrome pref names because the version
+// of ICU included on certain ports does not have some of the newer scripts. If
+// |scriptCode| is not a member of such a family, returns |scriptCode|.
+UScriptCode GetScriptForWebSettings(UScriptCode scriptCode) {
+ switch (scriptCode) {
+ case USCRIPT_HIRAGANA:
+ case USCRIPT_KATAKANA:
+ case USCRIPT_JAPANESE:
+ return USCRIPT_KATAKANA_OR_HIRAGANA;
+ case USCRIPT_KOREAN:
+ return USCRIPT_HANGUL;
+ default:
+ return scriptCode;
+ }
+}
+
+void ApplyFontsFromMap(const ScriptFontFamilyMap& map,
+ SetFontFamilyWrapper setter,
+ WebSettings* settings) {
+ for (ScriptFontFamilyMap::const_iterator it = map.begin(); it != map.end();
+ ++it) {
+ int32 script = u_getPropertyValueEnum(UCHAR_SCRIPT, (it->first).c_str());
+ if (script >= 0 && script < USCRIPT_CODE_LIMIT) {
+ UScriptCode code = static_cast<UScriptCode>(script);
+ (*setter)(settings, it->second, GetScriptForWebSettings(code));
+ }
+ }
+}
+
} // namespace
RenderViewImpl::RenderViewImpl(RenderViewImplParams* params)
: RenderWidget(blink::WebPopupTypeNone,
params->screen_info,
params->swapped_out,
- params->hidden),
+ params->hidden,
+ params->never_visible),
webkit_preferences_(params->webkit_prefs),
send_content_state_immediately_(false),
enabled_bindings_(0),
history_list_length_(0),
frames_in_progress_(0),
target_url_status_(TARGET_NONE),
+ uses_temporary_zoom_level_(false),
#if defined(OS_ANDROID)
top_controls_constraints_(cc::BOTH),
#endif
- cached_is_main_frame_pinned_to_left_(false),
- cached_is_main_frame_pinned_to_right_(false),
- cached_has_main_frame_horizontal_scrollbar_(false),
- cached_has_main_frame_vertical_scrollbar_(false),
has_scrolled_focused_editable_node_into_rect_(false),
- notification_provider_(NULL),
- geolocation_dispatcher_(NULL),
- input_tag_speech_dispatcher_(NULL),
speech_recognition_dispatcher_(NULL),
- media_stream_dispatcher_(NULL),
browser_plugin_manager_(NULL),
- media_stream_client_(NULL),
- web_user_media_client_(NULL),
- midi_dispatcher_(NULL),
devtools_agent_(NULL),
- accessibility_mode_(AccessibilityModeOff),
- renderer_accessibility_(NULL),
mouse_lock_dispatcher_(NULL),
#if defined(OS_ANDROID)
- body_background_color_(SK_ColorWHITE),
expected_content_intent_id_(0),
- media_player_manager_(NULL),
#endif
#if defined(OS_WIN)
focused_plugin_id_(-1),
pepper_last_mouse_event_target_(NULL),
#endif
enumeration_completion_id_(0),
- load_progress_tracker_(new LoadProgressTracker(this)),
session_storage_namespace_id_(params->session_storage_namespace_id),
next_snapshot_id_(0) {
}
// Ensure we start with a valid next_page_id_ from the browser.
DCHECK_GE(next_page_id_, 0);
-#if defined(ENABLE_NOTIFICATIONS)
- notification_provider_ = new NotificationProvider(this);
-#else
- notification_provider_ = NULL;
-#endif
+ main_render_frame_.reset(RenderFrameImpl::Create(
+ this, params->main_frame_routing_id));
+ // The main frame WebLocalFrame object is closed by
+ // RenderFrameImpl::frameDetached().
+ WebLocalFrame* web_frame = WebLocalFrame::create(main_render_frame_.get());
+ main_render_frame_->SetWebFrame(web_frame);
webwidget_ = WebView::create(this);
webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(webwidget_));
stats_collection_observer_.reset(new StatsCollectionObserver(this));
#if defined(OS_ANDROID)
- content::DeviceTelephonyInfo device_info;
-
const std::string region_code =
command_line.HasSwitch(switches::kNetworkCountryIso)
? command_line.GetSwitchValueASCII(switches::kNetworkCountryIso)
- : device_info.GetNetworkCountryIso();
+ : net::android::GetTelephonyNetworkOperator();
content_detectors_.push_back(linked_ptr<ContentDetector>(
new AddressDetector()));
content_detectors_.push_back(linked_ptr<ContentDetector>(
g_view_map.Get().insert(std::make_pair(webview(), this));
g_routing_id_view_map.Get().insert(std::make_pair(routing_id_, this));
webview()->setDeviceScaleFactor(device_scale_factor_);
- webview()->settings()->setAcceleratedCompositingForFixedPositionEnabled(
- ShouldUseFixedPositionCompositing(device_scale_factor_));
- webview()->settings()->setAcceleratedCompositingForOverflowScrollEnabled(
- ShouldUseAcceleratedCompositingForOverflowScroll(device_scale_factor_));
- webview()->settings()->setCompositorDrivenAcceleratedScrollingEnabled(
- ShouldUseUniversalAcceleratedCompositingForOverflowScroll());
+ webview()->settings()->setPreferCompositingToLCDTextEnabled(
+ PreferCompositingToLCDText(device_scale_factor_));
webview()->settings()->setAcceleratedCompositingForTransitionEnabled(
ShouldUseTransitionCompositing(device_scale_factor_));
- webview()->settings()->setAcceleratedCompositingForFixedRootBackgroundEnabled(
- ShouldUseAcceleratedFixedRootBackground(device_scale_factor_));
- webview()->settings()->setAcceleratedCompositingForScrollableFramesEnabled(
- ShouldUseAcceleratedCompositingForScrollableFrames(device_scale_factor_));
- webview()->settings()->setCompositedScrollingForFramesEnabled(
- ShouldUseCompositedScrollingForFrames(device_scale_factor_));
- webview()->settings()
- ->setAcceleratedCompositingForGpuRasterizationHintEnabled(
- ShouldUseCompositingForGpuRasterizationHint());
+ webview()->settings()->setThreadedScrollingEnabled(
+ !command_line.HasSwitch(switches::kDisableThreadedScrolling));
ApplyWebPreferences(webkit_preferences_, webview());
- main_render_frame_.reset(
- RenderFrameImpl::Create(this, params->main_frame_routing_id));
- // The main frame WebFrame object is closed by
- // RenderFrameImpl::frameDetached().
- webview()->setMainFrame(WebFrame::create(main_render_frame_.get()));
- main_render_frame_->SetWebFrame(webview()->mainFrame());
+ webview()->settings()->setAllowConnectingInsecureWebSocket(
+ command_line.HasSwitch(switches::kAllowInsecureWebSocketFromHttpsOrigin));
+
+ RenderFrameProxy* proxy = NULL;
+ if (params->proxy_routing_id != MSG_ROUTING_NONE) {
+ CHECK(params->swapped_out);
+ proxy = RenderFrameProxy::CreateProxyToReplaceFrame(
+ main_render_frame_.get(), params->proxy_routing_id);
+ main_render_frame_->set_render_frame_proxy(proxy);
+ }
+
+ // In --site-per-process, just use the WebRemoteFrame as the main frame.
+ if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess) &&
+ proxy) {
+ webview()->setMainFrame(proxy->web_frame());
+ } else {
+ webview()->setMainFrame(main_render_frame_->GetWebFrame());
+ }
+ main_render_frame_->Initialize();
if (switches::IsTouchDragDropEnabled())
webview()->settings()->setTouchDragDropEnabled(true);
if (!params->frame_name.empty())
webview()->mainFrame()->setName(params->frame_name);
- OnSetRendererPrefs(params->renderer_prefs);
+ // TODO(davidben): Move this state from Blink into content.
+ if (params->window_was_created_with_opener)
+ webview()->setOpenedByDOM();
-#if defined(ENABLE_WEBRTC)
- if (!media_stream_dispatcher_)
- media_stream_dispatcher_ = new MediaStreamDispatcher(this);
-#endif
+ OnSetRendererPrefs(params->renderer_prefs);
new MHTMLGenerator(this);
#if defined(OS_MACOSX)
new TextInputClientObserver(this);
#endif // defined(OS_MACOSX)
-#if defined(OS_ANDROID)
- media_player_manager_ = new RendererMediaPlayerManager(this);
-#endif
-
// The next group of objects all implement RenderViewObserver, so are deleted
// along with the RenderView automatically.
devtools_agent_ = new DevToolsAgent(this);
webview()->devToolsAgent()->setLayerTreeId(rwc->GetLayerTreeId());
}
mouse_lock_dispatcher_ = new RenderViewMouseLockDispatcher(this);
- new ImageLoadingHelper(this);
- // Create renderer_accessibility_ if needed.
- OnSetAccessibilityMode(params->accessibility_mode);
+ history_controller_.reset(new HistoryController(this));
new IdleUserDetector(this);
// If we are initially swapped out, navigate to kSwappedOutURL.
// This ensures we are in a unique origin that others cannot script.
- if (is_swapped_out_)
+ if (is_swapped_out_ && webview()->mainFrame()->isWebLocalFrame())
NavigateToSwappedOutURL(webview()->mainFrame());
}
RenderViewImpl::~RenderViewImpl() {
+ for (BitmapMap::iterator it = disambiguation_bitmaps_.begin();
+ it != disambiguation_bitmaps_.end();
+ ++it)
+ delete it->second;
history_page_ids_.clear();
base::debug::TraceLog::GetInstance()->RemoveProcessLabel(routing_id_);
return RenderViewImpl::FromRoutingID(routing_id);
}
+/* static */
+size_t RenderViewImpl::GetRenderViewCount() {
+ return g_view_map.Get().size();
+}
+
/*static*/
void RenderView::ForEach(RenderViewVisitor* visitor) {
ViewMap* views = g_view_map.Pointer();
}
/*static*/
+void RenderView::ApplyWebPreferences(const WebPreferences& prefs,
+ WebView* web_view) {
+ WebSettings* settings = web_view->settings();
+ ApplyFontsFromMap(prefs.standard_font_family_map,
+ SetStandardFontFamilyWrapper, settings);
+ ApplyFontsFromMap(prefs.fixed_font_family_map,
+ SetFixedFontFamilyWrapper, settings);
+ ApplyFontsFromMap(prefs.serif_font_family_map,
+ SetSerifFontFamilyWrapper, settings);
+ ApplyFontsFromMap(prefs.sans_serif_font_family_map,
+ SetSansSerifFontFamilyWrapper, settings);
+ ApplyFontsFromMap(prefs.cursive_font_family_map,
+ SetCursiveFontFamilyWrapper, settings);
+ ApplyFontsFromMap(prefs.fantasy_font_family_map,
+ SetFantasyFontFamilyWrapper, settings);
+ ApplyFontsFromMap(prefs.pictograph_font_family_map,
+ SetPictographFontFamilyWrapper, settings);
+ settings->setDefaultFontSize(prefs.default_font_size);
+ settings->setDefaultFixedFontSize(prefs.default_fixed_font_size);
+ settings->setMinimumFontSize(prefs.minimum_font_size);
+ settings->setMinimumLogicalFontSize(prefs.minimum_logical_font_size);
+ settings->setDefaultTextEncodingName(
+ base::ASCIIToUTF16(prefs.default_encoding));
+ settings->setJavaScriptEnabled(prefs.javascript_enabled);
+ settings->setWebSecurityEnabled(prefs.web_security_enabled);
+ settings->setJavaScriptCanOpenWindowsAutomatically(
+ prefs.javascript_can_open_windows_automatically);
+ settings->setLoadsImagesAutomatically(prefs.loads_images_automatically);
+ settings->setImagesEnabled(prefs.images_enabled);
+ settings->setPluginsEnabled(prefs.plugins_enabled);
+ settings->setDOMPasteAllowed(prefs.dom_paste_enabled);
+ settings->setShrinksStandaloneImagesToFit(
+ prefs.shrinks_standalone_images_to_fit);
+ settings->setUsesEncodingDetector(prefs.uses_universal_detector);
+ settings->setTextAreasAreResizable(prefs.text_areas_are_resizable);
+ settings->setAllowScriptsToCloseWindows(prefs.allow_scripts_to_close_windows);
+ settings->setDownloadableBinaryFontsEnabled(prefs.remote_fonts_enabled);
+ settings->setJavaScriptCanAccessClipboard(
+ prefs.javascript_can_access_clipboard);
+ WebRuntimeFeatures::enableXSLT(prefs.xslt_enabled);
+ settings->setXSSAuditorEnabled(prefs.xss_auditor_enabled);
+ settings->setDNSPrefetchingEnabled(prefs.dns_prefetching_enabled);
+ settings->setLocalStorageEnabled(prefs.local_storage_enabled);
+ settings->setSyncXHRInDocumentsEnabled(prefs.sync_xhr_in_documents_enabled);
+ WebRuntimeFeatures::enableDatabase(prefs.databases_enabled);
+ settings->setOfflineWebApplicationCacheEnabled(
+ prefs.application_cache_enabled);
+ settings->setCaretBrowsingEnabled(prefs.caret_browsing_enabled);
+ settings->setHyperlinkAuditingEnabled(prefs.hyperlink_auditing_enabled);
+ settings->setCookieEnabled(prefs.cookie_enabled);
+ settings->setNavigateOnDragDrop(prefs.navigate_on_drag_drop);
+
+ settings->setJavaEnabled(prefs.java_enabled);
+
+ // By default, allow_universal_access_from_file_urls is set to false and thus
+ // we mitigate attacks from local HTML files by not granting file:// URLs
+ // universal access. Only test shell will enable this.
+ settings->setAllowUniversalAccessFromFileURLs(
+ prefs.allow_universal_access_from_file_urls);
+ settings->setAllowFileAccessFromFileURLs(
+ prefs.allow_file_access_from_file_urls);
+
+ // Enable the web audio API if requested on the command line.
+ settings->setWebAudioEnabled(prefs.webaudio_enabled);
+
+ // Enable experimental WebGL support if requested on command line
+ // and support is compiled in.
+ settings->setExperimentalWebGLEnabled(prefs.experimental_webgl_enabled);
+
+ // Disable GL multisampling if requested on command line.
+ settings->setOpenGLMultisamplingEnabled(prefs.gl_multisampling_enabled);
+
+ // Enable WebGL errors to the JS console if requested.
+ settings->setWebGLErrorsToConsoleEnabled(
+ prefs.webgl_errors_to_console_enabled);
+
+ // Uses the mock theme engine for scrollbars.
+ settings->setMockScrollbarsEnabled(prefs.mock_scrollbars_enabled);
+
+ settings->setLayerSquashingEnabled(prefs.layer_squashing_enabled);
+
+ // Enable gpu-accelerated 2d canvas if requested on the command line.
+ settings->setAccelerated2dCanvasEnabled(prefs.accelerated_2d_canvas_enabled);
+
+ settings->setMinimumAccelerated2dCanvasSize(
+ prefs.minimum_accelerated_2d_canvas_size);
+
+ // Disable antialiasing for 2d canvas if requested on the command line.
+ settings->setAntialiased2dCanvasEnabled(
+ !prefs.antialiased_2d_canvas_disabled);
+
+ // Set MSAA sample count for 2d canvas if requested on the command line (or
+ // default value if not).
+ settings->setAccelerated2dCanvasMSAASampleCount(
+ prefs.accelerated_2d_canvas_msaa_sample_count);
+
+ // Enable deferred filter rendering if requested on the command line.
+ settings->setDeferredFiltersEnabled(prefs.deferred_filters_enabled);
+
+ // Enable container culling if requested on the command line.
+ settings->setContainerCullingEnabled(prefs.container_culling_enabled);
+
+ settings->setAsynchronousSpellCheckingEnabled(
+ prefs.asynchronous_spell_checking_enabled);
+ settings->setUnifiedTextCheckerEnabled(prefs.unified_textchecker_enabled);
+
+ // Tabs to link is not part of the settings. WebCore calls
+ // ChromeClient::tabsToLinks which is part of the glue code.
+ web_view->setTabsToLinks(prefs.tabs_to_links);
+
+ settings->setAllowDisplayOfInsecureContent(
+ prefs.allow_displaying_insecure_content);
+ settings->setAllowRunningOfInsecureContent(
+ prefs.allow_running_insecure_content);
+ settings->setPasswordEchoEnabled(prefs.password_echo_enabled);
+ settings->setShouldPrintBackgrounds(prefs.should_print_backgrounds);
+ settings->setShouldClearDocumentBackground(
+ prefs.should_clear_document_background);
+ settings->setEnableScrollAnimator(prefs.enable_scroll_animator);
+
+ settings->setRegionBasedColumnsEnabled(prefs.region_based_columns_enabled);
+
+ WebRuntimeFeatures::enableTouch(prefs.touch_enabled);
+ settings->setMaxTouchPoints(prefs.pointer_events_max_touch_points);
+ settings->setDeviceSupportsTouch(prefs.device_supports_touch);
+ settings->setDeviceSupportsMouse(prefs.device_supports_mouse);
+ settings->setEnableTouchAdjustment(prefs.touch_adjustment_enabled);
+
+ settings->setDeferredImageDecodingEnabled(
+ prefs.deferred_image_decoding_enabled);
+ settings->setShouldRespectImageOrientation(
+ prefs.should_respect_image_orientation);
+
+ settings->setUnsafePluginPastingEnabled(false);
+ settings->setEditingBehavior(
+ static_cast<WebSettings::EditingBehavior>(prefs.editing_behavior));
+
+ settings->setSupportsMultipleWindows(prefs.supports_multiple_windows);
+
+ settings->setViewportEnabled(prefs.viewport_enabled);
+ settings->setLoadWithOverviewMode(prefs.initialize_at_minimum_page_scale);
+ settings->setViewportMetaEnabled(prefs.viewport_meta_enabled);
+ settings->setMainFrameResizesAreOrientationChanges(
+ prefs.main_frame_resizes_are_orientation_changes);
+
+ settings->setSmartInsertDeleteEnabled(prefs.smart_insert_delete_enabled);
+
+ settings->setSpatialNavigationEnabled(prefs.spatial_navigation_enabled);
+
+ settings->setSelectionIncludesAltImageText(true);
+
+ settings->setV8CacheOptions(
+ static_cast<WebSettings::V8CacheOptions>(prefs.v8_cache_options));
+
+ settings->setV8ScriptStreamingEnabled(prefs.v8_script_streaming_enabled);
+
+ // Crosswalk shared settings:
+ settings->setMainFrameClipsContent(false);
+
+#if defined(OS_TIZEN)
+ // Scrollbars should not be stylable.
+ settings->setAllowCustomScrollbarInMainFrame(false);
+
+ // IME support
+ settings->setAutoZoomFocusedNodeToLegibleScale(true);
+
+ // Enable double tap to zoom when zoomable.
+ settings->setDoubleTapToZoomEnabled(true);
+
+ settings->setShrinksViewportContentToFit(true);
+#endif
+
+#if defined(OS_ANDROID)
+ settings->setAllowCustomScrollbarInMainFrame(false);
+ settings->setTextAutosizingEnabled(prefs.text_autosizing_enabled);
+ settings->setAccessibilityFontScaleFactor(prefs.font_scale_factor);
+ settings->setDeviceScaleAdjustment(prefs.device_scale_adjustment);
+ settings->setDisallowFullscreenForNonMediaElements(
+ prefs.disallow_fullscreen_for_non_media_elements);
+ settings->setFullscreenSupported(prefs.fullscreen_supported);
+ web_view->setIgnoreViewportTagScaleLimits(prefs.force_enable_zoom);
+ settings->setAutoZoomFocusedNodeToLegibleScale(true);
+ settings->setDoubleTapToZoomEnabled(prefs.double_tap_to_zoom_enabled);
+ settings->setMediaControlsOverlayPlayButtonEnabled(true);
+ settings->setMediaPlaybackRequiresUserGesture(
+ prefs.user_gesture_required_for_media_playback);
+ settings->setDefaultVideoPosterURL(
+ base::ASCIIToUTF16(prefs.default_video_poster_url.spec()));
+ settings->setSupportDeprecatedTargetDensityDPI(
+ prefs.support_deprecated_target_density_dpi);
+ settings->setUseLegacyBackgroundSizeShorthandBehavior(
+ prefs.use_legacy_background_size_shorthand_behavior);
+ settings->setWideViewportQuirkEnabled(prefs.wide_viewport_quirk);
+ settings->setUseWideViewport(prefs.use_wide_viewport);
+ settings->setForceZeroLayoutHeight(prefs.force_zero_layout_height);
+ settings->setViewportMetaLayoutSizeQuirk(
+ prefs.viewport_meta_layout_size_quirk);
+ settings->setViewportMetaMergeContentQuirk(
+ prefs.viewport_meta_merge_content_quirk);
+ settings->setViewportMetaNonUserScalableQuirk(
+ prefs.viewport_meta_non_user_scalable_quirk);
+ settings->setViewportMetaZeroValuesQuirk(
+ prefs.viewport_meta_zero_values_quirk);
+ settings->setClobberUserAgentInitialScaleQuirk(
+ prefs.clobber_user_agent_initial_scale_quirk);
+ settings->setIgnoreMainFrameOverflowHiddenQuirk(
+ prefs.ignore_main_frame_overflow_hidden_quirk);
+ settings->setReportScreenSizeInPhysicalPixelsQuirk(
+ prefs.report_screen_size_in_physical_pixels_quirk);
+ settings->setMainFrameClipsContent(false);
+ settings->setShrinksStandaloneImagesToFit(false);
+ settings->setShrinksViewportContentToFit(true);
+#endif
+
+ WebNetworkStateNotifier::setOnLine(prefs.is_online);
+ WebNetworkStateNotifier::setWebConnectionType(
+ NetConnectionTypeToWebConnectionType(prefs.connection_type));
+ settings->setPinchVirtualViewportEnabled(
+ prefs.pinch_virtual_viewport_enabled);
+
+ settings->setPinchOverlayScrollbarThickness(
+ prefs.pinch_overlay_scrollbar_thickness);
+ settings->setUseSolidColorScrollbars(prefs.use_solid_color_scrollbars);
+}
+
+/*static*/
RenderViewImpl* RenderViewImpl::Create(
int32 opener_id,
+ bool window_was_created_with_opener,
const RendererPreferences& renderer_prefs,
const WebPreferences& webkit_prefs,
int32 routing_id,
const base::string16& frame_name,
bool is_renderer_created,
bool swapped_out,
+ int32 proxy_routing_id,
bool hidden,
+ bool never_visible,
int32 next_page_id,
- const blink::WebScreenInfo& screen_info,
- AccessibilityMode accessibility_mode) {
+ const blink::WebScreenInfo& screen_info) {
DCHECK(routing_id != MSG_ROUTING_NONE);
RenderViewImplParams params(opener_id,
+ window_was_created_with_opener,
renderer_prefs,
webkit_prefs,
routing_id,
frame_name,
is_renderer_created,
swapped_out,
+ proxy_routing_id,
hidden,
+ never_visible,
next_page_id,
- screen_info,
- accessibility_mode);
+ screen_info);
RenderViewImpl* render_view = NULL;
if (g_create_render_view_impl)
render_view = g_create_render_view_impl(¶ms);
else
render_view = new RenderViewImpl(¶ms);
+
render_view->Initialize(¶ms);
return render_view;
}
else if (focused_pepper_plugin_ == instance)
focused_pepper_plugin_ = NULL;
- UpdateTextInputType();
+ UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
UpdateSelectionBounds();
}
Send(new ViewHostMsg_PluginFocusChanged(routing_id(), focused, plugin_id));
}
+void RenderViewImpl::OnGetRenderedText() {
+ if (!webview())
+ return;
+ // Get rendered text from WebLocalFrame.
+ // TODO: Currently IPC truncates any data that has a
+ // size > kMaximumMessageSize. May be split the text into smaller chunks and
+ // send back using multiple IPC. See http://crbug.com/393444.
+ static const size_t kMaximumMessageSize = 8 * 1024 * 1024;
+ std::string text = webview()->mainFrame()->contentAsText(
+ kMaximumMessageSize).utf8();
+
+ Send(new ViewMsg_GetRenderedTextCompleted(routing_id(), text));
+}
+
void RenderViewImpl::StartPluginIme() {
IPC::Message* msg = new ViewHostMsg_StartPluginIme(routing_id());
// This message can be sent during event-handling, and needs to be delivered
bool RenderViewImpl::OnMessageReceived(const IPC::Message& message) {
WebFrame* main_frame = webview() ? webview()->mainFrame() : NULL;
- if (main_frame)
+ if (main_frame && main_frame->isWebLocalFrame())
GetContentClient()->SetActiveURL(main_frame->document().url());
ObserverListBase<RenderViewObserver>::Iterator it(observers_);
return true;
bool handled = true;
- bool msg_is_ok = true;
- IPC_BEGIN_MESSAGE_MAP_EX(RenderViewImpl, message, msg_is_ok)
+ IPC_BEGIN_MESSAGE_MAP(RenderViewImpl, message)
IPC_MESSAGE_HANDLER(InputMsg_ExecuteEditCommand, OnExecuteEditCommand)
IPC_MESSAGE_HANDLER(InputMsg_MoveCaret, OnMoveCaret)
- IPC_MESSAGE_HANDLER(InputMsg_Replace, OnReplace)
- IPC_MESSAGE_HANDLER(InputMsg_ReplaceMisspelling, OnReplaceMisspelling)
IPC_MESSAGE_HANDLER(InputMsg_ScrollFocusedEditableNodeIntoRect,
OnScrollFocusedEditableNodeIntoRect)
IPC_MESSAGE_HANDLER(InputMsg_SetEditCommandsForNextKeyEvent,
OnSetEditCommandsForNextKeyEvent)
- IPC_MESSAGE_HANDLER(FrameMsg_Navigate, OnNavigate)
- IPC_MESSAGE_HANDLER(ViewMsg_Stop, OnStop)
- IPC_MESSAGE_HANDLER(ViewMsg_ReloadFrame, OnReloadFrame)
- IPC_MESSAGE_HANDLER(ViewMsg_SetName, OnSetName)
IPC_MESSAGE_HANDLER(ViewMsg_CopyImageAt, OnCopyImageAt)
+ IPC_MESSAGE_HANDLER(ViewMsg_SaveImageAt, OnSaveImageAt)
IPC_MESSAGE_HANDLER(ViewMsg_Find, OnFind)
IPC_MESSAGE_HANDLER(ViewMsg_StopFinding, OnStopFinding)
IPC_MESSAGE_HANDLER(ViewMsg_Zoom, OnZoom)
- IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevel, OnSetZoomLevel)
IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForLoadingURL,
OnSetZoomLevelForLoadingURL)
+ IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForView,
+ OnSetZoomLevelForView)
IPC_MESSAGE_HANDLER(ViewMsg_SetPageEncoding, OnSetPageEncoding)
IPC_MESSAGE_HANDLER(ViewMsg_ResetPageEncodingToDefault,
OnResetPageEncodingToDefault)
- IPC_MESSAGE_HANDLER(ViewMsg_ScriptEvalRequest, OnScriptEvalRequest)
IPC_MESSAGE_HANDLER(ViewMsg_PostMessageEvent, OnPostMessageEvent)
IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
- IPC_MESSAGE_HANDLER(DragMsg_SourceEndedOrMoved, OnDragSourceEndedOrMoved)
+ IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
OnDragSourceSystemDragEnded)
IPC_MESSAGE_HANDLER(ViewMsg_AllowBindings, OnAllowBindings)
IPC_MESSAGE_HANDLER(ViewMsg_ThemeChanged, OnThemeChanged)
IPC_MESSAGE_HANDLER(ViewMsg_MoveOrResizeStarted, OnMoveOrResizeStarted)
IPC_MESSAGE_HANDLER(ViewMsg_ClearFocusedElement, OnClearFocusedElement)
- IPC_MESSAGE_HANDLER(ViewMsg_SetBackground, OnSetBackground)
+ IPC_MESSAGE_HANDLER(ViewMsg_SetBackgroundOpaque, OnSetBackgroundOpaque)
IPC_MESSAGE_HANDLER(ViewMsg_EnablePreferredSizeChangedMode,
OnEnablePreferredSizeChangedMode)
IPC_MESSAGE_HANDLER(ViewMsg_EnableAutoResize, OnEnableAutoResize)
OnDisableScrollbarsForSmallWindows)
IPC_MESSAGE_HANDLER(ViewMsg_SetRendererPrefs, OnSetRendererPrefs)
IPC_MESSAGE_HANDLER(ViewMsg_MediaPlayerActionAt, OnMediaPlayerActionAt)
- IPC_MESSAGE_HANDLER(ViewMsg_OrientationChangeEvent,
- OnOrientationChangeEvent)
IPC_MESSAGE_HANDLER(ViewMsg_PluginActionAt, OnPluginActionAt)
IPC_MESSAGE_HANDLER(ViewMsg_SetActive, OnSetActive)
IPC_MESSAGE_HANDLER(ViewMsg_GetAllSavableResourceLinksForCurrentPage,
IPC_MESSAGE_HANDLER(ViewMsg_SetHistoryLengthAndPrune,
OnSetHistoryLengthAndPrune)
IPC_MESSAGE_HANDLER(ViewMsg_EnableViewSourceMode, OnEnableViewSourceMode)
- IPC_MESSAGE_HANDLER(ViewMsg_SetAccessibilityMode, OnSetAccessibilityMode)
- IPC_MESSAGE_HANDLER(ViewMsg_DisownOpener, OnDisownOpener)
- IPC_MESSAGE_HANDLER(ViewMsg_ReleaseDisambiguationPopupDIB,
- OnReleaseDisambiguationPopupDIB)
+ IPC_MESSAGE_HANDLER(ViewMsg_ReleaseDisambiguationPopupBitmap,
+ OnReleaseDisambiguationPopupBitmap)
IPC_MESSAGE_HANDLER(ViewMsg_WindowSnapshotCompleted,
OnWindowSnapshotCompleted)
+ IPC_MESSAGE_HANDLER(ViewMsg_ForceRedraw, OnForceRedraw)
+ IPC_MESSAGE_HANDLER(ViewMsg_SelectWordAroundCaret, OnSelectWordAroundCaret)
#if defined(OS_ANDROID)
IPC_MESSAGE_HANDLER(InputMsg_ActivateNearestFindResult,
OnActivateNearestFindResult)
IPC_MESSAGE_HANDLER(ViewMsg_FindMatchRects, OnFindMatchRects)
- IPC_MESSAGE_HANDLER(ViewMsg_SelectPopupMenuItems, OnSelectPopupMenuItems)
IPC_MESSAGE_HANDLER(ViewMsg_UpdateTopControlsState,
OnUpdateTopControlsState)
- IPC_MESSAGE_HANDLER(ViewMsg_PauseVideo, OnPauseVideo)
IPC_MESSAGE_HANDLER(ViewMsg_ExtractSmartClipData, OnExtractSmartClipData)
#elif defined(OS_MACOSX)
+ IPC_MESSAGE_HANDLER(ViewMsg_GetRenderedText,
+ OnGetRenderedText)
IPC_MESSAGE_HANDLER(ViewMsg_PluginImeCompositionCompleted,
OnPluginImeCompositionCompleted)
- IPC_MESSAGE_HANDLER(ViewMsg_SelectPopupMenuItem, OnSelectPopupMenuItem)
IPC_MESSAGE_HANDLER(ViewMsg_SetInLiveResize, OnSetInLiveResize)
IPC_MESSAGE_HANDLER(ViewMsg_SetWindowVisibility, OnSetWindowVisibility)
IPC_MESSAGE_HANDLER(ViewMsg_WindowFrameChanged, OnWindowFrameChanged)
IPC_MESSAGE_UNHANDLED(handled = RenderWidget::OnMessageReceived(message))
IPC_END_MESSAGE_MAP()
- if (!msg_is_ok) {
- // The message had a handler, but its deserialization failed.
- // Kill the renderer to avoid potential spoofing attacks.
- CHECK(false) << "Unable to deserialize message in RenderViewImpl.";
- }
-
return handled;
}
-void RenderViewImpl::OnNavigate(const FrameMsg_Navigate_Params& params) {
- FOR_EACH_OBSERVER(RenderViewObserver, observers_, Navigate(params.url));
+void RenderViewImpl::OnSelectWordAroundCaret() {
+ if (!webview())
+ return;
+
+ handling_input_event_ = true;
+ webview()->focusedFrame()->selectWordAroundCaret();
+ handling_input_event_ = false;
}
bool RenderViewImpl::IsBackForwardToStaleEntry(
return false;
}
-// Stop loading the current page.
-void RenderViewImpl::OnStop() {
- if (webview())
- webview()->mainFrame()->stopLoading();
- FOR_EACH_OBSERVER(RenderViewObserver, observers_, OnStop());
- main_render_frame_->OnStop();
-}
-
-// Reload current focused frame.
-// E.g. called by right-clicking on the frame and picking "reload this frame".
-void RenderViewImpl::OnReloadFrame() {
- if (webview() && webview()->focusedFrame()) {
- // We always obey the cache (ignore_cache=false) here.
- // TODO(evanm): perhaps we could allow shift-clicking the menu item to do
- // a cache-ignoring reload of the frame.
- webview()->focusedFrame()->reload(false);
- }
-}
-
void RenderViewImpl::OnCopyImageAt(int x, int y) {
webview()->copyImageAt(WebPoint(x, y));
}
+void RenderViewImpl::OnSaveImageAt(int x, int y) {
+ webview()->saveImageAt(WebPoint(x, y));
+}
+
void RenderViewImpl::OnUpdateTargetURLAck() {
// Check if there is a targeturl waiting to be sent.
- if (target_url_status_ == TARGET_PENDING) {
- Send(new ViewHostMsg_UpdateTargetURL(routing_id_, page_id_,
- pending_target_url_));
- }
+ if (target_url_status_ == TARGET_PENDING)
+ Send(new ViewHostMsg_UpdateTargetURL(routing_id_, pending_target_url_));
target_url_status_ = TARGET_NONE;
}
webview()->focusedFrame()->moveCaretSelection(point);
}
-void RenderViewImpl::OnReplace(const base::string16& text) {
- if (!webview())
- return;
-
- WebFrame* frame = webview()->focusedFrame();
- if (!frame->hasSelection())
- frame->selectWordAroundCaret();
-
- frame->replaceSelection(text);
-}
-
-void RenderViewImpl::OnReplaceMisspelling(const base::string16& text) {
- if (!webview())
- return;
-
- WebFrame* frame = webview()->focusedFrame();
- if (!frame->hasSelection())
- return;
-
- frame->replaceMisspelledRange(text);
-}
-
void RenderViewImpl::OnScrollFocusedEditableNodeIntoRect(
const gfx::Rect& rect) {
if (has_scrolled_focused_editable_node_into_rect_ &&
edit_commands_ = edit_commands;
}
-void RenderViewImpl::OnSetName(const std::string& name) {
- if (!webview())
- return;
-
- webview()->mainFrame()->setName(WebString::fromUTF8(name));
-}
-
void RenderViewImpl::OnSetHistoryLengthAndPrune(int history_length,
int32 minimum_page_id) {
DCHECK_GE(history_length, 0);
}
#endif
-#if defined(OS_ANDROID)
-void RenderViewImpl::OnPauseVideo() {
- // Inform RendererMediaPlayerManager to release all video player resources.
- // If something is in progress the resource will not be freed, it will
- // only be freed once the tab is destroyed or if the user navigates away
- // via WebMediaPlayerAndroid::Destroy.
- media_player_manager_->ReleaseVideoResources();
-}
-#endif
-
///////////////////////////////////////////////////////////////////////////////
-// Tell the embedding application that the title of the active page has changed
-void RenderViewImpl::UpdateTitle(WebFrame* frame,
- const base::string16& title,
- WebTextDirection title_direction) {
- // Ignore all but top level navigations.
- if (frame->parent())
- return;
-
- base::debug::TraceLog::GetInstance()->UpdateProcessLabel(
- routing_id_, base::UTF16ToUTF8(title));
-
- base::string16 shortened_title = title.substr(0, kMaxTitleChars);
- Send(new ViewHostMsg_UpdateTitle(routing_id_, page_id_, shortened_title,
- title_direction));
-}
-
-void RenderViewImpl::UpdateEncoding(WebFrame* frame,
- const std::string& encoding_name) {
- // Only update main frame's encoding_name.
- if (webview()->mainFrame() == frame &&
- last_encoding_name_ != encoding_name) {
- // Save the encoding name for later comparing.
- last_encoding_name_ = encoding_name;
-
- Send(new ViewHostMsg_UpdateEncoding(routing_id_, last_encoding_name_));
- }
-}
-
-// Sends the last committed session history state to the browser so it will be
-// saved before we navigate to a new page. This must be called *before* the
-// page ID has been updated so we know what it was.
+// Sends the current history state to the browser so it will be saved before we
+// navigate to a new page.
void RenderViewImpl::UpdateSessionHistory(WebFrame* frame) {
// If we have a valid page ID at this point, then it corresponds to the page
// we are navigating away from. Otherwise, this is the first navigation, so
// there is no past session history to record.
if (page_id_ == -1)
return;
-
- const WebHistoryItem& item =
- webview()->mainFrame()->previousHistoryItem();
- SendUpdateState(item);
+ SendUpdateState(history_controller_->GetCurrentEntry());
}
-void RenderViewImpl::SendUpdateState(const WebHistoryItem& item) {
- if (item.isNull())
+void RenderViewImpl::SendUpdateState(HistoryEntry* entry) {
+ if (!entry)
return;
// Don't send state updates for kSwappedOutURL.
- if (item.urlString() == WebString::fromUTF8(kSwappedOutURL))
+ if (entry->root().urlString() == WebString::fromUTF8(kSwappedOutURL))
return;
Send(new ViewHostMsg_UpdateState(
- routing_id_, page_id_, HistoryItemToPageState(item)));
-}
-
-// WebViewDelegate ------------------------------------------------------------
-
-void RenderViewImpl::LoadNavigationErrorPage(
- WebFrame* frame,
- const WebURLRequest& failed_request,
- const WebURLError& error,
- bool replace) {
- std::string error_html;
- GetContentClient()->renderer()->GetNavigationErrorStrings(
- this, frame, failed_request, error, &error_html, NULL);
-
- frame->loadHTMLString(error_html,
- GURL(kUnreachableWebDataURL),
- error.unreachableURL,
- replace);
-}
-
-bool RenderViewImpl::RunJavaScriptMessage(JavaScriptMessageType type,
- const base::string16& message,
- const base::string16& default_value,
- const GURL& frame_url,
- base::string16* result) {
- // Don't allow further dialogs if we are waiting to swap out, since the
- // PageGroupLoadDeferrer in our stack prevents it.
- if (suppress_dialogs_until_swap_out_)
- return false;
-
- bool success = false;
- base::string16 result_temp;
- if (!result)
- result = &result_temp;
-
- SendAndRunNestedMessageLoop(new ViewHostMsg_RunJavaScriptMessage(
- routing_id_, message, default_value, frame_url, type, &success, result));
- return success;
+ routing_id_, page_id_, HistoryEntryToPageState(entry)));
}
bool RenderViewImpl::SendAndRunNestedMessageLoop(IPC::SyncMessage* message) {
int id = next_snapshot_id_++;
pending_snapshots_.insert(std::make_pair(id, callback));
ui::LatencyInfo latency_info;
- latency_info.AddLatencyNumber(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
+ latency_info.AddLatencyNumber(ui::WINDOW_OLD_SNAPSHOT_FRAME_NUMBER_COMPONENT,
0,
id);
scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
if (RenderWidgetCompositor* rwc = compositor()) {
latency_info_swap_promise_monitor =
rwc->CreateLatencyInfoSwapPromiseMonitor(&latency_info).Pass();
- } else {
- latency_info_.push_back(latency_info);
+ }
+ ScheduleCompositeWithForcedRedraw();
+}
+
+void RenderViewImpl::OnForceRedraw(int id) {
+ ui::LatencyInfo latency_info;
+ if (id) {
+ latency_info.AddLatencyNumber(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
+ 0,
+ id);
+ }
+ scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
+ if (RenderWidgetCompositor* rwc = compositor()) {
+ latency_info_swap_promise_monitor =
+ rwc->CreateLatencyInfoSwapPromiseMonitor(&latency_info).Pass();
}
ScheduleCompositeWithForcedRedraw();
}
// blink::WebViewClient ------------------------------------------------------
-WebView* RenderViewImpl::createView(
- WebFrame* creator,
- const WebURLRequest& request,
- const WebWindowFeatures& features,
- const WebString& frame_name,
- WebNavigationPolicy policy,
- bool suppress_opener) {
+WebView* RenderViewImpl::createView(WebLocalFrame* creator,
+ const WebURLRequest& request,
+ const WebWindowFeatures& features,
+ const WebString& frame_name,
+ WebNavigationPolicy policy,
+ bool suppress_opener) {
ViewHostMsg_CreateWindow_Params params;
params.opener_id = routing_id_;
params.user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
RenderFrameImpl::FromWebFrame(creator)->GetRoutingID();
params.opener_url = creator->document().url();
params.opener_top_level_frame_url = creator->top()->document().url();
- GURL security_url(creator->document().securityOrigin().toString().utf8());
+ GURL security_url(creator->document().securityOrigin().toString());
if (!security_url.is_valid())
security_url = GURL();
params.opener_security_origin = security_url;
int32 routing_id = MSG_ROUTING_NONE;
int32 main_frame_routing_id = MSG_ROUTING_NONE;
int32 surface_id = 0;
- int64 cloned_session_storage_namespace_id;
+ int64 cloned_session_storage_namespace_id = 0;
RenderThread::Get()->Send(
new ViewHostMsg_CreateWindow(params,
WebUserGestureIndicator::consumeUserGesture();
- WebPreferences transferred_preferences = webkit_preferences_;
-
- // Unless accelerated compositing has been explicitly disabled from the
- // command line (e.g. via the blacklist or about:flags) re-enable it for
- // new views that get spawned by this view. This gets around the issue that
- // background extension pages disable accelerated compositing via web prefs
- // but can themselves spawn a visible render view which should be allowed
- // use gpu acceleration.
- if (!webkit_preferences_.accelerated_compositing_enabled) {
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
- if (!command_line.HasSwitch(switches::kDisableAcceleratedCompositing))
- transferred_preferences.accelerated_compositing_enabled = true;
- }
+ // While this view may be a background extension page, it can spawn a visible
+ // render view. So we just assume that the new one is not another background
+ // page instead of passing on our own value.
+ // TODO(vangelis): Can we tell if the new view will be a background page?
+ bool never_visible = false;
// The initial hidden state for the RenderViewImpl here has to match what the
// browser will eventually decide for the given disposition. Since we have to
// disagrees.
RenderViewImpl* view = RenderViewImpl::Create(
routing_id_,
+ true, // window_was_created_with_opener
renderer_preferences_,
- transferred_preferences,
+ webkit_preferences_,
routing_id,
main_frame_routing_id,
surface_id,
base::string16(), // WebCore will take care of setting the correct name.
true, // is_renderer_created
false, // swapped_out
+ MSG_ROUTING_NONE, // proxy_routing_id
params.disposition == NEW_BACKGROUND_TAB, // hidden
- 1, // next_page_id
- screen_info_,
- accessibility_mode_);
+ never_visible,
+ 1, // next_page_id
+ screen_info_);
view->opened_by_user_gesture_ = params.user_gesture;
// Record whether the creator frame is trying to suppress the opener field.
return widget->webwidget();
}
-WebExternalPopupMenu* RenderViewImpl::createExternalPopupMenu(
- const WebPopupMenuInfo& popup_menu_info,
- WebExternalPopupMenuClient* popup_menu_client) {
-#if defined(OS_MACOSX) || defined(OS_ANDROID)
- // An IPC message is sent to the browser to build and display the actual
- // popup. The user could have time to click a different select by the time
- // the popup is shown. In that case external_popup_menu_ is non NULL.
- // By returning NULL in that case, we instruct WebKit to cancel that new
- // popup. So from the user perspective, only the first one will show, and
- // will have to close the first one before another one can be shown.
- if (external_popup_menu_)
- return NULL;
- external_popup_menu_.reset(
- new ExternalPopupMenu(this, popup_menu_info, popup_menu_client));
- if (screen_metrics_emulator_) {
- SetExternalPopupOriginAdjustmentsForEmulation(
- external_popup_menu_.get(), screen_metrics_emulator_.get());
- }
- return external_popup_menu_.get();
-#else
- return NULL;
-#endif
-}
-
WebStorageNamespace* RenderViewImpl::createSessionStorageNamespace() {
CHECK(session_storage_namespace_id_ != kInvalidSessionStorageNamespaceId);
return new WebStorageNamespaceImpl(session_storage_namespace_id_);
}
-bool RenderViewImpl::shouldReportDetailedMessageForSource(
- const WebString& source) {
- return GetContentClient()->renderer()->ShouldReportDetailedMessageForSource(
- source);
-}
-
-void RenderViewImpl::didAddMessageToConsole(
- const WebConsoleMessage& message, const WebString& source_name,
- unsigned source_line, const WebString& stack_trace) {
- logging::LogSeverity log_severity = logging::LOG_VERBOSE;
- switch (message.level) {
- case WebConsoleMessage::LevelDebug:
- log_severity = logging::LOG_VERBOSE;
- break;
- case WebConsoleMessage::LevelLog:
- case WebConsoleMessage::LevelInfo:
- log_severity = logging::LOG_INFO;
- break;
- case WebConsoleMessage::LevelWarning:
- log_severity = logging::LOG_WARNING;
- break;
- case WebConsoleMessage::LevelError:
- log_severity = logging::LOG_ERROR;
- break;
- default:
- NOTREACHED();
- }
-
- if (shouldReportDetailedMessageForSource(source_name)) {
- FOR_EACH_OBSERVER(
- RenderViewObserver,
- observers_,
- DetailedConsoleMessageAdded(message.text,
- source_name,
- stack_trace,
- source_line,
- static_cast<int32>(log_severity)));
- }
-
- Send(new ViewHostMsg_AddMessageToConsole(routing_id_,
- static_cast<int32>(log_severity),
- message.text,
- static_cast<int32>(source_line),
- source_name));
-}
-
-void RenderViewImpl::printPage(WebFrame* frame) {
+void RenderViewImpl::printPage(WebLocalFrame* frame) {
FOR_EACH_OBSERVER(RenderViewObserver, observers_,
PrintPage(frame, handling_input_event_));
}
-blink::WebNotificationPresenter* RenderViewImpl::notificationPresenter() {
- return notification_provider_;
+void RenderViewImpl::saveImageFromDataURL(const blink::WebString& data_url) {
+ // Note: We should basically send GURL but we use size-limited string instead
+ // in order to send a larger data url to save a image for <canvas> or <img>.
+ if (data_url.length() < kMaxLengthOfDataURLString)
+ Send(new ViewHostMsg_SaveImageFromDataURL(routing_id_, data_url.utf8()));
}
bool RenderViewImpl::enumerateChosenDirectory(
base::FilePath::FromUTF16Unsafe(path)));
}
-void RenderViewImpl::didStartLoading(bool to_different_document) {
- main_render_frame_->didStartLoading(to_different_document);
-}
-
-void RenderViewImpl::didStopLoading() {
- main_render_frame_->didStopLoading();
-}
-
void RenderViewImpl::FrameDidStartLoading(WebFrame* frame) {
- if (load_progress_tracker_ != NULL) {
- load_progress_tracker_->DidStartLoading(
- RenderFrameImpl::FromWebFrame(frame)->GetRoutingID());
- }
DCHECK_GE(frames_in_progress_, 0);
if (frames_in_progress_ == 0)
FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidStartLoading());
}
void RenderViewImpl::FrameDidStopLoading(WebFrame* frame) {
- if (load_progress_tracker_ != NULL) {
- load_progress_tracker_->DidStopLoading(
- RenderFrameImpl::FromWebFrame(frame)->GetRoutingID());
- }
+ // TODO(japhet): This should be a DCHECK, but the pdf plugin sometimes
+ // calls DidStopLoading() without a matching DidStartLoading().
+ if (frames_in_progress_ == 0)
+ return;
frames_in_progress_--;
- DCHECK_GE(frames_in_progress_, 0);
if (frames_in_progress_ == 0) {
DidStopLoadingIcons();
FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidStopLoading());
}
}
-void RenderViewImpl::FrameDidChangeLoadProgress(WebFrame* frame,
- double load_progress) {
- if (load_progress_tracker_ != NULL) {
- load_progress_tracker_->DidChangeLoadProgress(
- RenderFrameImpl::FromWebFrame(frame)->GetRoutingID(), load_progress);
- }
-}
-
void RenderViewImpl::didCancelCompositionOnSelectionChange() {
- Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
-}
-
-void RenderViewImpl::didExecuteCommand(const WebString& command_name) {
- const std::string& name = base::UTF16ToUTF8(command_name);
- if (StartsWithASCII(name, "Move", true) ||
- StartsWithASCII(name, "Insert", true) ||
- StartsWithASCII(name, "Delete", true))
- return;
- RenderThreadImpl::current()->RecordComputedAction(name);
+ Send(new InputHostMsg_ImeCancelComposition(routing_id()));
}
bool RenderViewImpl::handleCurrentKeyboardEvent() {
return did_execute_command;
}
-blink::WebColorChooser* RenderViewImpl::createColorChooser(
- blink::WebColorChooserClient* client,
- const blink::WebColor& initial_color,
- const blink::WebVector<blink::WebColorSuggestion>& suggestions) {
- RendererWebColorChooserImpl* color_chooser =
- new RendererWebColorChooserImpl(this, client);
- std::vector<content::ColorSuggestion> color_suggestions;
- for (size_t i = 0; i < suggestions.size(); i++) {
- color_suggestions.push_back(content::ColorSuggestion(suggestions[i]));
- }
- color_chooser->Open(static_cast<SkColor>(initial_color), color_suggestions);
- return color_chooser;
-}
-
bool RenderViewImpl::runFileChooser(
const blink::WebFileChooserParams& params,
WebFileChooserCompletion* chooser_completion) {
return ScheduleFileChooser(ipc_params, chooser_completion);
}
-void RenderViewImpl::runModalAlertDialog(WebFrame* frame,
- const WebString& message) {
- RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_ALERT,
- message,
- base::string16(),
- frame->document().url(),
- NULL);
-}
-
-bool RenderViewImpl::runModalConfirmDialog(WebFrame* frame,
- const WebString& message) {
- return RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_CONFIRM,
- message,
- base::string16(),
- frame->document().url(),
- NULL);
-}
-
-bool RenderViewImpl::runModalPromptDialog(WebFrame* frame,
- const WebString& message,
- const WebString& default_value,
- WebString* actual_value) {
- base::string16 result;
- bool ok = RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_PROMPT,
- message,
- default_value,
- frame->document().url(),
- &result);
- if (ok)
- actual_value->assign(result);
- return ok;
-}
-
-bool RenderViewImpl::runModalBeforeUnloadDialog(
- WebFrame* frame, const WebString& message) {
- bool is_reload = false;
- WebDataSource* ds = frame->provisionalDataSource();
- if (ds)
- is_reload = (ds->navigationType() == blink::WebNavigationTypeReload);
- return runModalBeforeUnloadDialog(frame, is_reload, message);
-}
-
-bool RenderViewImpl::runModalBeforeUnloadDialog(
- WebFrame* frame, bool is_reload, const WebString& message) {
- // If we are swapping out, we have already run the beforeunload handler.
- // TODO(creis): Fix OnSwapOut to clear the frame without running beforeunload
- // at all, to avoid running it twice.
- if (is_swapped_out_)
- return true;
-
- // Don't allow further dialogs if we are waiting to swap out, since the
- // PageGroupLoadDeferrer in our stack prevents it.
- if (suppress_dialogs_until_swap_out_)
- return false;
-
- bool success = false;
- // This is an ignored return value, but is included so we can accept the same
- // response as RunJavaScriptMessage.
- base::string16 ignored_result;
- SendAndRunNestedMessageLoop(new ViewHostMsg_RunBeforeUnloadConfirm(
- routing_id_, frame->document().url(), message, is_reload,
- &success, &ignored_result));
- return success;
+void RenderViewImpl::SetValidationMessageDirection(
+ base::string16* wrapped_main_text,
+ blink::WebTextDirection main_text_hint,
+ base::string16* wrapped_sub_text,
+ blink::WebTextDirection sub_text_hint) {
+ if (main_text_hint == blink::WebTextDirectionLeftToRight) {
+ *wrapped_main_text =
+ base::i18n::GetDisplayStringInLTRDirectionality(*wrapped_main_text);
+ } else if (main_text_hint == blink::WebTextDirectionRightToLeft &&
+ !base::i18n::IsRTL()) {
+ base::i18n::WrapStringWithRTLFormatting(wrapped_main_text);
+ }
+
+ if (!wrapped_sub_text->empty()) {
+ if (sub_text_hint == blink::WebTextDirectionLeftToRight) {
+ *wrapped_sub_text =
+ base::i18n::GetDisplayStringInLTRDirectionality(*wrapped_sub_text);
+ } else if (sub_text_hint == blink::WebTextDirectionRightToLeft) {
+ base::i18n::WrapStringWithRTLFormatting(wrapped_sub_text);
+ }
+ }
}
void RenderViewImpl::showValidationMessage(
const blink::WebRect& anchor_in_root_view,
const blink::WebString& main_text,
+ blink::WebTextDirection main_text_hint,
const blink::WebString& sub_text,
- blink::WebTextDirection hint) {
+ blink::WebTextDirection sub_text_hint) {
base::string16 wrapped_main_text = main_text;
base::string16 wrapped_sub_text = sub_text;
- if (hint == blink::WebTextDirectionLeftToRight) {
- wrapped_main_text =
- base::i18n::GetDisplayStringInLTRDirectionality(wrapped_main_text);
- if (!wrapped_sub_text.empty()) {
- wrapped_sub_text =
- base::i18n::GetDisplayStringInLTRDirectionality(wrapped_sub_text);
- }
- } else if (hint == blink::WebTextDirectionRightToLeft
- && !base::i18n::IsRTL()) {
- base::i18n::WrapStringWithRTLFormatting(&wrapped_main_text);
- if (!wrapped_sub_text.empty()) {
- base::i18n::WrapStringWithRTLFormatting(&wrapped_sub_text);
- }
- }
+
+ SetValidationMessageDirection(
+ &wrapped_main_text, main_text_hint, &wrapped_sub_text, sub_text_hint);
+
Send(new ViewHostMsg_ShowValidationMessage(
- routing_id(), anchor_in_root_view, wrapped_main_text, wrapped_sub_text));
+ routing_id(), AdjustValidationMessageAnchor(anchor_in_root_view),
+ wrapped_main_text, wrapped_sub_text));
}
void RenderViewImpl::hideValidationMessage() {
void RenderViewImpl::moveValidationMessage(
const blink::WebRect& anchor_in_root_view) {
- Send(new ViewHostMsg_MoveValidationMessage(routing_id(),
- anchor_in_root_view));
+ Send(new ViewHostMsg_MoveValidationMessage(
+ routing_id(), AdjustValidationMessageAnchor(anchor_in_root_view)));
}
void RenderViewImpl::setStatusText(const WebString& text) {
// see |ParamTraits<GURL>|.
if (latest_url.possibly_invalid_spec().size() > GetMaxURLChars())
latest_url = GURL();
- Send(new ViewHostMsg_UpdateTargetURL(routing_id_, page_id_, latest_url));
+ Send(new ViewHostMsg_UpdateTargetURL(routing_id_, latest_url));
target_url_ = latest_url;
target_url_status_ = TARGET_INFLIGHT;
}
UpdateTargetURL(focus_url_, mouse_over_url_);
}
-void RenderViewImpl::startDragging(WebFrame* frame,
+void RenderViewImpl::startDragging(WebLocalFrame* frame,
const WebDragData& data,
WebDragOperationsMask mask,
const WebImage& image,
Send(new ViewHostMsg_FocusedNodeChanged(routing_id_, IsEditableNode(node)));
FOR_EACH_OBSERVER(RenderViewObserver, observers_, FocusedNodeChanged(node));
-}
-void RenderViewImpl::numberOfWheelEventHandlersChanged(unsigned num_handlers) {
- Send(new ViewHostMsg_DidChangeNumWheelEvents(routing_id_, num_handlers));
+ // TODO(dmazzoni): this should be part of RenderFrameObserver.
+ GetMainRenderFrame()->FocusedNodeChanged(node);
}
void RenderViewImpl::didUpdateLayout() {
return history_list_length_ - historyBackListCount() - 1;
}
-void RenderViewImpl::postAccessibilityEvent(
- const WebAXObject& obj, blink::WebAXEvent event) {
- if (renderer_accessibility_) {
- renderer_accessibility_->HandleWebAccessibilityEvent(obj, event);
- }
-}
-
-void RenderViewImpl::didUpdateInspectorSetting(const WebString& key,
- const WebString& value) {
- Send(new ViewHostMsg_UpdateInspectorSetting(routing_id_,
- key.utf8(),
- value.utf8()));
-}
-
// blink::WebWidgetClient ----------------------------------------------------
void RenderViewImpl::didFocus() {
DCHECK(opener_id_ != MSG_ROUTING_NONE);
- // Force new windows to a popup if they were not opened with a user gesture.
- if (!opened_by_user_gesture_) {
- // We exempt background tabs for compat with older versions of Chrome.
- // TODO(darin): This seems bogus. These should have a user gesture, so
- // we probably don't need this check.
- if (policy != blink::WebNavigationPolicyNewBackgroundTab)
- policy = blink::WebNavigationPolicyNewPopup;
- }
-
// NOTE: initial_pos_ may still have its default values at this point, but
// that's okay. It'll be ignored if disposition is not NEW_POPUP, or the
// browser process will impose a default position otherwise.
webwidget_mouse_lock_target_.get());
}
-// FIXME: To be removed as soon as chromium and blink side changes land
-// didActivateCompositor with parameters is still kept in order to land
-// these changes s-chromium - https://codereview.chromium.org/137893025/.
-// s-blink - https://codereview.chromium.org/138523003/
-void RenderViewImpl::didActivateCompositor(int input_handler_identifier) {
-#if !defined(OS_MACOSX) // many events are unhandled - http://crbug.com/138003
- InputHandlerManager* input_handler_manager =
- RenderThreadImpl::current()->input_handler_manager();
- if (input_handler_manager) {
- input_handler_manager->AddInputHandler(
- routing_id_,
- compositor_->GetInputHandler(),
- AsWeakPtr());
- }
-#endif
-
- RenderWidget::didActivateCompositor(input_handler_identifier);
-}
-
-void RenderViewImpl::didActivateCompositor() {
-#if !defined(OS_MACOSX) // many events are unhandled - http://crbug.com/138003
- InputHandlerManager* input_handler_manager =
- RenderThreadImpl::current()->input_handler_manager();
- if (input_handler_manager) {
- input_handler_manager->AddInputHandler(
- routing_id_,
- compositor_->GetInputHandler(),
- AsWeakPtr());
- }
-#endif
-
- RenderWidget::didActivateCompositor();
-}
-
void RenderViewImpl::didHandleGestureEvent(
const WebGestureEvent& event,
bool event_cancelled) {
RenderWidget::didHandleGestureEvent(event, event_cancelled);
+ if (!event_cancelled) {
+ FOR_EACH_OBSERVER(
+ RenderViewObserver, observers_, DidHandleGestureEvent(event));
+ }
+
if (event.type != blink::WebGestureEvent::GestureTap)
return;
+ // TODO(estade): hit test the event against focused node to make sure
+ // the tap actually hit the focused node.
blink::WebTextInputType text_input_type =
GetWebView()->textInputInfo().type;
void RenderViewImpl::initializeLayerTreeView() {
RenderWidget::initializeLayerTreeView();
RenderWidgetCompositor* rwc = compositor();
- if (!rwc || !webview() || !webview()->devToolsAgent())
+ if (!rwc)
return;
- webview()->devToolsAgent()->setLayerTreeId(rwc->GetLayerTreeId());
-}
-
-// blink::WebFrameClient -----------------------------------------------------
-
-WebMediaPlayer* RenderViewImpl::createMediaPlayer(
- WebFrame* frame, const blink::WebURL& url, WebMediaPlayerClient* client) {
- NOTREACHED();
- return NULL;
-}
-
-blink::WebMediaPlayer* RenderViewImpl::CreateMediaPlayer(
- RenderFrame* render_frame,
- blink::WebFrame* frame,
- const blink::WebURL& url,
- blink::WebMediaPlayerClient* client) {
- FOR_EACH_OBSERVER(
- RenderViewObserver, observers_, WillCreateMediaPlayer(frame, client));
-
- WebMediaPlayer* player = CreateWebMediaPlayerForMediaStream(frame, url,
- client);
- if (player)
- return player;
-
-#if defined(OS_ANDROID)
- return CreateAndroidWebMediaPlayer(frame, url, client);
-#else
- WebMediaPlayerParams params(
- base::Bind(&ContentRendererClient::DeferMediaLoad,
- base::Unretained(GetContentClient()->renderer()),
- static_cast<RenderFrame*>(render_frame)),
- RenderThreadImpl::current()->GetAudioRendererMixerManager()->CreateInput(
- routing_id_, render_frame->GetRoutingID()));
- return new WebMediaPlayerImpl(frame, client, AsWeakPtr(), params);
-#endif // defined(OS_ANDROID)
-}
-
-void RenderViewImpl::didAccessInitialDocument(WebFrame* frame) {
- // Notify the browser process that it is no longer safe to show the pending
- // URL of the main frame, since a URL spoof is now possible.
- if (!frame->parent() && page_id_ == -1)
- Send(new ViewHostMsg_DidAccessInitialDocument(routing_id_));
-}
-
-void RenderViewImpl::didDisownOpener(blink::WebFrame* frame) {
- // We only need to notify the browser if the active, top-level frame clears
- // its opener. We can ignore cases where a swapped out frame clears its
- // opener after hearing about it from the browser, and the browser does not
- // (yet) care about subframe openers.
- if (is_swapped_out_ || frame->parent())
- return;
-
- // Notify WebContents and all its swapped out RenderViews.
- Send(new ViewHostMsg_DidDisownOpener(routing_id_));
-}
-
-void RenderViewImpl::frameDetached(WebFrame* frame) {
- // NOTE: We may get here for either the main frame or for subframes. The
- // RenderFrameImpl will be deleted immediately after this call for subframes
- // but not for the main frame, which is owned by |main_render_frame_|.
-
- FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameDetached(frame));
-}
+ if (webview() && webview()->devToolsAgent())
+ webview()->devToolsAgent()->setLayerTreeId(rwc->GetLayerTreeId());
-void RenderViewImpl::willClose(WebFrame* frame) {
- FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameWillClose(frame));
+#if !defined(OS_MACOSX) // many events are unhandled - http://crbug.com/138003
+ RenderThreadImpl* render_thread = RenderThreadImpl::current();
+ // render_thread may be NULL in tests.
+ InputHandlerManager* input_handler_manager =
+ render_thread ? render_thread->input_handler_manager() : NULL;
+ if (input_handler_manager) {
+ input_handler_manager->AddInputHandler(
+ routing_id_, rwc->GetInputHandler(), AsWeakPtr());
+ }
+#endif
}
-void RenderViewImpl::didMatchCSS(
- WebFrame* frame,
- const WebVector<WebString>& newly_matching_selectors,
- const WebVector<WebString>& stopped_matching_selectors) {
- FOR_EACH_OBSERVER(
- RenderViewObserver, observers_,
- DidMatchCSS(frame, newly_matching_selectors, stopped_matching_selectors));
-}
+// blink::WebFrameClient -----------------------------------------------------
void RenderViewImpl::Repaint(const gfx::Size& size) {
OnRepaint(size);
return renderer_preferences_.accept_languages;
}
-void RenderViewImpl::willSendSubmitEvent(blink::WebFrame* frame,
- const blink::WebFormElement& form) {
- FOR_EACH_OBSERVER(
- RenderViewObserver, observers_, WillSendSubmitEvent(frame, form));
-}
-
-void RenderViewImpl::willSubmitForm(WebFrame* frame,
- const WebFormElement& form) {
- FOR_EACH_OBSERVER(
- RenderViewObserver, observers_, WillSubmitForm(frame, form));
-}
-
-void RenderViewImpl::didCreateDataSource(WebFrame* frame, WebDataSource* ds) {
+void RenderViewImpl::didCreateDataSource(WebLocalFrame* frame,
+ WebDataSource* ds) {
bool content_initiated = !pending_navigation_params_.get();
// Make sure any previous redirect URLs end up in our new data source.
// Carry over the user agent override flag, if it exists.
if (content_initiated && webview() && webview()->mainFrame() &&
+ webview()->mainFrame()->isWebLocalFrame() &&
webview()->mainFrame()->dataSource()) {
DocumentState* old_document_state =
DocumentState::FromDataSource(webview()->mainFrame()->dataSource());
const WebURLRequest& original_request = ds->originalRequest();
const GURL referrer(
original_request.httpHeaderField(WebString::fromUTF8("Referer")));
- if (!referrer.is_empty() &&
- DocumentState::FromDataSource(
- old_frame->dataSource())->was_prefetcher()) {
+ if (!referrer.is_empty() && old_frame->isWebLocalFrame() &&
+ DocumentState::FromDataSource(old_frame->dataSource())
+ ->was_prefetcher()) {
for (; old_frame; old_frame = old_frame->traverseNext(false)) {
WebDataSource* old_frame_ds = old_frame->dataSource();
if (old_frame_ds && referrer == GURL(old_frame_ds->request().url())) {
document_state->set_load_type(DocumentState::LINK_LOAD_NORMAL);
break;
case WebURLRequest::ReloadIgnoringCacheData: // reload.
+ case WebURLRequest::ReloadBypassingCache: // end-to-end reload.
document_state->set_load_type(DocumentState::LINK_LOAD_RELOAD);
break;
case WebURLRequest::ReturnCacheDataElseLoad: // allow stale data.
case WebURLRequest::ReturnCacheDataDontLoad: // Don't re-post.
document_state->set_load_type(DocumentState::LINK_LOAD_CACHE_ONLY);
break;
+ default:
+ NOTREACHED();
}
}
InternalDocumentStateData* internal_data =
InternalDocumentStateData::FromDocumentState(document_state);
- if (!params.url.SchemeIs(kJavaScriptScheme) &&
+ if (!params.url.SchemeIs(url::kJavaScriptScheme) &&
params.navigation_type == FrameMsg_Navigate_Type::RESTORE) {
// We're doing a load of a page that was restored from the last session. By
// default this prefers the cache over loading (LOAD_PREFERRING_CACHE) which
// A navigation resulting from loading a javascript URL should not be treated
// as a browser initiated event. Instead, we want it to look as if the page
// initiated any load resulting from JS execution.
- if (!params.url.SchemeIs(kJavaScriptScheme)) {
+ if (!params.url.SchemeIs(url::kJavaScriptScheme)) {
navigation_state = NavigationState::CreateBrowserInitiated(
params.page_id,
params.pending_history_list_offset,
webview()->setPageScaleFactorLimits(1, maxPageScaleFactor);
}
-// TODO(nasko): Remove this method once WebTestProxy in Blink is fixed.
-void RenderViewImpl::didStartProvisionalLoad(WebFrame* frame) {
-}
-
-void RenderViewImpl::didFailProvisionalLoad(WebFrame* frame,
- const WebURLError& error) {
- // Notify the browser that we failed a provisional load with an error.
- //
- // Note: It is important this notification occur before DidStopLoading so the
- // SSL manager can react to the provisional load failure before being
- // notified the load stopped.
- //
- FOR_EACH_OBSERVER(
- RenderViewObserver, observers_, DidFailProvisionalLoad(frame, error));
-}
-
-void RenderViewImpl::didCommitProvisionalLoad(WebFrame* frame,
- bool is_new_navigation) {
- FOR_EACH_OBSERVER(RenderViewObserver, observers_,
- DidCommitProvisionalLoad(frame, is_new_navigation));
-
- // TODO(nasko): Transition this code to RenderFrameImpl, since g_view_map is
- // not accessible from there.
- if (!frame->parent()) { // Only for top frames.
- RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
- if (render_thread_impl) { // Can be NULL in tests.
- render_thread_impl->histogram_customizer()->
- RenderViewNavigatedToHost(GURL(GetLoadingUrl(frame)).host(),
- g_view_map.Get().size());
- }
- }
-}
-
-void RenderViewImpl::didClearWindowObject(WebFrame* frame, int world_id) {
- FOR_EACH_OBSERVER(RenderViewObserver, observers_,
- DidClearWindowObject(frame, world_id));
-
- // Only install controllers into the main world.
- if (world_id)
- return;
-
- if (enabled_bindings_& BINDINGS_POLICY_WEB_UI)
- WebUIExtension::Install(frame);
-
- if (enabled_bindings_ & BINDINGS_POLICY_STATS_COLLECTION)
- StatsCollectionController::Install(frame);
-
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-
- if (command_line.HasSwitch(switches::kEnableSkiaBenchmarking))
- SkiaBenchmarking::Install(frame);
-
- if (command_line.HasSwitch(switches::kEnableMemoryBenchmarking))
- MemoryBenchmarkingExtension::Install(frame);
-}
-
-void RenderViewImpl::didCreateDocumentElement(WebFrame* frame) {
- FOR_EACH_OBSERVER(RenderViewObserver, observers_,
- DidCreateDocumentElement(frame));
-}
-
-void RenderViewImpl::didReceiveTitle(WebFrame* frame, const WebString& title,
- WebTextDirection direction) {
- UpdateTitle(frame, title, direction);
-
- // Also check whether we have new encoding name.
- UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
-}
-
-void RenderViewImpl::didChangeIcon(WebFrame* frame,
- WebIconURL::Type icon_type) {
- if (frame->parent())
- return;
-
- if (!TouchEnabled() && icon_type != WebIconURL::TypeFavicon)
- return;
-
- WebVector<WebIconURL> icon_urls = frame->iconURLs(icon_type);
- std::vector<FaviconURL> urls;
- for (size_t i = 0; i < icon_urls.size(); i++) {
- std::vector<gfx::Size> sizes(icon_urls[i].sizes().size());
- ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
- urls.push_back(FaviconURL(
- icon_urls[i].iconURL(), ToFaviconType(icon_urls[i].iconType()), sizes));
- }
- SendUpdateFaviconURL(urls);
-}
-
-void RenderViewImpl::didFinishDocumentLoad(WebFrame* frame) {
- FOR_EACH_OBSERVER(RenderViewObserver, observers_,
- DidFinishDocumentLoad(frame));
-}
-
-void RenderViewImpl::didHandleOnloadEvents(WebFrame* frame) {
- if (webview()->mainFrame() == frame) {
- Send(new ViewHostMsg_DocumentOnLoadCompletedInMainFrame(routing_id_,
- page_id_));
- }
-}
-
-void RenderViewImpl::didFailLoad(WebFrame* frame, const WebURLError& error) {
- FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFailLoad(frame, error));
-}
-
-void RenderViewImpl::didFinishLoad(WebFrame* frame) {
- FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFinishLoad(frame));
-}
-
-void RenderViewImpl::didNavigateWithinPage(
- WebFrame* frame,
- bool is_new_navigation) {
- // TODO(nasko): Forward calls to the main RenderFrameImpl until all
- // callers of this method on RenderView are removed.
- main_render_frame_->didNavigateWithinPage(frame, is_new_navigation);
-}
-
-void RenderViewImpl::didUpdateCurrentHistoryItem(WebFrame* frame) {
- StartNavStateSyncTimerIfNecessary();
-}
-
-void RenderViewImpl::willSendRequest(WebFrame* frame,
- unsigned identifier,
- WebURLRequest& request,
- const WebURLResponse& redirect_response) {
- NOTREACHED();
-}
+void RenderViewImpl::didClearWindowObject(WebLocalFrame* frame) {
+ FOR_EACH_OBSERVER(
+ RenderViewObserver, observers_, DidClearWindowObject(frame));
-void RenderViewImpl::didReceiveResponse(
- WebFrame* frame, unsigned identifier, const WebURLResponse& response) {
- NOTREACHED();
-}
+ if (enabled_bindings_& BINDINGS_POLICY_WEB_UI)
+ WebUIExtension::Install(frame);
-void RenderViewImpl::didFinishResourceLoad(
- WebFrame* frame, unsigned identifier) {
- InternalDocumentStateData* internal_data =
- InternalDocumentStateData::FromDataSource(frame->dataSource());
- if (!internal_data->use_error_page())
- return;
+ if (enabled_bindings_ & BINDINGS_POLICY_STATS_COLLECTION)
+ StatsCollectionController::Install(frame);
- // Do not show error page when DevTools is attached.
- if (devtools_agent_->IsAttached())
- return;
+ const CommandLine& command_line = *CommandLine::ForCurrentProcess();
- // Display error page, if appropriate.
- std::string error_domain = "http";
- int http_status_code = internal_data->http_status_code();
- if (GetContentClient()->renderer()->HasErrorPage(
- http_status_code, &error_domain)) {
- WebURLError error;
- error.unreachableURL = frame->document().url();
- error.domain = WebString::fromUTF8(error_domain);
- error.reason = http_status_code;
- LoadNavigationErrorPage(frame, frame->dataSource()->request(), error, true);
- }
-}
+ if (command_line.HasSwitch(switches::kEnableSkiaBenchmarking))
+ SkiaBenchmarking::Install(frame);
-void RenderViewImpl::didLoadResourceFromMemoryCache(
- WebFrame* frame, const WebURLRequest& request,
- const WebURLResponse& response) {
- NOTREACHED();
+ if (command_line.HasSwitch(switches::kEnableMemoryBenchmarking))
+ MemoryBenchmarkingExtension::Install(frame);
}
-void RenderViewImpl::didDisplayInsecureContent(WebFrame* frame) {
- NOTREACHED();
-}
+void RenderViewImpl::didChangeIcon(WebLocalFrame* frame,
+ WebIconURL::Type icon_type) {
+ if (frame->parent())
+ return;
-void RenderViewImpl::didRunInsecureContent(
- WebFrame* frame, const WebSecurityOrigin& origin, const WebURL& target) {
- NOTREACHED();
-}
+ if (!TouchEnabled() && icon_type != WebIconURL::TypeFavicon)
+ return;
-void RenderViewImpl::didCreateScriptContext(WebFrame* frame,
- v8::Handle<v8::Context> context,
- int extension_group,
- int world_id) {
- NOTREACHED();
+ WebVector<WebIconURL> icon_urls = frame->iconURLs(icon_type);
+ std::vector<FaviconURL> urls;
+ for (size_t i = 0; i < icon_urls.size(); i++) {
+ std::vector<gfx::Size> sizes;
+ ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
+ urls.push_back(FaviconURL(
+ icon_urls[i].iconURL(), ToFaviconType(icon_urls[i].iconType()), sizes));
+ }
+ SendUpdateFaviconURL(urls);
}
-void RenderViewImpl::willReleaseScriptContext(WebFrame* frame,
- v8::Handle<v8::Context> context,
- int world_id) {
- NOTREACHED();
+void RenderViewImpl::didUpdateCurrentHistoryItem(WebLocalFrame* frame) {
+ StartNavStateSyncTimerIfNecessary();
}
void RenderViewImpl::CheckPreferredSize() {
return browser_plugin_manager_.get();
}
-bool RenderViewImpl::InitializeMediaStreamClient() {
- if (media_stream_client_)
- return true;
-
- if (!RenderThreadImpl::current()) // Will be NULL during unit tests.
- return false;
-
-#if defined(OS_ANDROID)
- if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableWebRTC))
- return false;
-#endif
-
-#if defined(ENABLE_WEBRTC)
- if (!media_stream_dispatcher_)
- media_stream_dispatcher_ = new MediaStreamDispatcher(this);
-
- MediaStreamImpl* media_stream_impl = new MediaStreamImpl(
- this,
- media_stream_dispatcher_,
- RenderThreadImpl::current()->GetMediaStreamDependencyFactory());
- media_stream_client_ = media_stream_impl;
- web_user_media_client_ = media_stream_impl;
- return true;
-#else
- return false;
-#endif
-}
-
-void RenderViewImpl::didChangeContentsSize(WebFrame* frame,
- const WebSize& size) {
- if (webview()->mainFrame() != frame)
- return;
- WebView* frameView = frame->view();
- if (!frameView)
- return;
-
- bool has_horizontal_scrollbar = frame->hasHorizontalScrollbar();
- bool has_vertical_scrollbar = frame->hasVerticalScrollbar();
-
- if (has_horizontal_scrollbar != cached_has_main_frame_horizontal_scrollbar_ ||
- has_vertical_scrollbar != cached_has_main_frame_vertical_scrollbar_) {
- Send(new ViewHostMsg_DidChangeScrollbarsForMainFrame(
- routing_id_, has_horizontal_scrollbar, has_vertical_scrollbar));
-
- cached_has_main_frame_horizontal_scrollbar_ = has_horizontal_scrollbar;
- cached_has_main_frame_vertical_scrollbar_ = has_vertical_scrollbar;
- }
-}
-
-void RenderViewImpl::UpdateScrollState(WebFrame* frame) {
- WebSize offset = frame->scrollOffset();
- WebSize minimum_offset = frame->minimumScrollOffset();
- WebSize maximum_offset = frame->maximumScrollOffset();
-
- bool is_pinned_to_left = offset.width <= minimum_offset.width;
- bool is_pinned_to_right = offset.width >= maximum_offset.width;
-
- if (is_pinned_to_left != cached_is_main_frame_pinned_to_left_ ||
- is_pinned_to_right != cached_is_main_frame_pinned_to_right_) {
- Send(new ViewHostMsg_DidChangeScrollOffsetPinningForMainFrame(
- routing_id_, is_pinned_to_left, is_pinned_to_right));
-
- cached_is_main_frame_pinned_to_left_ = is_pinned_to_left;
- cached_is_main_frame_pinned_to_right_ = is_pinned_to_right;
- }
-
- Send(new ViewHostMsg_DidChangeScrollOffset(routing_id_));
-}
-
-void RenderViewImpl::didChangeScrollOffset(WebFrame* frame) {
+void RenderViewImpl::didChangeScrollOffset(WebLocalFrame* frame) {
StartNavStateSyncTimerIfNecessary();
- if (webview()->mainFrame() == frame)
- UpdateScrollState(frame);
-
FOR_EACH_OBSERVER(
RenderViewObserver, observers_, DidChangeScrollOffset(frame));
}
-void RenderViewImpl::willInsertBody(blink::WebFrame* frame) {
- NOTREACHED();
-}
-
-void RenderViewImpl::didFirstVisuallyNonEmptyLayout(WebFrame* frame) {
- if (frame != webview()->mainFrame())
- return;
-
- InternalDocumentStateData* data =
- InternalDocumentStateData::FromDataSource(frame->dataSource());
- data->set_did_first_visually_non_empty_layout(true);
-
-#if defined(OS_ANDROID)
- // Update body background color if necessary.
- SkColor bg_color = webwidget_->backgroundColor();
-
- // If not initialized, default to white. Note that 0 is different from black
- // as black still has alpha 0xFF.
- if (!bg_color)
- bg_color = SK_ColorWHITE;
-
- if (bg_color != body_background_color_) {
- body_background_color_ = bg_color;
- Send(new ViewHostMsg_DidChangeBodyBackgroundColor(
- GetRoutingID(), bg_color));
- }
-#endif
-}
-
void RenderViewImpl::SendFindReply(int request_id,
int match_count,
int ordinal,
final_status_update));
}
-void RenderViewImpl::reportFindInPageMatchCount(int request_id,
- int count,
- bool final_update) {
- NOTREACHED();
-}
-
-void RenderViewImpl::reportFindInPageSelection(int request_id,
- int active_match_ordinal,
- const WebRect& selection_rect) {
- NOTREACHED();
-}
-
-void RenderViewImpl::requestStorageQuota(
- WebFrame* frame,
- WebStorageQuotaType type,
- unsigned long long requested_size,
- blink::WebStorageQuotaCallbacks callbacks) {
- NOTREACHED();
-}
-
-bool RenderViewImpl::willCheckAndDispatchMessageEvent(
- blink::WebFrame* sourceFrame,
- blink::WebFrame* targetFrame,
- blink::WebSecurityOrigin target_origin,
- blink::WebDOMMessageEvent event) {
- if (!is_swapped_out_)
- return false;
-
- ViewMsg_PostMessage_Params params;
- params.data = event.data().toString();
- params.source_origin = event.origin();
- if (!target_origin.isNull())
- params.target_origin = target_origin.toString();
-
- blink::WebMessagePortChannelArray channels = event.releaseChannels();
- if (!channels.isEmpty()) {
- std::vector<int> message_port_ids(channels.size());
- // Extract the port IDs from the channel array.
- for (size_t i = 0; i < channels.size(); ++i) {
- WebMessagePortChannelImpl* webchannel =
- static_cast<WebMessagePortChannelImpl*>(channels[i]);
- message_port_ids[i] = webchannel->message_port_id();
- webchannel->QueueMessages();
- DCHECK_NE(message_port_ids[i], MSG_ROUTING_NONE);
- }
- params.message_port_ids = message_port_ids;
- }
-
- // Include the routing ID for the source frame (if one exists), which the
- // browser process will translate into the routing ID for the equivalent
- // frame in the target process.
- params.source_routing_id = MSG_ROUTING_NONE;
- if (sourceFrame) {
- RenderViewImpl* source_view = FromWebView(sourceFrame->view());
- if (source_view)
- params.source_routing_id = source_view->routing_id();
- }
-
- Send(new ViewHostMsg_RouteMessageEvent(routing_id_, params));
- return true;
-}
-
-void RenderViewImpl::willOpenSocketStream(
- WebSocketStreamHandle* handle) {
- NOTREACHED();
-}
-
-void RenderViewImpl::willStartUsingPeerConnectionHandler(
- blink::WebFrame* frame, blink::WebRTCPeerConnectionHandler* handler) {
- NOTREACHED();
-}
-
blink::WebString RenderViewImpl::acceptLanguages() {
return WebString::fromUTF8(renderer_preferences_.accept_languages);
}
-blink::WebString RenderViewImpl::userAgentOverride(
- blink::WebFrame* frame,
- const blink::WebURL& url) {
- NOTREACHED();
- return blink::WebString();
-}
-
-WebString RenderViewImpl::doNotTrackValue(WebFrame* frame) {
- NOTREACHED();
- return blink::WebString();
-}
-
-bool RenderViewImpl::allowWebGL(WebFrame* frame, bool default_value) {
- NOTREACHED();
- return false;
-}
-
-void RenderViewImpl::didLoseWebGLContext(
- blink::WebFrame* frame,
- int arb_robustness_status_code) {
- NOTREACHED();
-}
-
// blink::WebPageSerializerClient implementation ------------------------------
void RenderViewImpl::didSerializeDataForFrame(
return RenderWidget::Send(message);
}
-RenderFrame* RenderViewImpl::GetMainRenderFrame() {
+RenderFrameImpl* RenderViewImpl::GetMainRenderFrame() {
return main_render_frame_.get();
}
return routing_id_;
}
-int RenderViewImpl::GetPageId() const {
- return page_id_;
-}
-
gfx::Size RenderViewImpl::GetSize() const {
return size();
}
return false;
}
-void RenderViewImpl::EvaluateScript(const base::string16& frame_xpath,
- const base::string16& jscript,
- int id,
- bool notify_result) {
- v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
- v8::Handle<v8::Value> result;
-
- WebFrame* web_frame;
- if (frame_xpath.empty()) {
- web_frame = webview()->mainFrame();
- } else {
- // The |frame_xpath| string can represent a frame deep down the tree (across
- // multiple frame DOMs).
- //
- // For example,
- // /html/body/table/tbody/tr/td/iframe\n/frameset/frame[0]
- // should break into 2 xpaths:
- // /html/body/table/tbody/tr/td/iframe
- // /frameset/frame[0]
- std::vector<base::string16> xpaths;
- base::SplitString(frame_xpath, '\n', &xpaths);
-
- WebFrame* frame = webview()->mainFrame();
- for (std::vector<base::string16>::const_iterator i = xpaths.begin();
- frame && i != xpaths.end(); ++i) {
- frame = frame->findChildByExpression(*i);
- }
-
- web_frame = frame;
- }
-
- if (web_frame)
- result = web_frame->executeScriptAndReturnValue(WebScriptSource(jscript));
- if (notify_result) {
- base::ListValue list;
- if (!result.IsEmpty() && web_frame) {
- v8::Local<v8::Context> context = web_frame->mainWorldScriptContext();
- v8::Context::Scope context_scope(context);
- V8ValueConverterImpl converter;
- converter.SetDateAllowed(true);
- converter.SetRegExpAllowed(true);
- base::Value* result_value = converter.FromV8Value(result, context);
- list.Set(0, result_value ? result_value : base::Value::CreateNullValue());
- } else {
- list.Set(0, base::Value::CreateNullValue());
- }
- Send(new ViewHostMsg_ScriptEvalResponse(routing_id_, id, list));
- }
+bool RenderViewImpl::NodeContainsPoint(const WebNode& node,
+ const gfx::Point& point) const {
+ blink::WebHitTestResult hit_test =
+ webview()->hitTestResultAt(WebPoint(point.x(), point.y()));
+ return node.containsIncludingShadowDOM(hit_test.node());
}
bool RenderViewImpl::ShouldDisplayScrollbars(int width, int height) const {
return send_content_state_immediately_;
}
-float RenderViewImpl::GetFilteredTimePerFrame() const {
- return filtered_time_per_frame();
-}
-
blink::WebPageVisibilityState RenderViewImpl::GetVisibilityState() const {
return visibilityState();
}
-void RenderViewImpl::RunModalAlertDialog(blink::WebFrame* frame,
- const blink::WebString& message) {
- return runModalAlertDialog(frame, message);
-}
-
void RenderViewImpl::DidStartLoading() {
main_render_frame_->didStartLoading(true);
}
main_render_frame_->didStopLoading();
}
-void RenderViewImpl::DidPlay(blink::WebMediaPlayer* player) {
- Send(new ViewHostMsg_MediaPlayingNotification(routing_id_,
- reinterpret_cast<int64>(player),
- player->hasVideo(),
- player->hasAudio()));
-}
-
-void RenderViewImpl::DidPause(blink::WebMediaPlayer* player) {
- Send(new ViewHostMsg_MediaPausedNotification(
- routing_id_, reinterpret_cast<int64>(player)));
-}
-
-void RenderViewImpl::PlayerGone(blink::WebMediaPlayer* player) {
- DidPause(player);
-}
-
void RenderViewImpl::SyncNavigationState() {
if (!webview())
return;
-
- const WebHistoryItem& item = webview()->mainFrame()->currentHistoryItem();
- SendUpdateState(item);
-}
-
-GURL RenderViewImpl::GetLoadingUrl(blink::WebFrame* frame) const {
- WebDataSource* ds = frame->dataSource();
- if (ds->hasUnreachableURL())
- return ds->unreachableURL();
-
- const WebURLRequest& request = ds->request();
- return request.url();
+ SendUpdateState(history_controller_->GetCurrentEntry());
}
blink::WebPlugin* RenderViewImpl::GetWebPluginForFind() {
return NULL;
WebFrame* main_frame = webview()->mainFrame();
- if (main_frame->document().isPluginDocument())
+ if (main_frame->isWebLocalFrame() &&
+ main_frame->document().isPluginDocument())
return webview()->mainFrame()->document().to<WebPluginDocument>().plugin();
#if defined(ENABLE_PLUGINS)
zoomLevelChanged();
}
-void RenderViewImpl::OnSetZoomLevel(double zoom_level) {
- webview()->hidePopups();
- webview()->setZoomLevel(zoom_level);
- zoomLevelChanged();
-}
-
void RenderViewImpl::OnSetZoomLevelForLoadingURL(const GURL& url,
double zoom_level) {
#if !defined(OS_ANDROID)
#endif
}
+void RenderViewImpl::OnSetZoomLevelForView(bool uses_temporary_zoom_level,
+ double level) {
+ uses_temporary_zoom_level_ = uses_temporary_zoom_level;
+
+ webview()->hidePopups();
+ webview()->setZoomLevel(level);
+}
+
void RenderViewImpl::OnSetPageEncoding(const std::string& encoding_name) {
webview()->setPageEncoding(WebString::fromUTF8(encoding_name));
}
webview()->setPageEncoding(no_encoding);
}
-void RenderViewImpl::OnScriptEvalRequest(const base::string16& frame_xpath,
- const base::string16& jscript,
- int id,
- bool notify_result) {
- TRACE_EVENT_INSTANT0("test_tracing", "OnScriptEvalRequest",
- TRACE_EVENT_SCOPE_THREAD);
- EvaluateScript(frame_xpath, jscript, id, notify_result);
-}
-
void RenderViewImpl::OnPostMessageEvent(
const ViewMsg_PostMessage_Params& params) {
// TODO(nasko): Support sending to subframes.
base::MessageLoopProxy::current().get());
}
+ WebSerializedScriptValue serialized_script_value;
+ if (params.is_data_raw_string) {
+ v8::HandleScope handle_scope(blink::mainThreadIsolate());
+ v8::Local<v8::Context> context = frame->mainWorldScriptContext();
+ v8::Context::Scope context_scope(context);
+ V8ValueConverterImpl converter;
+ converter.SetDateAllowed(true);
+ converter.SetRegExpAllowed(true);
+ scoped_ptr<base::Value> value(new base::StringValue(params.data));
+ v8::Handle<v8::Value> result_value = converter.ToV8Value(value.get(),
+ context);
+ serialized_script_value = WebSerializedScriptValue::serialize(result_value);
+ } else {
+ serialized_script_value = WebSerializedScriptValue::fromString(params.data);
+ }
+
// Create an event with the message. The final parameter to initMessageEvent
// is the last event ID, which is not used with postMessage.
WebDOMEvent event = frame->document().createEvent("MessageEvent");
msg_event.initMessageEvent("message",
// |canBubble| and |cancellable| are always false
false, false,
- WebSerializedScriptValue::fromString(params.data),
+ serialized_script_value,
params.source_origin, source_frame, "", channels);
// We must pass in the target_origin to do the security check on this side,
!(enabled_bindings_ & BINDINGS_POLICY_WEB_UI)) {
// WebUIExtensionData deletes itself when we're destroyed.
new WebUIExtensionData(this);
-#if defined(USE_MOJO)
// WebUIMojo deletes itself when we're destroyed.
new WebUIMojo(this);
-#endif
}
enabled_bindings_ |= enabled_bindings_flags;
Send(new DragHostMsg_TargetDrop_ACK(routing_id_));
}
-void RenderViewImpl::OnDragSourceEndedOrMoved(const gfx::Point& client_point,
- const gfx::Point& screen_point,
- bool ended,
- WebDragOperation op) {
- if (ended) {
- webview()->dragSourceEndedAt(client_point, screen_point, op);
- } else {
- webview()->dragSourceMovedTo(client_point, screen_point, op);
- }
+void RenderViewImpl::OnDragSourceEnded(const gfx::Point& client_point,
+ const gfx::Point& screen_point,
+ WebDragOperation op) {
+ webview()->dragSourceEndedAt(client_point, screen_point, op);
}
void RenderViewImpl::OnDragSourceSystemDragEnded() {
if (!new_size.IsEmpty()) {
Resize(new_size,
physical_backing_size_,
- overdraw_bottom_height_,
+ top_controls_layout_height_,
+ visible_viewport_size_,
resizer_rect_,
is_fullscreen_,
NO_RESIZE_ACK);
void RenderViewImpl::OnSetRendererPrefs(
const RendererPreferences& renderer_prefs) {
double old_zoom_level = renderer_preferences_.default_zoom_level;
+ std::string old_accept_languages = renderer_preferences_.accept_languages;
+
renderer_preferences_ = renderer_prefs;
UpdateFontRenderingFromRendererPrefs();
-#if defined(USE_DEFAULT_RENDER_THEME) || defined(TOOLKIT_GTK)
+#if defined(USE_DEFAULT_RENDER_THEME)
if (renderer_prefs.use_custom_colors) {
WebColorName name = blink::WebColorWebkitFocusRingColor;
blink::setNamedColors(&name, &renderer_prefs.focus_ring_color, 1);
blink::setCaretBlinkInterval(renderer_prefs.caret_blink_interval);
-#if defined(TOOLKIT_GTK)
- ui::NativeTheme::instance()->SetScrollbarColors(
- renderer_prefs.thumb_inactive_color,
- renderer_prefs.thumb_active_color,
- renderer_prefs.track_color);
-#endif // defined(TOOLKIT_GTK)
if (webview()) {
webview()->setSelectionColors(
webview()->themeChanged();
}
}
-#endif // defined(USE_DEFAULT_RENDER_THEME) || defined(TOOLKIT_GTK)
-
- if (RenderThreadImpl::current()) // Will be NULL during unit tests.
- RenderThreadImpl::current()->SetFlingCurveParameters(
- renderer_prefs.touchpad_fling_profile,
- renderer_prefs.touchscreen_fling_profile);
+#endif // defined(USE_DEFAULT_RENDER_THEME)
// If the zoom level for this page matches the old zoom default, and this
// is not a plugin, update the zoom level to match the new default.
- if (webview() && !webview()->mainFrame()->document().isPluginDocument() &&
+ if (webview() && webview()->mainFrame()->isWebLocalFrame() &&
+ !webview()->mainFrame()->document().isPluginDocument() &&
!ZoomValuesEqual(old_zoom_level,
renderer_preferences_.default_zoom_level) &&
ZoomValuesEqual(webview()->zoomLevel(), old_zoom_level)) {
webview()->setZoomLevel(renderer_preferences_.default_zoom_level);
zoomLevelChanged();
}
+
+ if (webview() &&
+ old_accept_languages != renderer_preferences_.accept_languages) {
+ webview()->acceptLanguagesChanged();
+ }
}
void RenderViewImpl::OnMediaPlayerActionAt(const gfx::Point& location,
webview()->performMediaPlayerAction(action, location);
}
-void RenderViewImpl::OnOrientationChangeEvent(int orientation) {
- // Screen has rotated. 0 = default (portrait), 90 = one turn right, and so on.
+void RenderViewImpl::OnOrientationChange() {
+ // TODO(mlamouri): consumers of that event should be using DisplayObserver.
FOR_EACH_OBSERVER(RenderViewObserver,
observers_,
- OrientationChangeEvent(orientation));
- webview()->mainFrame()->sendOrientationChangeEvent(orientation);
+ OrientationChangeEvent());
+
+ webview()->mainFrame()->toWebLocalFrame()->sendOrientationChangeEvent();
}
void RenderViewImpl::OnPluginActionAt(const gfx::Point& location,
for (size_t i = 0; i < local_paths.size(); i++)
webstring_paths[i] = local_paths[i].AsUTF16Unsafe();
- WebPageSerializer::serialize(webview()->mainFrame(), true, this, weburl_links,
+ WebPageSerializer::serialize(webview()->mainFrame()->toWebLocalFrame(),
+ true,
+ this,
+ weburl_links,
webstring_paths,
local_directory_name.AsUTF16Unsafe());
}
CHECK(is_swapped_out_ || rf->is_swapped_out());
GURL swappedOutURL(kSwappedOutURL);
WebURLRequest request(swappedOutURL);
- frame->loadRequest(request);
+ if (frame->isWebLocalFrame())
+ frame->loadRequest(request);
}
void RenderViewImpl::OnClosePage() {
// revisited to avoid having two ways to close a page. Having a single way
// to close that can run onunload is also useful for fixing
// http://b/issue?id=753080.
- webview()->dispatchUnloadEvent();
+ webview()->mainFrame()->dispatchUnloadEvent();
Send(new ViewHostMsg_ClosePage_ACK(routing_id_));
}
}
void RenderViewImpl::OnResize(const ViewMsg_Resize_Params& params) {
+ TRACE_EVENT0("renderer", "RenderViewImpl::OnResize");
if (webview()) {
webview()->hidePopups();
if (send_preferred_size_changes_) {
ShouldDisplayScrollbars(params.new_size.width(),
params.new_size.height()));
}
- UpdateScrollState(webview()->mainFrame());
}
+ gfx::Size old_visible_viewport_size = visible_viewport_size_;
+
RenderWidget::OnResize(params);
+
+ if (old_visible_viewport_size != visible_viewport_size_)
+ has_scrolled_focused_editable_node_into_rect_ = false;
+
+ FOR_EACH_OBSERVER(RenderViewObserver,
+ observers_,
+ Resized());
}
void RenderViewImpl::DidInitiatePaint() {
return;
WebFrame* main_frame = webview()->mainFrame();
+ for (WebFrame* frame = main_frame; frame;
+ frame = frame->traverseNext(false)) {
+ if (frame->isWebLocalFrame())
+ main_frame = frame;
+ }
// If we have a provisional frame we are between the start and commit stages
// of loading and we don't want to save stats.
if (!main_frame->provisionalDataSource()) {
WebDataSource* ds = main_frame->dataSource();
DocumentState* document_state = DocumentState::FromDataSource(ds);
- InternalDocumentStateData* data =
- InternalDocumentStateData::FromDocumentState(document_state);
- if (data->did_first_visually_non_empty_layout() &&
- !data->did_first_visually_non_empty_paint()) {
- data->set_did_first_visually_non_empty_paint(true);
- Send(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_,
- page_id_));
- }
// TODO(jar): The following code should all be inside a method, probably in
// NavigatorState.
}
}
-PepperPluginInstanceImpl* RenderViewImpl::GetBitmapForOptimizedPluginPaint(
- const gfx::Rect& paint_bounds,
- TransportDIB** dib,
- gfx::Rect* location,
- gfx::Rect* clip,
- float* scale_factor) {
-#if defined(ENABLE_PLUGINS)
- for (PepperPluginSet::iterator i = active_pepper_instances_.begin();
- i != active_pepper_instances_.end(); ++i) {
- PepperPluginInstanceImpl* instance = *i;
- // In Flash fullscreen , the plugin contents should be painted onto the
- // fullscreen widget instead of the web page.
- if (!instance->FlashIsFullscreenOrPending() &&
- instance->GetBitmapForOptimizedPluginPaint(paint_bounds, dib, location,
- clip, scale_factor))
- return *i;
+gfx::Vector2d RenderViewImpl::GetScrollOffset() {
+ WebFrame* main_frame = webview()->mainFrame();
+ for (WebFrame* frame = main_frame; frame;
+ frame = frame->traverseNext(false)) {
+ // TODO(nasko): This is a hack for the case in which the top-level
+ // frame is being rendered in another process. It will not
+ // behave correctly for out of process iframes.
+ if (frame->isWebLocalFrame()) {
+ main_frame = frame;
+ break;
+ }
}
-#endif
- return NULL;
-}
-gfx::Vector2d RenderViewImpl::GetScrollOffset() {
- WebSize scroll_offset = webview()->mainFrame()->scrollOffset();
+ WebSize scroll_offset = main_frame->scrollOffset();
return gfx::Vector2d(scroll_offset.width, scroll_offset.height);
}
webview()->clearFocusedElement();
}
-void RenderViewImpl::OnSetBackground(const SkBitmap& background) {
+void RenderViewImpl::OnSetBackgroundOpaque(bool opaque) {
if (webview())
- webview()->setIsTransparent(!background.empty());
+ webview()->setIsTransparent(!opaque);
if (compositor_)
- compositor_->setHasTransparentBackground(!background.empty());
-
- SetBackground(background);
-}
-
-void RenderViewImpl::OnSetAccessibilityMode(AccessibilityMode new_mode) {
- if (accessibility_mode_ == new_mode)
- return;
- accessibility_mode_ = new_mode;
- if (renderer_accessibility_) {
- delete renderer_accessibility_;
- renderer_accessibility_ = NULL;
- }
- if (accessibility_mode_ == AccessibilityModeOff)
- return;
-
- if (accessibility_mode_ & AccessibilityModeFlagFullTree)
- renderer_accessibility_ = new RendererAccessibilityComplete(this);
-#if !defined(OS_ANDROID)
- else
- renderer_accessibility_ = new RendererAccessibilityFocusOnly(this);
-#endif
+ compositor_->setHasTransparentBackground(!opaque);
}
void RenderViewImpl::OnSetActive(bool active) {
}
#endif // OS_MACOSX
+void RenderViewImpl::OnClose() {
+ if (closing_)
+ RenderThread::Get()->Send(new ViewHostMsg_Close_ACK(routing_id_));
+ RenderWidget::OnClose();
+}
+
void RenderViewImpl::Close() {
// We need to grab a pointer to the doomed WebView before we destroy it.
WebView* doomed = webview();
RenderWidget::Close();
g_view_map.Get().erase(doomed);
g_routing_id_view_map.Get().erase(routing_id_);
+ RenderThread::Get()->Send(new ViewHostMsg_Close_ACK(routing_id_));
}
void RenderViewImpl::DidHandleKeyEvent() {
ClearEditCommands();
}
-void RenderViewImpl::WillProcessUserGesture() {
- FOR_EACH_OBSERVER(
- RenderViewObserver, observers_, WillProcessUserGesture());
-}
-
bool RenderViewImpl::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
possible_drag_event_info_.event_source =
ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
#if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
RenderThreadImpl::current()->video_capture_impl_manager()->
SuspendDevices(true);
+ if (speech_recognition_dispatcher_)
+ speech_recognition_dispatcher_->AbortAllRecognitions();
#endif
if (webview())
#endif // ENABLE_PLUGINS
}
-void RenderViewImpl::OnWasShown(bool needs_repainting) {
- RenderWidget::OnWasShown(needs_repainting);
+void RenderViewImpl::OnWasShown(bool needs_repainting,
+ const ui::LatencyInfo& latency_info) {
+ RenderWidget::OnWasShown(needs_repainting, latency_info);
#if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
RenderThreadImpl::current()->video_capture_impl_manager()->
GURL RenderViewImpl::GetURLForGraphicsContext3D() {
DCHECK(webview());
- if (webview()->mainFrame())
+ if (webview()->mainFrame()->isWebLocalFrame())
return GURL(webview()->mainFrame()->document().url());
else
return GURL("chrome://gpu/RenderViewImpl::CreateGraphicsContext3D");
}
-bool RenderViewImpl::ForceCompositingModeEnabled() {
- return webkit_preferences_.force_compositing_mode;
-}
-
void RenderViewImpl::OnSetFocus(bool enable) {
RenderWidget::OnSetFocus(enable);
if (replacement_range.IsValid() && webview()) {
// Select the text in |replacement_range|, it will then be replaced by
// text added by the call to RenderWidget::OnImeConfirmComposition().
- if (WebFrame* frame = webview()->focusedFrame()) {
+ if (WebLocalFrame* frame = webview()->focusedFrame()->toWebLocalFrame()) {
WebRange webrange = WebRange::fromDocumentRange(
frame, replacement_range.start(), replacement_range.length());
if (!webrange.isNull())
RenderWidget::SetDeviceScaleFactor(device_scale_factor);
if (webview()) {
webview()->setDeviceScaleFactor(device_scale_factor);
- webview()->settings()->setAcceleratedCompositingForFixedPositionEnabled(
- ShouldUseFixedPositionCompositing(device_scale_factor_));
- webview()->settings()->setAcceleratedCompositingForOverflowScrollEnabled(
- ShouldUseAcceleratedCompositingForOverflowScroll(device_scale_factor_));
+ webview()->settings()->setPreferCompositingToLCDTextEnabled(
+ PreferCompositingToLCDText(device_scale_factor_));
webview()->settings()->setAcceleratedCompositingForTransitionEnabled(
ShouldUseTransitionCompositing(device_scale_factor_));
- webview()->settings()->
- setAcceleratedCompositingForFixedRootBackgroundEnabled(
- ShouldUseAcceleratedFixedRootBackground(device_scale_factor_));
- webview()->settings()->setAcceleratedCompositingForScrollableFramesEnabled(
- ShouldUseAcceleratedCompositingForScrollableFrames(
- device_scale_factor_));
- webview()->settings()->setCompositedScrollingForFramesEnabled(
- ShouldUseCompositedScrollingForFrames(device_scale_factor_));
}
if (auto_resize_mode_)
AutoResizeCompositor();
if (browser_plugin_manager_.get())
- browser_plugin_manager_->UpdateDeviceScaleFactor(device_scale_factor_);
+ browser_plugin_manager_->UpdateDeviceScaleFactor();
+}
+
+bool RenderViewImpl::SetDeviceColorProfile(
+ const std::vector<char>& profile) {
+ bool changed = RenderWidget::SetDeviceColorProfile(profile);
+ if (changed && webview()) {
+ WebVector<char> colorProfile = profile;
+ webview()->setDeviceColorProfile(colorProfile);
+ }
+ return changed;
+}
+
+void RenderViewImpl::ResetDeviceColorProfileForTesting() {
+ RenderWidget::ResetDeviceColorProfileForTesting();
+ if (webview())
+ webview()->resetDeviceColorProfile();
}
ui::TextInputType RenderViewImpl::GetTextInputType() {
RenderWidget::GetSelectionBounds(start, end);
}
-#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
+#if defined(OS_MACOSX) || defined(USE_AURA)
void RenderViewImpl::GetCompositionCharacterBounds(
std::vector<gfx::Rect>* bounds) {
DCHECK(bounds);
float device_scale_factor,
const gfx::Point& root_layer_offset,
float root_layer_scale) {
- if (webview()) {
+ if (webview() && compositor()) {
webview()->setCompositorDeviceScaleFactorOverride(device_scale_factor);
webview()->setRootLayerTransform(
blink::WebSize(root_layer_offset.x(), root_layer_offset.y()),
return true;
}
-blink::WebGeolocationClient* RenderViewImpl::geolocationClient() {
- if (!geolocation_dispatcher_)
- geolocation_dispatcher_ = new GeolocationDispatcher(this);
- return geolocation_dispatcher_;
-}
-
-blink::WebSpeechInputController* RenderViewImpl::speechInputController(
- blink::WebSpeechInputListener* listener) {
-#if defined(ENABLE_INPUT_SPEECH)
- if (!input_tag_speech_dispatcher_)
- input_tag_speech_dispatcher_ =
- new InputTagSpeechDispatcher(this, listener);
-#endif
- return input_tag_speech_dispatcher_;
-}
-
blink::WebSpeechRecognizer* RenderViewImpl::speechRecognizer() {
if (!speech_recognition_dispatcher_)
speech_recognition_dispatcher_ = new SpeechRecognitionDispatcher(this);
void RenderViewImpl::zoomLimitsChanged(double minimum_level,
double maximum_level) {
- // For now, don't remember plugin zoom values. We don't want to mix them with
- // normal web content (i.e. a fixed layout plugin would usually want them
- // different).
- bool remember = !webview()->mainFrame()->document().isPluginDocument();
-
int minimum_percent = static_cast<int>(
ZoomLevelToZoomFactor(minimum_level) * 100);
int maximum_percent = static_cast<int>(
ZoomLevelToZoomFactor(maximum_level) * 100);
Send(new ViewHostMsg_UpdateZoomLimits(
- routing_id_, minimum_percent, maximum_percent, remember));
+ routing_id_, minimum_percent, maximum_percent));
}
void RenderViewImpl::zoomLevelChanged() {
- bool remember = !webview()->mainFrame()->document().isPluginDocument();
double zoom_level = webview()->zoomLevel();
- FOR_EACH_OBSERVER(RenderViewObserver, observers_, ZoomLevelChanged());
-
// Do not send empty URLs to the browser when we are just setting the default
// zoom level (from RendererPreferences) before the first navigation.
if (!webview()->mainFrame()->document().url().isEmpty()) {
// Tell the browser which url got zoomed so it can update the menu and the
// saved values if necessary
Send(new ViewHostMsg_DidZoomURL(
- routing_id_, zoom_level, remember,
+ routing_id_, zoom_level,
GURL(webview()->mainFrame()->document().url())));
}
}
}
void RenderViewImpl::registerProtocolHandler(const WebString& scheme,
- const WebURL& base_url,
const WebURL& url,
const WebString& title) {
bool user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
- GURL base(base_url);
- GURL absolute_url = base.Resolve(base::UTF16ToUTF8(url.string()));
- if (base.GetOrigin() != absolute_url.GetOrigin()) {
- return;
- }
Send(new ViewHostMsg_RegisterProtocolHandler(routing_id_,
base::UTF16ToUTF8(scheme),
- absolute_url,
+ url,
title,
user_gesture));
}
+void RenderViewImpl::unregisterProtocolHandler(const WebString& scheme,
+ const WebURL& url) {
+ bool user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
+ Send(new ViewHostMsg_UnregisterProtocolHandler(routing_id_,
+ base::UTF16ToUTF8(scheme),
+ url,
+ user_gesture));
+}
+
blink::WebPageVisibilityState RenderViewImpl::visibilityState() const {
blink::WebPageVisibilityState current_state = is_hidden() ?
blink::WebPageVisibilityStateHidden :
return current_state;
}
-blink::WebUserMediaClient* RenderViewImpl::userMediaClient() {
- // This can happen in tests, in which case it's OK to return NULL.
- if (!InitializeMediaStreamClient())
- return NULL;
-
- return web_user_media_client_;
-}
-
-blink::WebMIDIClient* RenderViewImpl::webMIDIClient() {
- if (!midi_dispatcher_)
- midi_dispatcher_ = new MidiDispatcher(this);
- return midi_dispatcher_;
+blink::WebPushClient* RenderViewImpl::webPushClient() {
+ // TODO(mvanouwerkerk): Remove this method once the Push API code in Blink
+ // has also switched over to Frame.
+ return main_render_frame_->pushClient();
}
void RenderViewImpl::draggableRegionsChanged() {
DraggableRegionsChanged(webview()->mainFrame()));
}
-WebMediaPlayer* RenderViewImpl::CreateWebMediaPlayerForMediaStream(
- WebFrame* frame,
- const blink::WebURL& url,
- WebMediaPlayerClient* client) {
-#if defined(ENABLE_WEBRTC)
- if (!InitializeMediaStreamClient()) {
- LOG(ERROR) << "Failed to initialize MediaStreamClient";
- return NULL;
- }
- if (media_stream_client_->IsMediaStream(url)) {
-#if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
- bool found_neon =
- (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
- UMA_HISTOGRAM_BOOLEAN("Platform.WebRtcNEONFound", found_neon);
-#endif // defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
- return new WebMediaPlayerMS(frame, client, AsWeakPtr(),
- media_stream_client_, new RenderMediaLog());
- }
-#endif // defined(ENABLE_WEBRTC)
- return NULL;
-}
-
#if defined(OS_ANDROID)
WebContentDetectionResult RenderViewImpl::detectContentAround(
const WebHitTestResult& touch_hit) {
date_time_picker_client_.reset(NULL);
}
-WebMediaPlayer* RenderViewImpl::CreateAndroidWebMediaPlayer(
- WebFrame* frame,
- const blink::WebURL& url,
- WebMediaPlayerClient* client) {
- GpuChannelHost* gpu_channel_host =
- RenderThreadImpl::current()->EstablishGpuChannelSync(
- CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
- if (!gpu_channel_host) {
- LOG(ERROR) << "Failed to establish GPU channel for media player";
- return NULL;
- }
-
- scoped_ptr<StreamTextureFactory> stream_texture_factory;
- if (UsingSynchronousRendererCompositor()) {
- SynchronousCompositorFactory* factory =
- SynchronousCompositorFactory::GetInstance();
- stream_texture_factory = factory->CreateStreamTextureFactory(routing_id_);
- } else {
- scoped_refptr<webkit::gpu::ContextProviderWebContext> context_provider =
- RenderThreadImpl::current()->SharedMainThreadContextProvider();
-
- if (!context_provider.get()) {
- LOG(ERROR) << "Failed to get context3d for media player";
- return NULL;
- }
-
- stream_texture_factory.reset(new StreamTextureFactoryImpl(
- context_provider, gpu_channel_host, routing_id_));
- }
-
- return new WebMediaPlayerAndroid(
- frame,
- client,
- AsWeakPtr(),
- media_player_manager_,
- stream_texture_factory.release(),
- RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy(),
- new RenderMediaLog());
-}
-
#endif // defined(OS_ANDROID)
-#if defined(OS_MACOSX)
-void RenderViewImpl::OnSelectPopupMenuItem(int selected_index) {
- if (external_popup_menu_ == NULL)
- return;
- external_popup_menu_->DidSelectItem(selected_index);
- external_popup_menu_.reset();
-}
-#endif
-
-#if defined(OS_ANDROID)
-void RenderViewImpl::OnSelectPopupMenuItems(
- bool canceled,
- const std::vector<int>& selected_indices) {
- // It is possible to receive more than one of these calls if the user presses
- // a select faster than it takes for the show-select-popup IPC message to make
- // it to the browser UI thread. Ignore the extra-messages.
- // TODO(jcivelli): http:/b/5793321 Implement a better fix, as detailed in bug.
- if (!external_popup_menu_)
- return;
-
- external_popup_menu_->DidSelectItems(canceled, selected_indices);
- external_popup_menu_.reset();
-}
-#endif
-
-#if defined(OS_MACOSX) || defined(OS_ANDROID)
-void RenderViewImpl::DidHideExternalPopupMenu() {
- // We need to clear external_popup_menu_ as soon as ExternalPopupMenu::close
- // is called. Otherwise, createExternalPopupMenu() for new popup will fail.
- external_popup_menu_.reset();
-}
-#endif
-
-void RenderViewImpl::OnShowContextMenu(const gfx::Point& location) {
- context_menu_source_type_ = ui::MENU_SOURCE_TOUCH_EDIT_MENU;
- touch_editing_context_menu_location_ = location;
+void RenderViewImpl::OnShowContextMenu(
+ ui::MenuSourceType source_type, const gfx::Point& location) {
+ context_menu_source_type_ = source_type;
+ has_host_context_menu_location_ = true;
+ host_context_menu_location_ = location;
if (webview())
webview()->showContextMenu();
+ has_host_context_menu_location_ = false;
}
void RenderViewImpl::OnEnableViewSourceMode() {
main_frame->enableViewSourceMode(true);
}
-void RenderViewImpl::OnDisownOpener() {
- if (!webview())
- return;
-
- WebFrame* main_frame = webview()->mainFrame();
- if (main_frame && main_frame->opener())
- main_frame->setOpener(NULL);
-}
-
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(TOOLKIT_VIEWS)
bool RenderViewImpl::didTapMultipleTargets(
- const blink::WebGestureEvent& event,
+ const WebSize& inner_viewport_offset,
+ const WebRect& touch_rect,
const WebVector<WebRect>& target_rects) {
// Never show a disambiguation popup when accessibility is enabled,
// as this interferes with "touch exploration".
- bool matchesAccessibilityModeComplete =
- (accessibility_mode_ & AccessibilityModeComplete) ==
- AccessibilityModeComplete;
- if (matchesAccessibilityModeComplete)
+ AccessibilityMode accessibility_mode =
+ GetMainRenderFrame()->accessibility_mode();
+ bool matches_accessibility_mode_complete =
+ (accessibility_mode & AccessibilityModeComplete) ==
+ AccessibilityModeComplete;
+ if (matches_accessibility_mode_complete)
return false;
- gfx::Rect finger_rect(
- event.x - event.data.tap.width / 2, event.y - event.data.tap.height / 2,
- event.data.tap.width, event.data.tap.height);
+ // The touch_rect, target_rects and zoom_rect are in the outer viewport
+ // reference frame.
gfx::Rect zoom_rect;
float new_total_scale =
DisambiguationPopupHelper::ComputeZoomAreaAndScaleFactor(
- finger_rect, target_rects, GetSize(),
+ touch_rect, target_rects, GetSize(),
gfx::Rect(webview()->mainFrame()->visibleContentRect()).size(),
device_scale_factor_ * webview()->pageScaleFactor(), &zoom_rect);
if (!new_total_scale)
case TAP_MULTIPLE_TARGETS_STRATEGY_POPUP: {
gfx::Size canvas_size =
gfx::ToCeiledSize(gfx::ScaleSize(zoom_rect.size(), new_total_scale));
- TransportDIB* transport_dib = NULL;
+ cc::SharedBitmapManager* manager =
+ RenderThreadImpl::current()->shared_bitmap_manager();
+ scoped_ptr<cc::SharedBitmap> shared_bitmap =
+ manager->AllocateSharedBitmap(canvas_size);
{
- scoped_ptr<skia::PlatformCanvas> canvas(
- RenderProcess::current()->GetDrawingCanvas(&transport_dib,
- gfx::Rect(canvas_size)));
- if (!canvas) {
- handled = false;
- break;
- }
+ SkBitmap bitmap;
+ SkImageInfo info = SkImageInfo::MakeN32Premul(canvas_size.width(),
+ canvas_size.height());
+ bitmap.installPixels(info, shared_bitmap->pixels(), info.minRowBytes());
+ SkCanvas canvas(bitmap);
// TODO(trchen): Cleanup the device scale factor mess.
// device scale will be applied in WebKit
// --> zoom_rect doesn't include device scale,
// but WebKit will still draw on zoom_rect * device_scale_factor_
- canvas->scale(new_total_scale / device_scale_factor_,
- new_total_scale / device_scale_factor_);
- canvas->translate(-zoom_rect.x() * device_scale_factor_,
- -zoom_rect.y() * device_scale_factor_);
-
- webwidget_->paint(
- canvas.get(),
- zoom_rect,
- WebWidget::ForceSoftwareRenderingAndIgnoreGPUResidentContent);
+ canvas.scale(new_total_scale / device_scale_factor_,
+ new_total_scale / device_scale_factor_);
+ canvas.translate(-zoom_rect.x() * device_scale_factor_,
+ -zoom_rect.y() * device_scale_factor_);
+
+ DCHECK(webwidget_->isAcceleratedCompositingActive());
+ // TODO(aelias): The disambiguation popup should be composited so we
+ // don't have to call this method.
+ webwidget_->paintCompositedDeprecated(&canvas, zoom_rect);
}
+ gfx::Rect zoom_rect_in_screen =
+ zoom_rect - gfx::Vector2d(inner_viewport_offset.width,
+ inner_viewport_offset.height);
+
gfx::Rect physical_window_zoom_rect = gfx::ToEnclosingRect(
- ClientRectToPhysicalWindowRect(gfx::RectF(zoom_rect)));
+ ClientRectToPhysicalWindowRect(gfx::RectF(zoom_rect_in_screen)));
+
Send(new ViewHostMsg_ShowDisambiguationPopup(routing_id_,
physical_window_zoom_rect,
canvas_size,
- transport_dib->id()));
+ shared_bitmap->id()));
+ cc::SharedBitmapId id = shared_bitmap->id();
+ disambiguation_bitmaps_[id] = shared_bitmap.release();
handled = true;
break;
}
return handled;
}
-#endif
+#endif // defined(OS_ANDROID) || defined(TOOLKIT_VIEWS)
unsigned RenderViewImpl::GetLocalSessionHistoryLengthForTesting() const {
return history_list_length_;
params.new_size = size();
params.physical_backing_size =
gfx::ToCeiledSize(gfx::ScaleSize(size(), factor));
- params.overdraw_bottom_height = 0.f;
+ params.top_controls_layout_height = 0.f;
params.resizer_rect = WebRect();
params.is_fullscreen = is_fullscreen();
OnResize(params);
}
+void RenderViewImpl::SetDeviceColorProfileForTesting(
+ const std::vector<char>& color_profile) {
+ SetDeviceColorProfile(color_profile);
+}
+
void RenderViewImpl::ForceResizeForTesting(const gfx::Size& new_size) {
gfx::Rect new_position(rootWindowRect().x,
rootWindowRect().y,
OnDisableAutoResize(new_size);
}
-void RenderViewImpl::SetMediaStreamClientForTesting(
- MediaStreamClient* media_stream_client) {
- DCHECK(!media_stream_client_);
- DCHECK(!web_user_media_client_);
- media_stream_client_ = media_stream_client;
-}
-
-void RenderViewImpl::OnReleaseDisambiguationPopupDIB(
- TransportDIB::Handle dib_handle) {
- TransportDIB* dib = TransportDIB::CreateWithHandle(dib_handle);
- RenderProcess::current()->ReleaseTransportDIB(dib);
+void RenderViewImpl::OnReleaseDisambiguationPopupBitmap(
+ const cc::SharedBitmapId& id) {
+ BitmapMap::iterator it = disambiguation_bitmaps_.find(id);
+ DCHECK(it != disambiguation_bitmaps_.end());
+ delete it->second;
+ disambiguation_bitmaps_.erase(it);
}
void RenderViewImpl::DidCommitCompositorFrame() {
void RenderViewImpl::SendUpdateFaviconURL(const std::vector<FaviconURL>& urls) {
if (!urls.empty())
- Send(new ViewHostMsg_UpdateFaviconURL(routing_id_, page_id_, urls));
+ Send(new ViewHostMsg_UpdateFaviconURL(routing_id_, urls));
}
void RenderViewImpl::DidStopLoadingIcons() {
std::vector<FaviconURL> urls;
for (size_t i = 0; i < icon_urls.size(); i++) {
WebURL url = icon_urls[i].iconURL();
- std::vector<gfx::Size> sizes(icon_urls[i].sizes().size());
+ std::vector<gfx::Size> sizes;
ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
if (!url.isEmpty())
urls.push_back(
projects / platform / framework / web / crosswalk.git / blobdiff