Skip to content

GitLab

T
tangled
Commit d357f705 authored by Dave Tapuska's avatar Dave Tapuska Committed by Commit Bot
Browse files
Options

Remove WebExternalWidget it is only used in tests now. 

With the removal of the RenderWidgetFullscreenPepper WebExternalWidget
is only used inside tests. Move these tests inside blink.
Add ability to override the WebViewFrameWidget with a custom implementation
so that we can instrument it for tests.

BUG=1097816

Change-Id: Id5cf6cea5d56f91aa6d7c0c5c05ff98f7ec9e19a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2460715
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: default avatardanakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#815323}
parent 91523ca2
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 349 additions and 884 deletions
content/renderer/render_widget_unittest.cc
View file @ d357f705
This diff is collapsed.
third_party/blink/public/BUILD.gn
View file @ d357f705
...@@ -313,8 +313,6 @@ source_set("blink_headers") { ...@@ -313,8 +313,6 @@ source_set("blink_headers") {
"web/web_element_collection.h", "web/web_element_collection.h",
"web/web_embedded_worker.h", "web/web_embedded_worker.h",
"web/web_embedded_worker_start_data.h", "web/web_embedded_worker_start_data.h",
"web/web_external_widget.h",
"web/web_external_widget_client.h",
"web/web_form_control_element.h", "web/web_form_control_element.h",
"web/web_form_element.h", "web/web_form_element.h",
"web/web_frame.h", "web/web_frame.h",
......
third_party/blink/public/web/web_external_widget.h deleted 100644 → 0
View file @ 91523ca2
// Copyright 2020 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.
#ifndef THIRD_PARTY_BLINK_PUBLIC_WEB_WEB_EXTERNAL_WIDGET_H_
#define THIRD_PARTY_BLINK_PUBLIC_WEB_WEB_EXTERNAL_WIDGET_H_
#include "cc/layers/layer.h"
#include "third_party/blink/public/mojom/page/widget.mojom-shared.h"
#include "third_party/blink/public/platform/cross_variant_mojo_util.h"
#include "third_party/blink/public/web/web_external_widget_client.h"
#include "third_party/blink/public/web/web_widget.h"
namespace blink {
// This is a type of Widget which is partially implemented outside of blink,
// such as fullscreen pepper widgets. This interface provides methods for the
// external implementation to access common Widget behaviour implemented inside
// blink, in addition to the WebWidget methods. The blink Widget uses
// WebExternalWidgetClient to communicate back to the external implementation.
class WebExternalWidget : public WebWidget {
public:
// Create a new concrete instance of this class.
// |client| should be non-null.
// |debug_url| provides the return value for WebWidget::GetURLForDebugTrace.
BLINK_EXPORT static std::unique_ptr<WebExternalWidget> Create(
WebExternalWidgetClient* client,
const WebURL& debug_url,
CrossVariantMojoAssociatedRemote<mojom::WidgetHostInterfaceBase>
widget_host,
CrossVariantMojoAssociatedReceiver<mojom::WidgetInterfaceBase> widget);
virtual ~WebExternalWidget() = default;
// Provides an externally-created Layer to display as the widget's content, or
// a null pointer to remove any existing Layer which will cause the widget to
// display nothing.
virtual void SetRootLayer(scoped_refptr<cc::Layer>) = 0;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_PUBLIC_WEB_WEB_EXTERNAL_WIDGET_H_
third_party/blink/public/web/web_external_widget_client.h deleted 100644 → 0
View file @ 91523ca2
// Copyright 2020 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.
#ifndef THIRD_PARTY_BLINK_PUBLIC_WEB_WEB_EXTERNAL_WIDGET_CLIENT_H_
#define THIRD_PARTY_BLINK_PUBLIC_WEB_WEB_EXTERNAL_WIDGET_CLIENT_H_
#include <vector>
#include "cc/trees/layer_tree_host.h"
#include "third_party/blink/public/platform/web_input_event_result.h"
#include "ui/gfx/geometry/size.h"
namespace blink {
class WebCoalescedInputEvent;
class WebGestureEvent;
// The interface from blink to Widgets with implementations outside of blink.
class WebExternalWidgetClient {
public:
virtual ~WebExternalWidgetClient() = default;
// Called when the associated WebExternalWidget receives input and
// needs the implementation to handle it.
virtual WebInputEventResult HandleInputEvent(
const WebCoalescedInputEvent&) = 0;
// Called when the associated WebExternalWidget wishes to dispatch
// any pending buffered touch events. The implementation may choose to buffer
// individual pointer events (received via HandleInputEvent) and dispatch
// a single touch event indicating the changes since the last touch event.
// This method is typically invoked once per frame whereas HandleInputEvent
// may be invoked many times per frame (i.e. multiple fingers on the touch
// surface).
virtual WebInputEventResult DispatchBufferedTouchEvents() = 0;
// Called when the associated WebExternalWidget has adjusted its size.
virtual void DidResize(const gfx::Size& size) = 0;
// Record the time it took for the first paint after the widget transitioned
// from background inactive to active.
virtual void RecordTimeToFirstActivePaint(base::TimeDelta duration) {}
// Notification that the BeginMainFrame completed, was committed into the
// compositor (thread) and submitted to the display compositor.
virtual void DidCommitAndDrawCompositorFrame() = 0;
// Called before gesture events are processed and allows the
// client to handle the event itself. Return true if event was handled
// and further processing should stop.
virtual bool WillHandleGestureEvent(const WebGestureEvent& event) {
return false;
}
virtual bool SupportsBufferedTouchEvents() { return false; }
// Returns whether we handled a GestureScrollEvent.
virtual void DidHandleGestureScrollEvent(
const WebGestureEvent& gesture_event,
const gfx::Vector2dF& unused_delta,
const cc::OverscrollBehavior& overscroll_behavior,
bool event_processed) {}
// Callback to notify new visual properties have been applied.
virtual void DidUpdateVisualProperties() {}
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_PUBLIC_WEB_WEB_EXTERNAL_WIDGET_CLIENT_H_
third_party/blink/renderer/core/exported/BUILD.gn
View file @ d357f705
...@@ -25,8 +25,6 @@ blink_core_sources("exported") { ...@@ -25,8 +25,6 @@ blink_core_sources("exported") {
"web_dom_message_event.cc", "web_dom_message_event.cc",
"web_element.cc", "web_element.cc",
"web_element_collection.cc", "web_element_collection.cc",
"web_external_widget_impl.cc",
"web_external_widget_impl.h",
"web_form_control_element.cc", "web_form_control_element.cc",
"web_form_element.cc", "web_form_element.cc",
"web_form_element_observer_impl.cc", "web_form_element_observer_impl.cc",
......
third_party/blink/renderer/core/exported/web_external_widget_impl.cc deleted 100644 → 0
View file @ 91523ca2
// Copyright 2020 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 "third_party/blink/renderer/core/exported/web_external_widget_impl.h"
#include "cc/trees/layer_tree_host.h"
#include "cc/trees/ukm_manager.h"
#include "third_party/blink/public/mojom/input/input_handler.mojom-blink.h"
#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
#include "third_party/blink/renderer/platform/widget/input/widget_input_handler_manager.h"
#include "third_party/blink/renderer/platform/widget/widget_base.h"
namespace blink {
std::unique_ptr<WebExternalWidget> WebExternalWidget::Create(
WebExternalWidgetClient* client,
const blink::WebURL& debug_url,
CrossVariantMojoAssociatedRemote<mojom::blink::WidgetHostInterfaceBase>
widget_host,
CrossVariantMojoAssociatedReceiver<mojom::blink::WidgetInterfaceBase>
widget) {
return std::make_unique<WebExternalWidgetImpl>(
client, debug_url, std::move(widget_host), std::move(widget));
}
WebExternalWidgetImpl::WebExternalWidgetImpl(
WebExternalWidgetClient* client,
const WebURL& debug_url,
CrossVariantMojoAssociatedRemote<mojom::blink::WidgetHostInterfaceBase>
widget_host,
CrossVariantMojoAssociatedReceiver<mojom::blink::WidgetInterfaceBase>
widget)
: client_(client),
debug_url_(debug_url),
widget_base_(
std::make_unique<WidgetBase>(this,
std::move(widget_host),
std::move(widget),
/*hidden=*/false,
/*never_composited=*/false,
/*is_for_child_local_root=*/false)) {
DCHECK(client_);
}
WebExternalWidgetImpl::~WebExternalWidgetImpl() = default;
cc::LayerTreeHost* WebExternalWidgetImpl::InitializeCompositing(
scheduler::WebThreadScheduler* main_thread_scheduler,
cc::TaskGraphRunner* task_graph_runner,
bool for_child_local_root_frame,
const ScreenInfo& screen_info,
std::unique_ptr<cc::UkmRecorderFactory> ukm_recorder_factory,
const cc::LayerTreeSettings* settings) {
widget_base_->InitializeCompositing(
main_thread_scheduler, task_graph_runner, for_child_local_root_frame,
screen_info, std::move(ukm_recorder_factory), settings);
return widget_base_->LayerTreeHost();
}
void WebExternalWidgetImpl::Close(
scoped_refptr<base::SingleThreadTaskRunner> cleanup_runner) {
widget_base_->Shutdown(std::move(cleanup_runner));
widget_base_.reset();
}
void WebExternalWidgetImpl::SetCompositorVisible(bool visible) {
widget_base_->SetCompositorVisible(visible);
}
WebHitTestResult WebExternalWidgetImpl::HitTestResultAt(const gfx::PointF&) {
NOTIMPLEMENTED();
return {};
}
KURL WebExternalWidgetImpl::GetURLForDebugTrace() {
return debug_url_;
}
gfx::Size WebExternalWidgetImpl::Size() {
return size_;
}
void WebExternalWidgetImpl::Resize(const gfx::Size& size) {
if (size_ == size)
return;
size_ = size;
client_->DidResize(gfx::Size(size));
}
WebInputEventResult WebExternalWidgetImpl::HandleInputEvent(
const WebCoalescedInputEvent& coalesced_event) {
return client_->HandleInputEvent(coalesced_event);
}
WebInputEventResult WebExternalWidgetImpl::DispatchBufferedTouchEvents() {
return client_->DispatchBufferedTouchEvents();
}
scheduler::WebRenderWidgetSchedulingState*
WebExternalWidgetImpl::RendererWidgetSchedulingState() {
return widget_base_->RendererWidgetSchedulingState();
}
void WebExternalWidgetImpl::SetCursor(const ui::Cursor& cursor) {
widget_base_->SetCursor(cursor);
}
bool WebExternalWidgetImpl::HandlingInputEvent() {
return widget_base_->input_handler().handling_input_event();
}
void WebExternalWidgetImpl::SetHandlingInputEvent(bool handling) {
widget_base_->input_handler().set_handling_input_event(handling);
}
void WebExternalWidgetImpl::ProcessInputEventSynchronouslyForTesting(
const WebCoalescedInputEvent& event,
HandledEventCallback callback) {
widget_base_->input_handler().HandleInputEvent(event, std::move(callback));
}
void WebExternalWidgetImpl::UpdateTextInputState() {
widget_base_->UpdateTextInputState();
}
void WebExternalWidgetImpl::UpdateSelectionBounds() {
widget_base_->UpdateSelectionBounds();
}
void WebExternalWidgetImpl::ShowVirtualKeyboard() {
widget_base_->ShowVirtualKeyboard();
}
void WebExternalWidgetImpl::SetFocus(bool focus) {
widget_base_->SetFocus(focus);
}
bool WebExternalWidgetImpl::HasFocus() {
return widget_base_->has_focus();
}
void WebExternalWidgetImpl::FlushInputProcessedCallback() {
widget_base_->FlushInputProcessedCallback();
}
void WebExternalWidgetImpl::CancelCompositionForPepper() {
widget_base_->CancelCompositionForPepper();
}
void WebExternalWidgetImpl::RequestMouseLock(
bool has_transient_user_activation,
bool request_unadjusted_movement,
base::OnceCallback<void(
mojom::blink::PointerLockResult,
CrossVariantMojoRemote<mojom::blink::PointerLockContextInterfaceBase>)>
callback) {
widget_base_->RequestMouseLock(has_transient_user_activation,
request_unadjusted_movement,
std::move(callback));
}
void WebExternalWidgetImpl::ApplyVisualProperties(
const VisualProperties& visual_properties) {
widget_base_->UpdateVisualProperties(visual_properties);
}
void WebExternalWidgetImpl::UpdateVisualProperties(
const VisualProperties& visual_properties) {
widget_base_->UpdateSurfaceAndScreenInfo(
visual_properties.local_surface_id.value_or(viz::LocalSurfaceId()),
visual_properties.compositor_viewport_pixel_rect,
visual_properties.screen_info);
widget_base_->SetVisibleViewportSizeInDIPs(
visual_properties.visible_viewport_size);
Resize(widget_base_->DIPsToCeiledBlinkSpace(visual_properties.new_size));
client_->DidUpdateVisualProperties();
}
const ScreenInfo& WebExternalWidgetImpl::GetScreenInfo() {
return widget_base_->GetScreenInfo();
}
gfx::Rect WebExternalWidgetImpl::WindowRect() {
return widget_base_->WindowRect();
}
gfx::Rect WebExternalWidgetImpl::ViewRect() {
return widget_base_->ViewRect();
}
void WebExternalWidgetImpl::SetScreenRects(
const gfx::Rect& widget_screen_rect,
const gfx::Rect& window_screen_rect) {
widget_base_->SetScreenRects(widget_screen_rect, window_screen_rect);
}
gfx::Size WebExternalWidgetImpl::VisibleViewportSizeInDIPs() {
return widget_base_->VisibleViewportSizeInDIPs();
}
void WebExternalWidgetImpl::SetPendingWindowRect(
const gfx::Rect* window_screen_rect) {
widget_base_->SetPendingWindowRect(window_screen_rect);
}
bool WebExternalWidgetImpl::IsHidden() const {
return widget_base_->is_hidden();
}
void WebExternalWidgetImpl::DidOverscrollForTesting(
const gfx::Vector2dF& overscroll_delta,
const gfx::Vector2dF& accumulated_overscroll,
const gfx::PointF& position,
const gfx::Vector2dF& velocity) {
cc::OverscrollBehavior overscroll_behavior =
widget_base_->LayerTreeHost()->overscroll_behavior();
widget_base_->input_handler().DidOverscrollFromBlink(
overscroll_delta, accumulated_overscroll, position, velocity,
overscroll_behavior);
}
void WebExternalWidgetImpl::SetRootLayer(scoped_refptr<cc::Layer> layer) {
widget_base_->LayerTreeHost()->SetRootLayer(layer);
}
void WebExternalWidgetImpl::RecordTimeToFirstActivePaint(
base::TimeDelta duration) {
client_->RecordTimeToFirstActivePaint(duration);
}
void WebExternalWidgetImpl::DidCommitAndDrawCompositorFrame() {
client_->DidCommitAndDrawCompositorFrame();
}
bool WebExternalWidgetImpl::WillHandleGestureEvent(
const WebGestureEvent& event) {
return client_->WillHandleGestureEvent(event);
}
bool WebExternalWidgetImpl::WillHandleMouseEvent(const WebMouseEvent& event) {
return false;
}
void WebExternalWidgetImpl::ObserveGestureEventAndResult(
const WebGestureEvent& gesture_event,
const gfx::Vector2dF& unused_delta,
const cc::OverscrollBehavior& overscroll_behavior,
bool event_processed) {
client_->DidHandleGestureScrollEvent(gesture_event, unused_delta,
overscroll_behavior, event_processed);
}
bool WebExternalWidgetImpl::SupportsBufferedTouchEvents() {
return client_->SupportsBufferedTouchEvents();
}
const ScreenInfo& WebExternalWidgetImpl::GetOriginalScreenInfo() {
return widget_base_->GetScreenInfo();
}
gfx::Rect WebExternalWidgetImpl::ViewportVisibleRect() {
return widget_base_->CompositorViewportRect();
}
std::unique_ptr<cc::LayerTreeFrameSink>
WebExternalWidgetImpl::AllocateNewLayerTreeFrameSink() {
return nullptr;
}
} // namespace blink
third_party/blink/renderer/core/exported/web_external_widget_impl.h deleted 100644 → 0
View file @ 91523ca2
// Copyright 2020 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.
#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_EXPORTED_WEB_EXTERNAL_WIDGET_IMPL_H_
#define THIRD_PARTY_BLINK_RENDERER_CORE_EXPORTED_WEB_EXTERNAL_WIDGET_IMPL_H_
#include "third_party/blink/public/web/web_external_widget.h"
#include "build/build_config.h"
#include "third_party/blink/public/mojom/input/pointer_lock_context.mojom-blink-forward.h"
#include "third_party/blink/public/mojom/input/pointer_lock_result.mojom-blink-forward.h"
#include "third_party/blink/public/mojom/page/widget.mojom-blink.h"
#include "third_party/blink/public/platform/cross_variant_mojo_util.h"
#include "third_party/blink/public/platform/web_url.h"
#include "third_party/blink/renderer/platform/widget/widget_base_client.h"
namespace blink {
class WidgetBase;
class WebExternalWidgetImpl : public WebExternalWidget,
public WidgetBaseClient {
public:
WebExternalWidgetImpl(
WebExternalWidgetClient* client,
const WebURL& debug_url,
CrossVariantMojoAssociatedRemote<mojom::blink::WidgetHostInterfaceBase>
widget_host,
CrossVariantMojoAssociatedReceiver<mojom::blink::WidgetInterfaceBase>
widget);
~WebExternalWidgetImpl() override;
// WebWidget overrides:
cc::LayerTreeHost* InitializeCompositing(
scheduler::WebThreadScheduler* main_thread_scheduler,
cc::TaskGraphRunner* task_graph_runner,
bool for_child_local_root_frame,
const ScreenInfo& screen_info,
std::unique_ptr<cc::UkmRecorderFactory> ukm_recorder_factory,
const cc::LayerTreeSettings* settings) override;
void SetCompositorVisible(bool visible) override;
void Close(
scoped_refptr<base::SingleThreadTaskRunner> cleanup_runner) override;
WebHitTestResult HitTestResultAt(const gfx::PointF&) override;
gfx::Size Size() override;
void Resize(const gfx::Size& size) override;
WebInputEventResult HandleInputEvent(
const WebCoalescedInputEvent& coalesced_event) override;
WebInputEventResult DispatchBufferedTouchEvents() override;
scheduler::WebRenderWidgetSchedulingState* RendererWidgetSchedulingState()
override;
void SetCursor(const ui::Cursor& cursor) override;
bool HandlingInputEvent() override;
void SetHandlingInputEvent(bool handling) override;
void ProcessInputEventSynchronouslyForTesting(const WebCoalescedInputEvent&,
HandledEventCallback) override;
void DidOverscrollForTesting(
const gfx::Vector2dF& overscroll_delta,
const gfx::Vector2dF& accumulated_overscroll,
const gfx::PointF& position_in_viewport,
const gfx::Vector2dF& velocity_in_viewport) override;
void UpdateTextInputState() override;
void UpdateSelectionBounds() override;
void ShowVirtualKeyboard() override;
bool HasFocus() override;
void SetFocus(bool focus) override;
void RequestMouseLock(
bool has_transient_user_activation,
bool request_unadjusted_movement,
base::OnceCallback<
void(mojom::blink::PointerLockResult,
CrossVariantMojoRemote<
mojom::blink::PointerLockContextInterfaceBase>)>) override;
void ApplyVisualProperties(
const VisualProperties& visual_properties) override;
const ScreenInfo& GetScreenInfo() override;
gfx::Rect WindowRect() override;
gfx::Rect ViewRect() override;
void SetScreenRects(const gfx::Rect& widget_screen_rect,
const gfx::Rect& window_screen_rect) override;
gfx::Size VisibleViewportSizeInDIPs() override;
void SetPendingWindowRect(const gfx::Rect* window_screen_rect) override;
bool IsHidden() const override;
// WebExternalWidget overrides:
void SetRootLayer(scoped_refptr<cc::Layer>) override;
// WidgetBaseClient overrides:
void BeginMainFrame(base::TimeTicks last_frame_time) override {}
void RecordTimeToFirstActivePaint(base::TimeDelta duration) override;
void UpdateLifecycle(WebLifecycleUpdate requested_update,
DocumentUpdateReason reason) override {}
void DidCommitAndDrawCompositorFrame() override;
bool WillHandleGestureEvent(const WebGestureEvent& event) override;
bool WillHandleMouseEvent(const WebMouseEvent& event) override;
void ObserveGestureEventAndResult(
const WebGestureEvent& gesture_event,
const gfx::Vector2dF& unused_delta,
const cc::OverscrollBehavior& overscroll_behavior,
bool event_processed) override;
bool SupportsBufferedTouchEvents() override;
void FlushInputProcessedCallback() override;
void CancelCompositionForPepper() override;
void UpdateVisualProperties(
const VisualProperties& visual_properties) override;
const ScreenInfo& GetOriginalScreenInfo() override;
gfx::Rect ViewportVisibleRect() override;
KURL GetURLForDebugTrace() override;
std::unique_ptr<cc::LayerTreeFrameSink> AllocateNewLayerTreeFrameSink()
override;
private:
WebExternalWidgetClient* const client_;
const WebURL debug_url_;
gfx::Size size_;
std::unique_ptr<WidgetBase> widget_base_;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_CORE_EXPORTED_WEB_EXTERNAL_WIDGET_IMPL_H_
third_party/blink/renderer/core/frame/DEPS
View file @ d357f705
...@@ -41,6 +41,7 @@ specific_include_rules = { ...@@ -41,6 +41,7 @@ specific_include_rules = {
"+ui/base/mojom/ui_base_types.mojom-shared.h", "+ui/base/mojom/ui_base_types.mojom-shared.h",
], ],
"web_frame_widget_test.cc": [ "web_frame_widget_test.cc": [
"+base/run_loop.h",
"+components/viz/common/surfaces/parent_local_surface_id_allocator.h", "+components/viz/common/surfaces/parent_local_surface_id_allocator.h",
], ],
"settings.h": [ "settings.h": [
......
third_party/blink/renderer/core/frame/frame_test_helpers.cc
View file @ d357f705
...@@ -801,7 +801,9 @@ void TestWebWidgetClient::WillQueueSyntheticEvent( ...@@ -801,7 +801,9 @@ void TestWebWidgetClient::WillQueueSyntheticEvent(
std::make_unique<WebCoalescedInputEvent>(event)); std::make_unique<WebCoalescedInputEvent>(event));
} }
void TestWebWidgetClient::SetCursor(const ui::Cursor& cursor) {} void TestWebWidgetClient::SetCursor(const ui::Cursor& cursor) {
cursor_set_count_++;
}
void TestWebWidgetClient::SetToolTipText( void TestWebWidgetClient::SetToolTipText(
const String& tooltip_text, const String& tooltip_text,
......
third_party/blink/renderer/core/frame/frame_test_helpers.h
View file @ d357f705
...@@ -204,6 +204,8 @@ class TestWebWidgetClient : public WebWidgetClient, ...@@ -204,6 +204,8 @@ class TestWebWidgetClient : public WebWidgetClient,
bool AnimationScheduled() const { return animation_scheduled_; } bool AnimationScheduled() const { return animation_scheduled_; }
void ClearAnimationScheduled() { animation_scheduled_ = false; } void ClearAnimationScheduled() { animation_scheduled_ = false; }
size_t CursorSetCount() const { return cursor_set_count_; }
bool HaveScrollEventHandlers() const; bool HaveScrollEventHandlers() const;
const Vector<std::unique_ptr<blink::WebCoalescedInputEvent>>& const Vector<std::unique_ptr<blink::WebCoalescedInputEvent>>&
GetInjectedScrollEvents() const { GetInjectedScrollEvents() const {
...@@ -269,6 +271,7 @@ class TestWebWidgetClient : public WebWidgetClient, ...@@ -269,6 +271,7 @@ class TestWebWidgetClient : public WebWidgetClient,
injected_scroll_events_; injected_scroll_events_;
std::unique_ptr<TestWidgetInputHandlerHost> widget_input_handler_host_; std::unique_ptr<TestWidgetInputHandlerHost> widget_input_handler_host_;
bool animation_scheduled_ = false; bool animation_scheduled_ = false;
size_t cursor_set_count_ = 0;
viz::FrameSinkId frame_sink_id_; viz::FrameSinkId frame_sink_id_;
mojo::AssociatedReceiver<mojom::blink::WidgetHost> receiver_{this}; mojo::AssociatedReceiver<mojom::blink::WidgetHost> receiver_{this};
}; };
......
third_party/blink/renderer/core/frame/web_frame_widget_impl.cc
View file @ d357f705
...@@ -106,6 +106,14 @@ FloatRect NormalizeRect(const IntRect& to_normalize, const IntRect& base_rect) { ...@@ -106,6 +106,14 @@ FloatRect NormalizeRect(const IntRect& to_normalize, const IntRect& base_rect) {
// WebFrameWidget ------------------------------------------------------------ // WebFrameWidget ------------------------------------------------------------
static CreateWebViewFrameWidgetFunction g_create_web_view_frame_widget =
nullptr;
void InstallCreateWebViewFrameWidgetHook(
CreateWebViewFrameWidgetFunction create_widget) {
g_create_web_view_frame_widget = create_widget;
}
WebFrameWidget* WebFrameWidget::CreateForMainFrame( WebFrameWidget* WebFrameWidget::CreateForMainFrame(
WebWidgetClient* client, WebWidgetClient* client,
WebLocalFrame* main_frame, WebLocalFrame* main_frame,
...@@ -132,14 +140,23 @@ WebFrameWidget* WebFrameWidget::CreateForMainFrame( ...@@ -132,14 +140,23 @@ WebFrameWidget* WebFrameWidget::CreateForMainFrame(
DCHECK(main_frame_impl.ViewImpl()); DCHECK(main_frame_impl.ViewImpl());
WebViewImpl& web_view_impl = *main_frame_impl.ViewImpl(); WebViewImpl& web_view_impl = *main_frame_impl.ViewImpl();
// Note: this isn't a leak, as the object has a self-reference that the WebViewFrameWidget* widget = nullptr;
// caller needs to release by calling Close(). if (g_create_web_view_frame_widget) {
// TODO(dcheng): Remove the special bridge class for main frame widgets. widget = g_create_web_view_frame_widget(
auto* widget = MakeGarbageCollected<WebViewFrameWidget>( util::PassKey<WebFrameWidget>(), *client, web_view_impl,
util::PassKey<WebFrameWidget>(), *client, web_view_impl, std::move(mojo_frame_widget_host), std::move(mojo_frame_widget),
std::move(mojo_frame_widget_host), std::move(mojo_frame_widget), std::move(mojo_widget_host), std::move(mojo_widget),
std::move(mojo_widget_host), std::move(mojo_widget), is_for_nested_main_frame, hidden, never_composited);
is_for_nested_main_frame, hidden, never_composited); } else {
// Note: this isn't a leak, as the object has a self-reference that the
// caller needs to release by calling Close().
// TODO(dcheng): Remove the special bridge class for main frame widgets.
widget = MakeGarbageCollected<WebViewFrameWidget>(
util::PassKey<WebFrameWidget>(), *client, web_view_impl,
std::move(mojo_frame_widget_host), std::move(mojo_frame_widget),
std::move(mojo_widget_host), std::move(mojo_widget),
is_for_nested_main_frame, hidden, never_composited);
}
widget->BindLocalRoot(*main_frame); widget->BindLocalRoot(*main_frame);
return widget; return widget;
} }
......
third_party/blink/renderer/core/frame/web_view_frame_widget.h
View file @ d357f705
...@@ -212,6 +212,32 @@ class CORE_EXPORT WebViewFrameWidget : public WebFrameWidgetBase { ...@@ -212,6 +212,32 @@ class CORE_EXPORT WebViewFrameWidget : public WebFrameWidgetBase {
DISALLOW_COPY_AND_ASSIGN(WebViewFrameWidget); DISALLOW_COPY_AND_ASSIGN(WebViewFrameWidget);
}; };
// Convenience type for creation method taken by
// InstallCreateWebViewFrameWidgetHook(). The method signature matches the
// WebViewFrameWidget constructor.
using CreateWebViewFrameWidgetFunction =
WebViewFrameWidget* (*)(util::PassKey<WebFrameWidget>,
WebWidgetClient&,
WebViewImpl&,
CrossVariantMojoAssociatedRemote<
mojom::blink::FrameWidgetHostInterfaceBase>
frame_widget_host,
CrossVariantMojoAssociatedReceiver<
mojom::blink::FrameWidgetInterfaceBase>
frame_widget,
CrossVariantMojoAssociatedRemote<
mojom::blink::WidgetHostInterfaceBase>
widget_host,
CrossVariantMojoAssociatedReceiver<
mojom::blink::WidgetInterfaceBase> widget,
bool is_for_nested_main_frame,
bool hidden,
bool never_composited);
// Overrides the implementation of WebFrameWidget::CreateForMainFrame() function
// below. Used by tests to override some functionality on WebViewFrameWidget.
void CORE_EXPORT InstallCreateWebViewFrameWidgetHook(
CreateWebViewFrameWidgetFunction create_widget);
} // namespace blink } // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_WEB_VIEW_FRAME_WIDGET_H_ #endif // THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_WEB_VIEW_FRAME_WIDGET_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment