// Copyright (c) 2014 The Chromium Embedded Framework Authors. // Portions copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "libcef/browser/osr/render_widget_host_view_osr.h" #include #include #include "libcef/browser/alloy/alloy_browser_host_impl.h" #include "libcef/browser/osr/osr_util.h" #include "libcef/browser/osr/synthetic_gesture_target_osr.h" #include "libcef/browser/osr/video_consumer_osr.h" #include "libcef/browser/thread_util.h" #include "base/callback_helpers.h" #include "base/command_line.h" #include "base/memory/ptr_util.h" #include "base/strings/utf_string_conversions.h" #include "base/task/post_task.h" #include "cc/base/switches.h" #include "components/viz/common/features.h" #include "components/viz/common/frame_sinks/begin_frame_args.h" #include "components/viz/common/frame_sinks/copy_output_request.h" #include "components/viz/common/frame_sinks/delay_based_time_source.h" #include "components/viz/common/surfaces/frame_sink_id_allocator.h" #include "components/viz/common/switches.h" #include "content/browser/bad_message.h" #include "content/browser/gpu/gpu_data_manager_impl.h" #include "content/browser/renderer_host/cursor_manager.h" #include "content/browser/renderer_host/delegated_frame_host.h" #include "content/browser/renderer_host/dip_util.h" #include "content/browser/renderer_host/input/motion_event_web.h" #include "content/browser/renderer_host/input/synthetic_gesture_target_base.h" #include "content/browser/renderer_host/render_widget_host_delegate.h" #include "content/browser/renderer_host/render_widget_host_impl.h" #include "content/browser/renderer_host/render_widget_host_input_event_router.h" #include "content/common/content_switches_internal.h" #include "content/public/browser/browser_task_traits.h" #include "content/public/browser/browser_thread.h" #include "content/public/browser/context_factory.h" #include "content/public/browser/render_process_host.h" #include "content/public/browser/render_view_host.h" #include "content/public/common/content_switches.h" #include "media/base/video_frame.h" #include "media/capture/mojom/video_capture_buffer.mojom.h" #include "ui/compositor/compositor.h" #include "ui/events/blink/blink_event_util.h" #include "ui/events/gesture_detection/gesture_provider_config_helper.h" #include "ui/events/gesture_detection/motion_event.h" #include "ui/gfx/geometry/dip_util.h" #include "ui/gfx/geometry/size_conversions.h" namespace { // The maximum number of damage rects to cache for outstanding frame requests // (for OnAcceleratedPaint). const size_t kMaxDamageRects = 10; const float kDefaultScaleFactor = 1.0; display::ScreenInfo ScreenInfoFrom(const CefScreenInfo& src) { display::ScreenInfo screenInfo; screenInfo.device_scale_factor = src.device_scale_factor; screenInfo.depth = src.depth; screenInfo.depth_per_component = src.depth_per_component; screenInfo.is_monochrome = src.is_monochrome ? true : false; screenInfo.rect = gfx::Rect(src.rect.x, src.rect.y, src.rect.width, src.rect.height); screenInfo.available_rect = gfx::Rect(src.available_rect.x, src.available_rect.y, src.available_rect.width, src.available_rect.height); return screenInfo; } class CefDelegatedFrameHostClient : public content::DelegatedFrameHostClient { public: explicit CefDelegatedFrameHostClient(CefRenderWidgetHostViewOSR* view) : view_(view) {} ui::Layer* DelegatedFrameHostGetLayer() const override { return view_->GetRootLayer(); } bool DelegatedFrameHostIsVisible() const override { // Called indirectly from DelegatedFrameHost::WasShown. return view_->IsShowing(); } SkColor DelegatedFrameHostGetGutterColor() const override { // When making an element on the page fullscreen the element's background // may not match the page's, so use black as the gutter color to avoid // flashes of brighter colors during the transition. if (view_->render_widget_host()->delegate() && view_->render_widget_host()->delegate()->IsFullscreen()) { return SK_ColorBLACK; } return *view_->GetBackgroundColor(); } void OnFrameTokenChanged(uint32_t frame_token, base::TimeTicks activation_time) override { view_->render_widget_host()->DidProcessFrame(frame_token, activation_time); } float GetDeviceScaleFactor() const override { return view_->GetDeviceScaleFactor(); } std::vector CollectSurfaceIdsForEviction() override { return view_->render_widget_host()->CollectSurfaceIdsForEviction(); } void InvalidateLocalSurfaceIdOnEviction() override { view_->InvalidateLocalSurfaceId(); } bool ShouldShowStaleContentOnEviction() override { return false; } private: CefRenderWidgetHostViewOSR* const view_; DISALLOW_COPY_AND_ASSIGN(CefDelegatedFrameHostClient); }; ui::GestureProvider::Config CreateGestureProviderConfig() { ui::GestureProvider::Config config = ui::GetGestureProviderConfig( ui::GestureProviderConfigType::CURRENT_PLATFORM); return config; } ui::LatencyInfo CreateLatencyInfo(const blink::WebInputEvent& event) { ui::LatencyInfo latency_info; // The latency number should only be added if the timestamp is valid. base::TimeTicks time = event.TimeStamp(); if (!time.is_null()) { latency_info.AddLatencyNumberWithTimestamp( ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, time); } return latency_info; } gfx::Rect GetViewBounds(AlloyBrowserHostImpl* browser) { if (!browser) return gfx::Rect(); CefRect rc; CefRefPtr handler = browser->GetClient()->GetRenderHandler(); CHECK(handler); handler->GetViewRect(browser, rc); CHECK_GT(rc.width, 0); CHECK_GT(rc.height, 0); return gfx::Rect(rc.x, rc.y, rc.width, rc.height); } float GetDeviceScaleFactor(AlloyBrowserHostImpl* browser) { if (!browser) return kDefaultScaleFactor; CefScreenInfo screen_info(kDefaultScaleFactor, 0, 0, false, CefRect(), CefRect()); CefRefPtr handler = browser->client()->GetRenderHandler(); CHECK(handler); if (!handler->GetScreenInfo(browser, screen_info)) return kDefaultScaleFactor; return screen_info.device_scale_factor; } ui::ImeTextSpan::UnderlineStyle GetImeUnderlineStyle( cef_composition_underline_style_t style) { switch (style) { case CEF_CUS_SOLID: return ui::ImeTextSpan::UnderlineStyle::kSolid; case CEF_CUS_DOT: return ui::ImeTextSpan::UnderlineStyle::kDot; case CEF_CUS_DASH: return ui::ImeTextSpan::UnderlineStyle::kDash; case CEF_CUS_NONE: return ui::ImeTextSpan::UnderlineStyle::kNone; } NOTREACHED(); return ui::ImeTextSpan::UnderlineStyle::kSolid; } } // namespace CefRenderWidgetHostViewOSR::CefRenderWidgetHostViewOSR( SkColor background_color, bool use_shared_texture, bool use_external_begin_frame, content::RenderWidgetHost* widget, CefRenderWidgetHostViewOSR* parent_host_view) : content::RenderWidgetHostViewBase(widget), background_color_(background_color), render_widget_host_(content::RenderWidgetHostImpl::From(widget)), has_parent_(parent_host_view != nullptr), parent_host_view_(parent_host_view), pinch_zoom_enabled_(content::IsPinchToZoomEnabled()), mouse_wheel_phase_handler_(this), gesture_provider_(CreateGestureProviderConfig(), this), weak_ptr_factory_(this) { DCHECK(render_widget_host_); DCHECK(!render_widget_host_->GetView()); SetCurrentDeviceScaleFactor(kDefaultScaleFactor); if (parent_host_view_) { browser_impl_ = parent_host_view_->browser_impl(); DCHECK(browser_impl_); } else if (content::RenderViewHost::From(render_widget_host_)) { // AlloyBrowserHostImpl might not be created at this time for popups. browser_impl_ = AlloyBrowserHostImpl::GetBrowserForHost( content::RenderViewHost::From(render_widget_host_)); } delegated_frame_host_client_.reset(new CefDelegatedFrameHostClient(this)); // Matching the attributes from BrowserCompositorMac. delegated_frame_host_ = std::make_unique( AllocateFrameSinkId(), delegated_frame_host_client_.get(), false /* should_register_frame_sink_id */); root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR)); bool opaque = SkColorGetA(background_color_) == SK_AlphaOPAQUE; GetRootLayer()->SetFillsBoundsOpaquely(opaque); GetRootLayer()->SetColor(background_color_); external_begin_frame_enabled_ = use_external_begin_frame; auto context_factory = content::GetContextFactory(); // Matching the attributes from RecyclableCompositorMac. compositor_.reset(new ui::Compositor( context_factory->AllocateFrameSinkId(), context_factory, base::ThreadTaskRunnerHandle::Get(), false /* enable_pixel_canvas */, use_external_begin_frame)); compositor_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget); compositor_->SetDelegate(this); compositor_->SetRootLayer(root_layer_.get()); compositor_->AddChildFrameSink(GetFrameSinkId()); content::RenderWidgetHostImpl* render_widget_host_impl = content::RenderWidgetHostImpl::From(render_widget_host_); if (render_widget_host_impl) render_widget_host_impl->SetCompositorForFlingScheduler(compositor_.get()); cursor_manager_.reset(new content::CursorManager(this)); // This may result in a call to GetFrameSinkId(). render_widget_host_->SetView(this); if (GetTextInputManager()) GetTextInputManager()->AddObserver(this); if (render_widget_host_->delegate() && render_widget_host_->delegate()->GetInputEventRouter()) { render_widget_host_->delegate()->GetInputEventRouter()->AddFrameSinkIdOwner( GetFrameSinkId(), this); } if (browser_impl_ && !parent_host_view_) { // For child/popup views this will be called from the associated InitAs*() // method. SetRootLayerSize(false /* force */); if (!render_widget_host_->is_hidden()) Show(); } } CefRenderWidgetHostViewOSR::~CefRenderWidgetHostViewOSR() { ReleaseCompositor(); root_layer_.reset(nullptr); DCHECK(!parent_host_view_); DCHECK(!popup_host_view_); DCHECK(!child_host_view_); DCHECK(guest_host_views_.empty()); if (text_input_manager_) text_input_manager_->RemoveObserver(this); } void CefRenderWidgetHostViewOSR::ReleaseCompositor() { if (!compositor_) { return; // already released } // Marking the DelegatedFrameHost as removed from the window hierarchy is // necessary to remove all connections to its old ui::Compositor. if (is_showing_) { delegated_frame_host_->WasHidden( content::DelegatedFrameHost::HiddenCause::kOther); } delegated_frame_host_->DetachFromCompositor(); delegated_frame_host_.reset(nullptr); compositor_.reset(nullptr); } // Called for full-screen widgets. void CefRenderWidgetHostViewOSR::InitAsChild(gfx::NativeView parent_view) { DCHECK(parent_host_view_); DCHECK(browser_impl_); if (parent_host_view_->child_host_view_) { // Cancel the previous popup widget. parent_host_view_->child_host_view_->CancelWidget(); } parent_host_view_->set_child_host_view(this); // The parent view should not render while the full-screen view exists. parent_host_view_->Hide(); SetRootLayerSize(false /* force */); Show(); } void CefRenderWidgetHostViewOSR::SetSize(const gfx::Size& size) {} void CefRenderWidgetHostViewOSR::SetBounds(const gfx::Rect& rect) {} gfx::NativeView CefRenderWidgetHostViewOSR::GetNativeView() { return gfx::NativeView(); } gfx::NativeViewAccessible CefRenderWidgetHostViewOSR::GetNativeViewAccessible() { return gfx::NativeViewAccessible(); } void CefRenderWidgetHostViewOSR::Focus() {} bool CefRenderWidgetHostViewOSR::HasFocus() { return false; } bool CefRenderWidgetHostViewOSR::IsSurfaceAvailableForCopy() { return delegated_frame_host_ ? delegated_frame_host_->CanCopyFromCompositingSurface() : false; } void CefRenderWidgetHostViewOSR::Show() { if (is_showing_) return; if (!content::GpuDataManagerImpl::GetInstance()->IsGpuCompositingDisabled() && !browser_impl_ && (!parent_host_view_ || !parent_host_view_->browser_impl_)) { return; } is_showing_ = true; // If the viz::LocalSurfaceId is invalid, we may have been evicted, // and no other visual properties have since been changed. Allocate a new id // and start synchronizing. if (!GetLocalSurfaceId().is_valid()) { AllocateLocalSurfaceId(); SynchronizeVisualProperties(cc::DeadlinePolicy::UseDefaultDeadline(), GetLocalSurfaceId()); } if (render_widget_host_) { render_widget_host_->WasShown( /*record_tab_switch_time_request=*/{}); // Call OnRenderFrameMetadataChangedAfterActivation for every frame. auto provider = content::RenderWidgetHostImpl::From(render_widget_host_) ->render_frame_metadata_provider(); provider->AddObserver(this); provider->ReportAllFrameSubmissionsForTesting(true); } if (delegated_frame_host_) { delegated_frame_host_->AttachToCompositor(compositor_.get()); delegated_frame_host_->WasShown(GetLocalSurfaceId(), GetViewBounds().size(), /*record_tab_switch_time_request=*/{}); } if (!content::GpuDataManagerImpl::GetInstance()->IsGpuCompositingDisabled()) { // Start generating frames when we're visible and at the correct size. if (!video_consumer_) { video_consumer_.reset(new CefVideoConsumerOSR(this)); UpdateFrameRate(); } else { video_consumer_->SetActive(true); } } } void CefRenderWidgetHostViewOSR::Hide() { if (!is_showing_) return; is_showing_ = false; if (browser_impl_.get()) browser_impl_->CancelContextMenu(); if (video_consumer_) { video_consumer_->SetActive(false); } if (render_widget_host_) { render_widget_host_->WasHidden(); auto provider = content::RenderWidgetHostImpl::From(render_widget_host_) ->render_frame_metadata_provider(); provider->RemoveObserver(this); } if (delegated_frame_host_) { delegated_frame_host_->WasHidden( content::DelegatedFrameHost::HiddenCause::kOther); delegated_frame_host_->DetachFromCompositor(); } } bool CefRenderWidgetHostViewOSR::IsShowing() { return is_showing_; } void CefRenderWidgetHostViewOSR::EnsureSurfaceSynchronizedForWebTest() { ++latest_capture_sequence_number_; SynchronizeVisualProperties(cc::DeadlinePolicy::UseInfiniteDeadline(), absl::nullopt); } gfx::Rect CefRenderWidgetHostViewOSR::GetViewBounds() { if (IsPopupWidget()) return popup_position_; return current_view_bounds_; } void CefRenderWidgetHostViewOSR::SetBackgroundColor(SkColor color) { // The renderer will feed its color back to us with the first CompositorFrame. // We short-cut here to show a sensible color before that happens. UpdateBackgroundColorFromRenderer(color); DCHECK(SkColorGetA(color) == SK_AlphaOPAQUE || SkColorGetA(color) == SK_AlphaTRANSPARENT); content::RenderWidgetHostViewBase::SetBackgroundColor(color); } absl::optional CefRenderWidgetHostViewOSR::GetBackgroundColor() { return background_color_; } void CefRenderWidgetHostViewOSR::UpdateBackgroundColor() {} absl::optional CefRenderWidgetHostViewOSR::GetDisplayFeature() { return absl::nullopt; } void CefRenderWidgetHostViewOSR::SetDisplayFeatureForTesting( const content::DisplayFeature* display_feature) { NOTREACHED(); } blink::mojom::PointerLockResult CefRenderWidgetHostViewOSR::LockMouse( bool request_unadjusted_movement) { return blink::mojom::PointerLockResult::kPermissionDenied; } blink::mojom::PointerLockResult CefRenderWidgetHostViewOSR::ChangeMouseLock( bool request_unadjusted_movement) { return blink::mojom::PointerLockResult::kPermissionDenied; } void CefRenderWidgetHostViewOSR::UnlockMouse() {} void CefRenderWidgetHostViewOSR::TakeFallbackContentFrom( content::RenderWidgetHostView* view) { DCHECK(!static_cast(view) ->IsRenderWidgetHostViewChildFrame()); CefRenderWidgetHostViewOSR* view_cef = static_cast(view); SetBackgroundColor(view_cef->background_color_); if (delegated_frame_host_ && view_cef->delegated_frame_host_) { delegated_frame_host_->TakeFallbackContentFrom( view_cef->delegated_frame_host_.get()); } host()->GetContentRenderingTimeoutFrom(view_cef->host()); } void CefRenderWidgetHostViewOSR::OnPresentCompositorFrame() {} void CefRenderWidgetHostViewOSR::OnDidUpdateVisualPropertiesComplete( const cc::RenderFrameMetadata& metadata) { if (host()->is_hidden()) { // When an embedded child responds, we want to accept its changes to the // viz::LocalSurfaceId. However we do not want to embed surfaces while // hidden. Nor do we want to embed invalid ids when we are evicted. Becoming // visible will generate a new id, if necessary, and begin embedding. UpdateLocalSurfaceIdFromEmbeddedClient(metadata.local_surface_id); } else { SynchronizeVisualProperties(cc::DeadlinePolicy::UseDefaultDeadline(), metadata.local_surface_id); } } void CefRenderWidgetHostViewOSR::AllocateLocalSurfaceId() { if (!parent_local_surface_id_allocator_) { parent_local_surface_id_allocator_ = std::make_unique(); } parent_local_surface_id_allocator_->GenerateId(); } const viz::LocalSurfaceId& CefRenderWidgetHostViewOSR::GetCurrentLocalSurfaceId() const { return parent_local_surface_id_allocator_->GetCurrentLocalSurfaceId(); } void CefRenderWidgetHostViewOSR::UpdateLocalSurfaceIdFromEmbeddedClient( const absl::optional& embedded_client_local_surface_id) { if (embedded_client_local_surface_id) { parent_local_surface_id_allocator_->UpdateFromChild( *embedded_client_local_surface_id); } else { AllocateLocalSurfaceId(); } } const viz::LocalSurfaceId& CefRenderWidgetHostViewOSR::GetOrCreateLocalSurfaceId() { if (!parent_local_surface_id_allocator_) AllocateLocalSurfaceId(); return GetCurrentLocalSurfaceId(); } void CefRenderWidgetHostViewOSR::InvalidateLocalSurfaceId() { if (!parent_local_surface_id_allocator_) return; parent_local_surface_id_allocator_->Invalidate(); } void CefRenderWidgetHostViewOSR::AddDamageRect(uint32_t sequence, const gfx::Rect& rect) { // Associate the given damage rect with the presentation token. // For OnAcceleratedPaint we'll lookup the corresponding damage area based on // the frame token which is passed back to OnPresentCompositorFrame. base::AutoLock lock_scope(damage_rect_lock_); // We assume our presentation_token is a counter. Since we're using an ordered // map we can enforce a max size and remove oldest from the front. Worst case, // if a damage rect isn't associated, we can simply pass the entire view size. while (damage_rects_.size() >= kMaxDamageRects) { damage_rects_.erase(damage_rects_.begin()); } damage_rects_[sequence] = rect; } void CefRenderWidgetHostViewOSR::ResetFallbackToFirstNavigationSurface() { if (delegated_frame_host_) { delegated_frame_host_->ResetFallbackToFirstNavigationSurface(); } } void CefRenderWidgetHostViewOSR::InitAsPopup( content::RenderWidgetHostView* parent_host_view, const gfx::Rect& bounds, const gfx::Rect& anchor_rect) { DCHECK_EQ(parent_host_view_, parent_host_view); DCHECK(browser_impl_); if (parent_host_view_->popup_host_view_) { // Cancel the previous popup widget. parent_host_view_->popup_host_view_->CancelWidget(); } parent_host_view_->set_popup_host_view(this); CefRefPtr handler = browser_impl_->GetClient()->GetRenderHandler(); CHECK(handler); handler->OnPopupShow(browser_impl_.get(), true); CefRect view_rect; handler->GetViewRect(browser_impl_.get(), view_rect); gfx::Rect client_pos(bounds.x() - view_rect.x, bounds.y() - view_rect.y, bounds.width(), bounds.height()); popup_position_ = client_pos; CefRect widget_pos(client_pos.x(), client_pos.y(), client_pos.width(), client_pos.height()); if (handler.get()) handler->OnPopupSize(browser_impl_.get(), widget_pos); // The size doesn't change for popups so we need to force the // initialization. SetRootLayerSize(true /* force */); Show(); } void CefRenderWidgetHostViewOSR::UpdateCursor( const content::WebCursor& cursor) {} content::CursorManager* CefRenderWidgetHostViewOSR::GetCursorManager() { return cursor_manager_.get(); } void CefRenderWidgetHostViewOSR::SetIsLoading(bool is_loading) { if (!is_loading) return; // Make sure gesture detection is fresh. gesture_provider_.ResetDetection(); forward_touch_to_popup_ = false; } void CefRenderWidgetHostViewOSR::RenderProcessGone() { Destroy(); } void CefRenderWidgetHostViewOSR::Destroy() { if (!is_destroyed_) { is_destroyed_ = true; if (has_parent_) { CancelWidget(); } else { if (popup_host_view_) popup_host_view_->CancelWidget(); if (child_host_view_) child_host_view_->CancelWidget(); if (!guest_host_views_.empty()) { // Guest RWHVs will be destroyed when the associated RWHVGuest is // destroyed. This parent RWHV may be destroyed first, so disassociate // the guest RWHVs here without destroying them. for (auto guest_host_view : guest_host_views_) guest_host_view->parent_host_view_ = nullptr; guest_host_views_.clear(); } Hide(); } } delete this; } void CefRenderWidgetHostViewOSR::UpdateTooltipUnderCursor( const std::u16string& tooltip_text) { if (!browser_impl_.get()) return; CefString tooltip(tooltip_text); CefRefPtr handler = browser_impl_->GetClient()->GetDisplayHandler(); if (handler.get()) { handler->OnTooltip(browser_impl_.get(), tooltip); } } gfx::Size CefRenderWidgetHostViewOSR::GetCompositorViewportPixelSize() { return gfx::ScaleToCeiledSize(GetRequestedRendererSize(), GetCurrentDeviceScaleFactor()); } uint32_t CefRenderWidgetHostViewOSR::GetCaptureSequenceNumber() const { return latest_capture_sequence_number_; } void CefRenderWidgetHostViewOSR::CopyFromSurface( const gfx::Rect& src_rect, const gfx::Size& output_size, base::OnceCallback callback) { if (delegated_frame_host_) { delegated_frame_host_->CopyFromCompositingSurface(src_rect, output_size, std::move(callback)); } } void CefRenderWidgetHostViewOSR::GetScreenInfo(display::ScreenInfo* results) { if (!browser_impl_.get()) return; CefScreenInfo screen_info(kDefaultScaleFactor, 0, 0, false, CefRect(), CefRect()); CefRefPtr handler = browser_impl_->client()->GetRenderHandler(); CHECK(handler); if (!handler->GetScreenInfo(browser_impl_.get(), screen_info) || screen_info.rect.width == 0 || screen_info.rect.height == 0 || screen_info.available_rect.width == 0 || screen_info.available_rect.height == 0) { // If a screen rectangle was not provided, try using the view rectangle // instead. Otherwise, popup views may be drawn incorrectly, or not at // all. CefRect screenRect; handler->GetViewRect(browser_impl_.get(), screenRect); CHECK_GT(screenRect.width, 0); CHECK_GT(screenRect.height, 0); if (screen_info.rect.width == 0 || screen_info.rect.height == 0) { screen_info.rect = screenRect; } if (screen_info.available_rect.width == 0 || screen_info.available_rect.height == 0) { screen_info.available_rect = screenRect; } } *results = ScreenInfoFrom(screen_info); } display::ScreenInfos CefRenderWidgetHostViewOSR::GetScreenInfos() { display::ScreenInfo screen_info; GetScreenInfo(&screen_info); return display::ScreenInfos(screen_info); } void CefRenderWidgetHostViewOSR::TransformPointToRootSurface( gfx::PointF* point) {} gfx::Rect CefRenderWidgetHostViewOSR::GetBoundsInRootWindow() { if (!browser_impl_.get()) return gfx::Rect(); CefRect rc; CefRefPtr handler = browser_impl_->client()->GetRenderHandler(); CHECK(handler); if (handler->GetRootScreenRect(browser_impl_.get(), rc)) return gfx::Rect(rc.x, rc.y, rc.width, rc.height); return GetViewBounds(); } #if !defined(OS_MAC) viz::ScopedSurfaceIdAllocator CefRenderWidgetHostViewOSR::DidUpdateVisualProperties( const cc::RenderFrameMetadata& metadata) { base::OnceCallback allocation_task = base::BindOnce( &CefRenderWidgetHostViewOSR::OnDidUpdateVisualPropertiesComplete, weak_ptr_factory_.GetWeakPtr(), metadata); return viz::ScopedSurfaceIdAllocator(std::move(allocation_task)); } #endif viz::SurfaceId CefRenderWidgetHostViewOSR::GetCurrentSurfaceId() const { return delegated_frame_host_ ? delegated_frame_host_->GetCurrentSurfaceId() : viz::SurfaceId(); } void CefRenderWidgetHostViewOSR::ImeSetComposition( const CefString& text, const std::vector& underlines, const CefRange& replacement_range, const CefRange& selection_range) { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::ImeSetComposition"); if (!render_widget_host_) return; std::vector web_underlines; web_underlines.reserve(underlines.size()); for (const CefCompositionUnderline& line : underlines) { web_underlines.push_back(ui::ImeTextSpan( ui::ImeTextSpan::Type::kComposition, line.range.from, line.range.to, line.thick ? ui::ImeTextSpan::Thickness::kThick : ui::ImeTextSpan::Thickness::kThin, GetImeUnderlineStyle(line.style), line.background_color, line.color, std::vector())); } gfx::Range range(replacement_range.from, replacement_range.to); // Start Monitoring for composition updates before we set. RequestImeCompositionUpdate(true); render_widget_host_->ImeSetComposition( text, web_underlines, range, selection_range.from, selection_range.to); } void CefRenderWidgetHostViewOSR::ImeCommitText( const CefString& text, const CefRange& replacement_range, int relative_cursor_pos) { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::ImeCommitText"); if (!render_widget_host_) return; gfx::Range range(replacement_range.from, replacement_range.to); render_widget_host_->ImeCommitText(text, std::vector(), range, relative_cursor_pos); // Stop Monitoring for composition updates after we are done. RequestImeCompositionUpdate(false); } void CefRenderWidgetHostViewOSR::ImeFinishComposingText(bool keep_selection) { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::ImeFinishComposingText"); if (!render_widget_host_) return; render_widget_host_->ImeFinishComposingText(keep_selection); // Stop Monitoring for composition updates after we are done. RequestImeCompositionUpdate(false); } void CefRenderWidgetHostViewOSR::ImeCancelComposition() { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::ImeCancelComposition"); if (!render_widget_host_) return; render_widget_host_->ImeCancelComposition(); // Stop Monitoring for composition updates after we are done. RequestImeCompositionUpdate(false); } void CefRenderWidgetHostViewOSR::SelectionChanged(const std::u16string& text, size_t offset, const gfx::Range& range) { RenderWidgetHostViewBase::SelectionChanged(text, offset, range); if (!browser_impl_.get()) return; CefString selected_text; if (!range.is_empty() && !text.empty()) { size_t pos = range.GetMin() - offset; size_t n = range.length(); if (pos + n <= text.length()) selected_text = text.substr(pos, n); } CefRefPtr handler = browser_impl_->GetClient()->GetRenderHandler(); CHECK(handler); CefRange cef_range(range.start(), range.end()); handler->OnTextSelectionChanged(browser_impl_.get(), selected_text, cef_range); } const viz::LocalSurfaceId& CefRenderWidgetHostViewOSR::GetLocalSurfaceId() const { return const_cast(this) ->GetOrCreateLocalSurfaceId(); } const viz::FrameSinkId& CefRenderWidgetHostViewOSR::GetFrameSinkId() const { return delegated_frame_host_ ? delegated_frame_host_->frame_sink_id() : viz::FrameSinkIdAllocator::InvalidFrameSinkId(); } viz::FrameSinkId CefRenderWidgetHostViewOSR::GetRootFrameSinkId() { return compositor_ ? compositor_->frame_sink_id() : viz::FrameSinkId(); } std::unique_ptr CefRenderWidgetHostViewOSR::CreateSyntheticGestureTarget() { return std::make_unique(host()); } bool CefRenderWidgetHostViewOSR::TransformPointToCoordSpaceForView( const gfx::PointF& point, RenderWidgetHostViewBase* target_view, gfx::PointF* transformed_point) { if (target_view == this) { *transformed_point = point; return true; } return target_view->TransformPointToLocalCoordSpace( point, GetCurrentSurfaceId(), transformed_point); } void CefRenderWidgetHostViewOSR::DidNavigate() { if (!IsShowing()) { // Navigating while hidden should not allocate a new LocalSurfaceID. Once // sizes are ready, or we begin to Show, we can then allocate the new // LocalSurfaceId. InvalidateLocalSurfaceId(); } else { if (is_first_navigation_) { // The first navigation does not need a new LocalSurfaceID. The renderer // can use the ID that was already provided. SynchronizeVisualProperties(cc::DeadlinePolicy::UseExistingDeadline(), GetLocalSurfaceId()); } else { SynchronizeVisualProperties(cc::DeadlinePolicy::UseExistingDeadline(), absl::nullopt); } } if (delegated_frame_host_) delegated_frame_host_->DidNavigate(); is_first_navigation_ = false; } void CefRenderWidgetHostViewOSR::OnFrameComplete( const viz::BeginFrameAck& ack) { DCHECK(begin_frame_pending_); DCHECK_EQ(begin_frame_source_.source_id(), ack.frame_id.source_id); DCHECK_EQ(begin_frame_number_, ack.frame_id.sequence_number); begin_frame_pending_ = false; } void CefRenderWidgetHostViewOSR::OnRenderFrameMetadataChangedAfterActivation( base::TimeTicks activation_time) { auto metadata = host_->render_frame_metadata_provider()->LastRenderFrameMetadata(); if (video_consumer_) { // Need to wait for the first frame of the new size before calling // SizeChanged. Otherwise, the video frame will be letterboxed. video_consumer_->SizeChanged(metadata.viewport_size_in_pixels); } gfx::Vector2dF root_scroll_offset; if (metadata.root_scroll_offset) { root_scroll_offset = *metadata.root_scroll_offset; } if (root_scroll_offset != last_scroll_offset_) { last_scroll_offset_ = root_scroll_offset; if (!is_scroll_offset_changed_pending_) { is_scroll_offset_changed_pending_ = true; // Send the notification asynchronously. CEF_POST_TASK( CEF_UIT, base::BindOnce(&CefRenderWidgetHostViewOSR::OnScrollOffsetChanged, weak_ptr_factory_.GetWeakPtr())); } } } std::unique_ptr CefRenderWidgetHostViewOSR::CreateHostDisplayClient() { host_display_client_ = new CefHostDisplayClientOSR(this, gfx::kNullAcceleratedWidget); host_display_client_->SetActive(true); return base::WrapUnique(host_display_client_); } bool CefRenderWidgetHostViewOSR::InstallTransparency() { if (background_color_ == SK_ColorTRANSPARENT) { SetBackgroundColor(background_color_); if (compositor_) { compositor_->SetBackgroundColor(background_color_); } return true; } return false; } void CefRenderWidgetHostViewOSR::WasResized() { // Only one resize will be in-flight at a time. if (hold_resize_) { if (!pending_resize_) pending_resize_ = true; return; } SynchronizeVisualProperties(cc::DeadlinePolicy::UseExistingDeadline(), absl::nullopt); } void CefRenderWidgetHostViewOSR::SynchronizeVisualProperties( const cc::DeadlinePolicy& deadline_policy, const absl::optional& child_local_surface_id) { SetFrameRate(); const bool resized = ResizeRootLayer(); bool surface_id_updated = false; if (!resized && child_local_surface_id) { // Update the current surface ID. parent_local_surface_id_allocator_->UpdateFromChild( *child_local_surface_id); surface_id_updated = true; } // Allocate a new surface ID if the surface has been resized or if the current // ID is invalid (meaning we may have been evicted). if (resized || !GetCurrentLocalSurfaceId().is_valid()) { AllocateLocalSurfaceId(); surface_id_updated = true; } if (surface_id_updated) { delegated_frame_host_->EmbedSurface( GetCurrentLocalSurfaceId(), GetViewBounds().size(), deadline_policy); // |render_widget_host_| will retrieve resize parameters from the // DelegatedFrameHost and this view, so SynchronizeVisualProperties must be // called last. if (render_widget_host_) { render_widget_host_->SynchronizeVisualProperties(); } } } void CefRenderWidgetHostViewOSR::OnScreenInfoChanged() { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::OnScreenInfoChanged"); if (!render_widget_host_) return; SynchronizeVisualProperties(cc::DeadlinePolicy::UseDefaultDeadline(), absl::nullopt); if (render_widget_host_->delegate()) render_widget_host_->delegate()->SendScreenRects(); else render_widget_host_->SendScreenRects(); render_widget_host_->NotifyScreenInfoChanged(); // We might want to change the cursor scale factor here as well - see the // cache for the current_cursor_, as passed by UpdateCursor from the // renderer in the rwhv_aura (current_cursor_.SetScaleFactor) // Notify the guest hosts if any. for (auto guest_host_view : guest_host_views_) guest_host_view->OnScreenInfoChanged(); } void CefRenderWidgetHostViewOSR::Invalidate( CefBrowserHost::PaintElementType type) { TRACE_EVENT1("cef", "CefRenderWidgetHostViewOSR::Invalidate", "type", type); if (!IsPopupWidget() && type == PET_POPUP) { if (popup_host_view_) popup_host_view_->Invalidate(type); return; } InvalidateInternal(gfx::Rect(SizeInPixels())); } void CefRenderWidgetHostViewOSR::SendExternalBeginFrame() { DCHECK(external_begin_frame_enabled_); if (begin_frame_pending_) return; begin_frame_pending_ = true; base::TimeTicks frame_time = base::TimeTicks::Now(); base::TimeTicks deadline = base::TimeTicks(); base::TimeDelta interval = viz::BeginFrameArgs::DefaultInterval(); viz::BeginFrameArgs begin_frame_args = viz::BeginFrameArgs::Create( BEGINFRAME_FROM_HERE, begin_frame_source_.source_id(), ++begin_frame_number_, frame_time, deadline, interval, viz::BeginFrameArgs::NORMAL); DCHECK(begin_frame_args.IsValid()); if (render_widget_host_) render_widget_host_->ProgressFlingIfNeeded(frame_time); if (compositor_) { compositor_->IssueExternalBeginFrame( begin_frame_args, /* force= */ true, base::BindOnce(&CefRenderWidgetHostViewOSR::OnFrameComplete, weak_ptr_factory_.GetWeakPtr())); } else { begin_frame_pending_ = false; } if (!IsPopupWidget() && popup_host_view_) { popup_host_view_->SendExternalBeginFrame(); } } void CefRenderWidgetHostViewOSR::SendKeyEvent( const content::NativeWebKeyboardEvent& event) { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::SendKeyEvent"); content::RenderWidgetHostImpl* target_host = render_widget_host_; // If there are multiple widgets on the page (such as when there are // out-of-process iframes), pick the one that should process this event. if (render_widget_host_ && render_widget_host_->delegate()) { target_host = render_widget_host_->delegate()->GetFocusedRenderWidgetHost( render_widget_host_); } if (target_host && target_host->GetView()) { // Direct routing requires that events go directly to the View. target_host->ForwardKeyboardEventWithLatencyInfo( event, ui::LatencyInfo(event.GetType() == blink::WebInputEvent::Type::kChar || event.GetType() == blink::WebInputEvent::Type::kRawKeyDown ? ui::SourceEventType::KEY_PRESS : ui::SourceEventType::OTHER)); } } void CefRenderWidgetHostViewOSR::SendMouseEvent( const blink::WebMouseEvent& event) { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::SendMouseEvent"); if (!IsPopupWidget()) { if (browser_impl_.get() && event.GetType() == blink::WebMouseEvent::Type::kMouseDown) { browser_impl_->CancelContextMenu(); } if (popup_host_view_) { if (popup_host_view_->popup_position_.Contains( event.PositionInWidget().x(), event.PositionInWidget().y())) { blink::WebMouseEvent popup_event(event); popup_event.SetPositionInWidget( event.PositionInWidget().x() - popup_host_view_->popup_position_.x(), event.PositionInWidget().y() - popup_host_view_->popup_position_.y()); popup_event.SetPositionInScreen(popup_event.PositionInWidget().x(), popup_event.PositionInWidget().y()); popup_host_view_->SendMouseEvent(popup_event); return; } } else if (!guest_host_views_.empty()) { for (auto guest_host_view : guest_host_views_) { if (!guest_host_view->render_widget_host_ || !guest_host_view->render_widget_host_->GetView()) { continue; } const gfx::Rect& guest_bounds = guest_host_view->render_widget_host_->GetView()->GetViewBounds(); if (guest_bounds.Contains(event.PositionInWidget().x(), event.PositionInWidget().y())) { blink::WebMouseEvent guest_event(event); guest_event.SetPositionInWidget( event.PositionInWidget().x() - guest_bounds.x(), event.PositionInWidget().y() - guest_bounds.y()); guest_event.SetPositionInScreen(guest_event.PositionInWidget().x(), guest_event.PositionInWidget().y()); guest_host_view->SendMouseEvent(guest_event); return; } } } } if (render_widget_host_ && render_widget_host_->GetView()) { if (ShouldRouteEvents()) { // RouteMouseEvent wants non-const pointer to WebMouseEvent, but it only // forwards it to RenderWidgetTargeter::FindTargetAndDispatch as a const // reference, so const_cast here is safe. render_widget_host_->delegate()->GetInputEventRouter()->RouteMouseEvent( this, const_cast(&event), ui::LatencyInfo(ui::SourceEventType::OTHER)); } else { render_widget_host_->GetView()->ProcessMouseEvent( event, ui::LatencyInfo(ui::SourceEventType::OTHER)); } } } void CefRenderWidgetHostViewOSR::SendMouseWheelEvent( const blink::WebMouseWheelEvent& event) { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::SendMouseWheelEvent"); if (!IsPopupWidget()) { if (browser_impl_.get()) browser_impl_->CancelContextMenu(); if (popup_host_view_) { if (popup_host_view_->popup_position_.Contains( event.PositionInWidget().x(), event.PositionInWidget().y())) { blink::WebMouseWheelEvent popup_mouse_wheel_event(event); popup_mouse_wheel_event.SetPositionInWidget( event.PositionInWidget().x() - popup_host_view_->popup_position_.x(), event.PositionInWidget().y() - popup_host_view_->popup_position_.y()); popup_mouse_wheel_event.SetPositionInScreen( popup_mouse_wheel_event.PositionInWidget().x(), popup_mouse_wheel_event.PositionInWidget().y()); popup_host_view_->SendMouseWheelEvent(popup_mouse_wheel_event); return; } else { // Scrolling outside of the popup widget so destroy it. // Execute asynchronously to avoid deleting the widget from inside // some other callback. CEF_POST_TASK( CEF_UIT, base::BindOnce(&CefRenderWidgetHostViewOSR::CancelWidget, popup_host_view_->weak_ptr_factory_.GetWeakPtr())); } } else if (!guest_host_views_.empty()) { for (auto guest_host_view : guest_host_views_) { if (!guest_host_view->render_widget_host_ || !guest_host_view->render_widget_host_->GetView()) { continue; } const gfx::Rect& guest_bounds = guest_host_view->render_widget_host_->GetView()->GetViewBounds(); if (guest_bounds.Contains(event.PositionInWidget().x(), event.PositionInWidget().y())) { blink::WebMouseWheelEvent guest_mouse_wheel_event(event); guest_mouse_wheel_event.SetPositionInWidget( event.PositionInWidget().x() - guest_bounds.x(), event.PositionInWidget().y() - guest_bounds.y()); guest_mouse_wheel_event.SetPositionInScreen( guest_mouse_wheel_event.PositionInWidget().x(), guest_mouse_wheel_event.PositionInWidget().y()); guest_host_view->SendMouseWheelEvent(guest_mouse_wheel_event); return; } } } } if (render_widget_host_ && render_widget_host_->GetView()) { blink::WebMouseWheelEvent mouse_wheel_event(event); mouse_wheel_phase_handler_.SendWheelEndForTouchpadScrollingIfNeeded(false); mouse_wheel_phase_handler_.AddPhaseIfNeededAndScheduleEndEvent( mouse_wheel_event, false); if (ShouldRouteEvents()) { render_widget_host_->delegate() ->GetInputEventRouter() ->RouteMouseWheelEvent( this, const_cast(&mouse_wheel_event), ui::LatencyInfo(ui::SourceEventType::WHEEL)); } else { render_widget_host_->GetView()->ProcessMouseWheelEvent( mouse_wheel_event, ui::LatencyInfo(ui::SourceEventType::WHEEL)); } } } void CefRenderWidgetHostViewOSR::SendTouchEvent(const CefTouchEvent& event) { TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::SendTouchEvent"); if (!IsPopupWidget() && popup_host_view_) { if (!forward_touch_to_popup_ && event.type == CEF_TET_PRESSED && pointer_state_.GetPointerCount() == 0) { forward_touch_to_popup_ = popup_host_view_->popup_position_.Contains(event.x, event.y); } if (forward_touch_to_popup_) { CefTouchEvent popup_event(event); popup_event.x -= popup_host_view_->popup_position_.x(); popup_event.y -= popup_host_view_->popup_position_.y(); popup_host_view_->SendTouchEvent(popup_event); return; } } // Update the touch event first. if (!pointer_state_.OnTouch(event)) return; ui::FilteredGestureProvider::TouchHandlingResult result = gesture_provider_.OnTouchEvent(pointer_state_); blink::WebTouchEvent touch_event = ui::CreateWebTouchEventFromMotionEvent( pointer_state_, result.moved_beyond_slop_region, false); pointer_state_.CleanupRemovedTouchPoints(event); // Set unchanged touch point to StateStationary for touchmove and // touchcancel to make sure only send one ack per WebTouchEvent. if (!result.succeeded) pointer_state_.MarkUnchangedTouchPointsAsStationary(&touch_event, event); if (!render_widget_host_) return; ui::LatencyInfo latency_info = CreateLatencyInfo(touch_event); if (ShouldRouteEvents()) { render_widget_host_->delegate()->GetInputEventRouter()->RouteTouchEvent( this, &touch_event, latency_info); } else { render_widget_host_->ForwardTouchEventWithLatencyInfo(touch_event, latency_info); } bool touch_end = touch_event.GetType() == blink::WebInputEvent::Type::kTouchEnd || touch_event.GetType() == blink::WebInputEvent::Type::kTouchCancel; if (touch_end && IsPopupWidget() && parent_host_view_ && parent_host_view_->popup_host_view_ == this) { parent_host_view_->forward_touch_to_popup_ = false; } } bool CefRenderWidgetHostViewOSR::ShouldRouteEvents() const { if (!render_widget_host_->delegate()) return false; // Do not route events that are currently targeted to page popups such as //