electron/shell/browser/osr/osr_render_widget_host_view.cc
Electron Bot 69f1731bbb
chore: bump chromium to ec5bc1743792d64724693eb357083 (master) (#24984)
* chore: bump chromium in DEPS to cbdeef954dfc34e94c8ca9cf72ad326b4a121158

* chore: bump chromium in DEPS to 29723f905baeab1d4228eef2c31cdb341ebeffe0

* chore: bump chromium in DEPS to 44d6d78e852137fff58c14ed26ab1e803e5bf822

* update patches

* chore: bump chromium in DEPS to 8a3a0fccb39d6b8334c9a0496c0d5056e50cdb3f

* chore: update patches

* refactor: fix PrintBackend::CreateInstance() calls

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2354541

* chore: bump chromium in DEPS to b9ebec3bcb1cabdd1426f367636f54cc98e0500e

* chore: remove patches to code that was deleted upstream

CL: https://chromium-review.googlesource.com/c/chromium/src/+/2360314

* Remove uses of kCGColorSpaceITUR_2020_PQ_EOTF/HLG

CL: https://chromium-review.googlesource.com/c/chromium/src/+/2363950

just garden variety code shear

* chore: update patch indices

* Move ColorModel to //printing/mojom/print.mojom

https://chromium-review.googlesource.com/c/chromium/src/+/2355083

sync with printing ColorModel changes: moved to mojo, different naming scheme

* chore: bump chromium in DEPS to 56c4b4d2ce5ba941acd2e0fdb5100e8a48847134

* chore: bump chromium in DEPS to 130501f220b684a79dc82c17e236e63ac1f2a093

* Convert PrintHostMsg_DidGetPrintedPagesCount to Mojo

https://chromium-review.googlesource.com/c/chromium/src/+/2326857

Update argument list to Print()

* chore: update patch indices

* DumpAccTree: convert utf16 to utf8 in PropertyFilter

https://chromium-review.googlesource.com/c/chromium/src/+/2360218

* chore: bump chromium in DEPS to 3058368c6646e0dc8be6f8ea838b0343428b7998

* chore: bump chromium in DEPS to f51b4e6555364363c61438dac7afd988c8347bfc

* chore: bump chromium in DEPS to 2dcc6f8fc23ac41b2499eb69dee0b4017e9d1046

* update patches

* chore: bump chromium in DEPS to 2d8e98ecedc7e4905540b053bc1c87e964715be5

* update patches

* 2345900: Move content::RecordContentToVisibleTimeRequest struct to mojo

https://chromium-review.googlesource.com/c/chromium/src/+/2345900

* update patches

* 2345900: Move content::RecordContentToVisibleTimeRequest struct to mojo

https://chromium-review.googlesource.com/c/chromium/src/+/2345900

* 2367394: Remove net::LOAD_DO_NOT_SEND_COOKIES and net::LOAD_DO_NOT_SEND_AUTH_DATA.

https://chromium-review.googlesource.com/c/chromium/src/+/2367394

* 2373227: [XProto] Consolidate all <X11/*> includes to //ui/gfx/x/x11.h

https://chromium-review.googlesource.com/c/chromium/src/+/2373227

* fixup! 2373227: [XProto] Consolidate all <X11/*> includes to //ui/gfx/x/x11.h

* chore: bump chromium in DEPS to c090e3f960520cbd2328608b97f87238c76d6143

* update patches

* chore: bump chromium in DEPS to 13a25e0a755de9a14271022c595f3d2e29829e1a

* chore: bump chromium in DEPS to 6adbb767b012c41efaeab0d1bdbb3eefed0977bc

* chore: bump chromium in DEPS to 339ec5455c5932ef1322ea9953a6349b0732199e

* chore: bump chromium in DEPS to 20291807c33f7ef4ef4f57d62075e099b027bfe6

* chore: bump chromium in DEPS to 226fbd1b8b17d4ac84fdb9548ef3a1c646878d47

* update patches

* fixup disable_color_correct_rendering patch

* chore: bump chromium in DEPS to 577c45979cad4359f2e206d68efd9317d3d79315

* update patches

* viz: Rename RenderPass to CompositorRenderPass (and related types).

https://chromium-review.googlesource.com/c/chromium/src/+/2380730

* chore: bump chromium in DEPS to 37e2ad5303f2c03a1b5d8eda65341bf2561196cd

* update patches

* add kOmitCookies_Electron

* update patch

* chore: bump chromium in DEPS to 256e42409ea63a7e71016de07818a983a97db463

* update patches

* fix worker script ready hook

https://chromium-review.googlesource.com/c/chromium/src/+/2335713

* Fixup printing page ranges patch

* [printing] Move PrintMsg_PrintPages_Params to print.mojom

https://chromium-review.googlesource.com/c/chromium/src/+/2340854

* Add MIME sniffer overloads that take base::StringPieces

https://chromium-review.googlesource.com/c/chromium/src/+/2382896

* [printing] Move PrintHostMsg_PreviewIds to print.mojom

https://chromium-review.googlesource.com/c/chromium/src/+/2379455

* fixup test due to new DCHECK

https://chromium-review.googlesource.com/c/chromium/src/+/2333750

* stop sending cookies when useSessionCookies is false

* chore: bump chromium in DEPS to dd429dbc556449951ee8160d8a4d61fd95a139d5

* update patches

* chore: bump chromium in DEPS to 5202bde3f9f44c2065f5dacf27e7000dd19e4e4d

* chore: bump chromium in DEPS to 099e8e07b89da65932431bb0fd51b6f7f5344c19

* chore: bump chromium in DEPS to 104e5da2a43b759732d5b94bfc750b3a9a639653

* chore: bump chromium in DEPS to a4519ce657af25834e355315fd7fefa77b13426a

* update patches

* Make FileURLLoaderFactory always owned by its |receivers_|.

https://chromium-review.googlesource.com/c/chromium/src/+/2337411

* Make FileURLLoaderFactory always owned by its |receivers_|.

https://chromium-review.googlesource.com/c/chromium/src/+/2337411

* chore: bump chromium in DEPS to 1b62e9e8c8eaf6b8e3a9c77ee67a4c1bfa6a4d6b

* chore: update patches

* fixup! Make FileURLLoaderFactory always owned by its |receivers_|.

* chore: update patches

- mac: Disable CoreServices _CSCheckFix.
  https://chromium-review.googlesource.com/c/chromium/src/+/2401334
- [XProto] Remove bad DCHECK in x11_error_tracker.cc
  https://chromium-review.googlesource.com/c/chromium/src/+/2402304
- Move content/browser/frame_host/* over to content/browser/renderer_host/
  https://chromium-review.googlesource.com/c/chromium/src/+/2401303

* Refactor WebContentSettingsClient to dedupe AllowXYZ methods

https://chromium-review.googlesource.com/c/chromium/src/+/2353552

* Introduce NonNetworkURLLoaderFactoryBase class.

https://chromium-review.googlesource.com/c/chromium/src/+/2357559

* [XProto] Remove usage of all Xlib headers

https://chromium-review.googlesource.com/c/chromium/src/+/2392140

* fixup! chore: update patches

* chore: bump chromium in DEPS to c1df55fbeb8207d036a604f59e4ea4e8ee79930a

* chore: update patches

* Move content::WebPreferences struct to Blink

https://chromium-review.googlesource.com/c/chromium/src/+/2397670

* chore: bump chromium in DEPS to 57a23ec4884fff6c2f8d9b8536131cdc9b551ec2

* Set appid on Pip windows.

https://chromium-review.googlesource.com/c/chromium/src/+/2388274

* fixup! Set appid on Pip windows.

* fix: add a patch to remove deprecated factory

* chore: bump chromium in DEPS to 1a9ddb7ea43955877823d5c4dcbf241b64228635

* fix compilation on windows

* chore: bump chromium in DEPS to 234e6c6a77f61ffad9335099d9b13892cf88fd44

* chore: update patches

* chore: bump chromium in DEPS to 7631eb0a9f57a8a47d3c28e1d265961b3a4d6b2b

* chore: update patches

* chore: bump chromium in DEPS to f9c34cd485845b95c2d17a7f55fdf92cda9a1b3a

* chore: update patches

* chore: implement GetSurveyAPIKey

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2362182

* chore: replace CreateWebUIURLLoader with CreateWebUIURLLoaderFactory

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2358309

* chore: bump chromium in DEPS to 5bdbd2373da884adf41c087be1465fcc344d168c

* chore: update node patches for common.gypi

* chore: update patches

* chore: non_network_url_loader_factory_base was moved

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2357431

* 2415752: Reland "Reland "OOR-CORS: Remove BlinkCORS supporting code outside Blink""

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2415752

* chore: bump chromium in DEPS to b943d006a33ec5bc1743792d64724693eb357083

* fix: replace x11::None with x11::Window::None

* chore: update patches

* chore: update patches

* fix: cast x11::Window to int

* 2402123: Use end date when deleting http auth cache

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2402123

* 2320268: Migrate DragHostMsg_StartDragging to Mojo

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2320268

* 2401303: Move content/browser/frame_host/* over to content/browser/renderer_host/

https://chromium-review.googlesource.com/c/chromium/src/+/2401303

* chore: fix lint

* chore: fix build

* Update config.yml

Co-authored-by: Electron Bot <anonymous@electronjs.org>
Co-authored-by: Charles Kerr <charles@charleskerr.com>
Co-authored-by: Jeremy Rose <nornagon@nornagon.net>
Co-authored-by: John Kleinschmidt <jkleinsc@github.com>
Co-authored-by: deepak1556 <hop2deep@gmail.com>
Co-authored-by: Samuel Attard <samuel.r.attard@gmail.com>
Co-authored-by: Samuel Attard <sattard@slack-corp.com>
2020-09-21 01:00:36 -07:00

1042 lines
33 KiB
C++

// Copyright (c) 2016 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/browser/osr/osr_render_widget_host_view.h"
#include <algorithm>
#include <memory>
#include <utility>
#include <vector>
#include "base/callback_helpers.h"
#include "base/location.h"
#include "base/memory/ptr_util.h"
#include "base/optional.h"
#include "base/single_thread_task_runner.h"
#include "base/task/post_task.h"
#include "base/time/time.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/quads/compositor_render_pass.h"
#include "content/browser/renderer_host/cursor_manager.h" // nogncheck
#include "content/browser/renderer_host/input/synthetic_gesture_target.h" // nogncheck
#include "content/browser/renderer_host/render_widget_host_delegate.h" // nogncheck
#include "content/browser/renderer_host/render_widget_host_owner_delegate.h" // nogncheck
#include "content/common/view_messages.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/gpu_data_manager.h"
#include "content/public/browser/render_process_host.h"
#include "gpu/command_buffer/client/gl_helper.h"
#include "media/base/video_frame.h"
#include "third_party/blink/public/common/input/web_input_event.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "ui/compositor/compositor.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_type.h"
#include "ui/display/screen.h"
#include "ui/events/base_event_utils.h"
#include "ui/events/event_constants.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/dip_util.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/gfx/skbitmap_operations.h"
#include "ui/latency/latency_info.h"
namespace electron {
namespace {
const float kDefaultScaleFactor = 1.0;
ui::MouseEvent UiMouseEventFromWebMouseEvent(blink::WebMouseEvent event) {
ui::EventType type = ui::EventType::ET_UNKNOWN;
switch (event.GetType()) {
case blink::WebInputEvent::Type::kMouseDown:
type = ui::EventType::ET_MOUSE_PRESSED;
break;
case blink::WebInputEvent::Type::kMouseUp:
type = ui::EventType::ET_MOUSE_RELEASED;
break;
case blink::WebInputEvent::Type::kMouseMove:
type = ui::EventType::ET_MOUSE_MOVED;
break;
case blink::WebInputEvent::Type::kMouseEnter:
type = ui::EventType::ET_MOUSE_ENTERED;
break;
case blink::WebInputEvent::Type::kMouseLeave:
type = ui::EventType::ET_MOUSE_EXITED;
break;
case blink::WebInputEvent::Type::kMouseWheel:
type = ui::EventType::ET_MOUSEWHEEL;
break;
default:
type = ui::EventType::ET_UNKNOWN;
break;
}
int button_flags = 0;
switch (event.button) {
case blink::WebMouseEvent::Button::kBack:
button_flags |= ui::EventFlags::EF_BACK_MOUSE_BUTTON;
break;
case blink::WebMouseEvent::Button::kForward:
button_flags |= ui::EventFlags::EF_FORWARD_MOUSE_BUTTON;
break;
case blink::WebMouseEvent::Button::kLeft:
button_flags |= ui::EventFlags::EF_LEFT_MOUSE_BUTTON;
break;
case blink::WebMouseEvent::Button::kMiddle:
button_flags |= ui::EventFlags::EF_MIDDLE_MOUSE_BUTTON;
break;
case blink::WebMouseEvent::Button::kRight:
button_flags |= ui::EventFlags::EF_RIGHT_MOUSE_BUTTON;
break;
default:
button_flags = 0;
break;
}
ui::MouseEvent ui_event(type,
gfx::Point(std::floor(event.PositionInWidget().x()),
std::floor(event.PositionInWidget().y())),
gfx::Point(std::floor(event.PositionInWidget().x()),
std::floor(event.PositionInWidget().y())),
ui::EventTimeForNow(), button_flags, button_flags);
ui_event.SetClickCount(event.click_count);
return ui_event;
}
ui::MouseWheelEvent UiMouseWheelEventFromWebMouseEvent(
blink::WebMouseWheelEvent event) {
return ui::MouseWheelEvent(UiMouseEventFromWebMouseEvent(event),
std::floor(event.delta_x),
std::floor(event.delta_y));
}
} // namespace
class ElectronDelegatedFrameHostClient
: public content::DelegatedFrameHostClient {
public:
explicit ElectronDelegatedFrameHostClient(OffScreenRenderWidgetHostView* view)
: view_(view) {}
ui::Layer* DelegatedFrameHostGetLayer() const override {
return view_->GetRootLayer();
}
bool DelegatedFrameHostIsVisible() const override {
return view_->IsShowing();
}
SkColor DelegatedFrameHostGetGutterColor() const override {
if (view_->render_widget_host()->delegate() &&
view_->render_widget_host()->delegate()->IsFullscreen()) {
return SK_ColorWHITE;
}
return *view_->GetBackgroundColor();
}
void OnFrameTokenChanged(uint32_t frame_token) override {
view_->render_widget_host()->DidProcessFrame(frame_token);
}
float GetDeviceScaleFactor() const override {
return view_->GetDeviceScaleFactor();
}
std::vector<viz::SurfaceId> CollectSurfaceIdsForEviction() override {
return view_->render_widget_host()->CollectSurfaceIdsForEviction();
}
bool ShouldShowStaleContentOnEviction() override { return false; }
void InvalidateLocalSurfaceIdOnEviction() override {}
private:
OffScreenRenderWidgetHostView* const view_;
DISALLOW_COPY_AND_ASSIGN(ElectronDelegatedFrameHostClient);
};
OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
bool transparent,
bool painting,
int frame_rate,
const OnPaintCallback& callback,
content::RenderWidgetHost* host,
OffScreenRenderWidgetHostView* parent_host_view,
gfx::Size initial_size)
: content::RenderWidgetHostViewBase(host),
render_widget_host_(content::RenderWidgetHostImpl::From(host)),
parent_host_view_(parent_host_view),
transparent_(transparent),
callback_(callback),
frame_rate_(frame_rate),
size_(initial_size),
painting_(painting),
is_showing_(false),
cursor_manager_(new content::CursorManager(this)),
mouse_wheel_phase_handler_(this),
backing_(new SkBitmap),
weak_ptr_factory_(this) {
DCHECK(render_widget_host_);
DCHECK(!render_widget_host_->GetView());
current_device_scale_factor_ = kDefaultScaleFactor;
delegated_frame_host_allocator_.GenerateId();
delegated_frame_host_allocation_ =
delegated_frame_host_allocator_.GetCurrentLocalSurfaceIdAllocation();
compositor_allocator_.GenerateId();
compositor_allocation_ =
compositor_allocator_.GetCurrentLocalSurfaceIdAllocation();
delegated_frame_host_client_ =
std::make_unique<ElectronDelegatedFrameHostClient>(this);
delegated_frame_host_ = std::make_unique<content::DelegatedFrameHost>(
AllocateFrameSinkId(), delegated_frame_host_client_.get(),
true /* should_register_frame_sink_id */);
root_layer_ = std::make_unique<ui::Layer>(ui::LAYER_SOLID_COLOR);
bool opaque = SkColorGetA(background_color_) == SK_AlphaOPAQUE;
GetRootLayer()->SetFillsBoundsOpaquely(opaque);
GetRootLayer()->SetColor(background_color_);
ui::ContextFactory* context_factory = content::GetContextFactory();
compositor_ = std::make_unique<ui::Compositor>(
context_factory->AllocateFrameSinkId(), context_factory,
base::ThreadTaskRunnerHandle::Get(), false /* enable_pixel_canvas */,
false /* use_external_begin_frame_control */);
compositor_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
compositor_->SetDelegate(this);
compositor_->SetRootLayer(root_layer_.get());
ResizeRootLayer(false);
render_widget_host_->SetView(this);
if (content::GpuDataManager::GetInstance()->HardwareAccelerationEnabled()) {
video_consumer_ = std::make_unique<OffScreenVideoConsumer>(
this, base::BindRepeating(&OffScreenRenderWidgetHostView::OnPaint,
weak_ptr_factory_.GetWeakPtr()));
video_consumer_->SetActive(IsPainting());
video_consumer_->SetFrameRate(GetFrameRate());
}
}
OffScreenRenderWidgetHostView::~OffScreenRenderWidgetHostView() {
// 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();
compositor_.reset();
root_layer_.reset();
}
content::BrowserAccessibilityManager*
OffScreenRenderWidgetHostView::CreateBrowserAccessibilityManager(
content::BrowserAccessibilityDelegate*,
bool) {
return nullptr;
}
void OffScreenRenderWidgetHostView::InitAsChild(gfx::NativeView) {
DCHECK(parent_host_view_);
if (parent_host_view_->child_host_view_) {
parent_host_view_->child_host_view_->CancelWidget();
}
parent_host_view_->set_child_host_view(this);
parent_host_view_->Hide();
ResizeRootLayer(false);
SetPainting(parent_host_view_->IsPainting());
}
void OffScreenRenderWidgetHostView::SetSize(const gfx::Size& size) {
size_ = size;
SynchronizeVisualProperties();
}
void OffScreenRenderWidgetHostView::SetBounds(const gfx::Rect& new_bounds) {
SetSize(new_bounds.size());
}
gfx::NativeView OffScreenRenderWidgetHostView::GetNativeView() {
return gfx::NativeView();
}
gfx::NativeViewAccessible
OffScreenRenderWidgetHostView::GetNativeViewAccessible() {
return gfx::NativeViewAccessible();
}
ui::TextInputClient* OffScreenRenderWidgetHostView::GetTextInputClient() {
return nullptr;
}
void OffScreenRenderWidgetHostView::Focus() {}
bool OffScreenRenderWidgetHostView::HasFocus() {
return false;
}
bool OffScreenRenderWidgetHostView::IsSurfaceAvailableForCopy() {
return GetDelegatedFrameHost()->CanCopyFromCompositingSurface();
}
void OffScreenRenderWidgetHostView::Show() {
if (is_showing_)
return;
is_showing_ = true;
delegated_frame_host_->AttachToCompositor(compositor_.get());
delegated_frame_host_->WasShown(
GetLocalSurfaceIdAllocation().local_surface_id(),
GetRootLayer()->bounds().size(), {});
if (render_widget_host_)
render_widget_host_->WasShown({});
}
void OffScreenRenderWidgetHostView::Hide() {
if (!is_showing_)
return;
if (render_widget_host_)
render_widget_host_->WasHidden();
// TODO(deermichel): correct or kOther?
GetDelegatedFrameHost()->WasHidden(
content::DelegatedFrameHost::HiddenCause::kOccluded);
GetDelegatedFrameHost()->DetachFromCompositor();
is_showing_ = false;
}
bool OffScreenRenderWidgetHostView::IsShowing() {
return is_showing_;
}
void OffScreenRenderWidgetHostView::EnsureSurfaceSynchronizedForWebTest() {
++latest_capture_sequence_number_;
SynchronizeVisualProperties();
}
gfx::Rect OffScreenRenderWidgetHostView::GetViewBounds() {
if (IsPopupWidget())
return popup_position_;
return gfx::Rect(size_);
}
void OffScreenRenderWidgetHostView::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);
if (render_widget_host_ && render_widget_host_->owner_delegate()) {
render_widget_host_->owner_delegate()->SetBackgroundOpaque(
SkColorGetA(color) == SK_AlphaOPAQUE);
}
}
base::Optional<SkColor> OffScreenRenderWidgetHostView::GetBackgroundColor() {
return background_color_;
}
void OffScreenRenderWidgetHostView::UpdateBackgroundColor() {
NOTREACHED();
}
gfx::Size OffScreenRenderWidgetHostView::GetVisibleViewportSize() {
return size_;
}
void OffScreenRenderWidgetHostView::SetInsets(const gfx::Insets& insets) {}
blink::mojom::PointerLockResult OffScreenRenderWidgetHostView::LockMouse(
bool request_unadjusted_movement) {
return blink::mojom::PointerLockResult::kUnsupportedOptions;
}
blink::mojom::PointerLockResult OffScreenRenderWidgetHostView::ChangeMouseLock(
bool request_unadjusted_movement) {
return blink::mojom::PointerLockResult::kUnsupportedOptions;
}
void OffScreenRenderWidgetHostView::UnlockMouse() {}
void OffScreenRenderWidgetHostView::TakeFallbackContentFrom(
content::RenderWidgetHostView* view) {
DCHECK(!static_cast<content::RenderWidgetHostViewBase*>(view)
->IsRenderWidgetHostViewChildFrame());
OffScreenRenderWidgetHostView* view_osr =
static_cast<OffScreenRenderWidgetHostView*>(view);
SetBackgroundColor(view_osr->background_color_);
if (GetDelegatedFrameHost() && view_osr->GetDelegatedFrameHost()) {
GetDelegatedFrameHost()->TakeFallbackContentFrom(
view_osr->GetDelegatedFrameHost());
}
host()->GetContentRenderingTimeoutFrom(view_osr->host());
}
void OffScreenRenderWidgetHostView::ResetFallbackToFirstNavigationSurface() {
GetDelegatedFrameHost()->ResetFallbackToFirstNavigationSurface();
}
void OffScreenRenderWidgetHostView::InitAsPopup(
content::RenderWidgetHostView* parent_host_view,
const gfx::Rect& pos) {
DCHECK_EQ(parent_host_view_, parent_host_view);
DCHECK_EQ(widget_type_, content::WidgetType::kPopup);
if (parent_host_view_->popup_host_view_) {
parent_host_view_->popup_host_view_->CancelWidget();
}
parent_host_view_->set_popup_host_view(this);
parent_callback_ =
base::BindRepeating(&OffScreenRenderWidgetHostView::OnPopupPaint,
parent_host_view_->weak_ptr_factory_.GetWeakPtr());
popup_position_ = pos;
ResizeRootLayer(false);
SetPainting(parent_host_view_->IsPainting());
if (video_consumer_) {
video_consumer_->SizeChanged();
}
Show();
}
void OffScreenRenderWidgetHostView::InitAsFullscreen(
content::RenderWidgetHostView*) {}
void OffScreenRenderWidgetHostView::UpdateCursor(const content::WebCursor&) {}
content::CursorManager* OffScreenRenderWidgetHostView::GetCursorManager() {
return cursor_manager_.get();
}
void OffScreenRenderWidgetHostView::SetIsLoading(bool loading) {}
void OffScreenRenderWidgetHostView::TextInputStateChanged(
const ui::mojom::TextInputState& params) {}
void OffScreenRenderWidgetHostView::ImeCancelComposition() {}
void OffScreenRenderWidgetHostView::RenderProcessGone() {
Destroy();
}
void OffScreenRenderWidgetHostView::Destroy() {
if (!is_destroyed_) {
is_destroyed_ = true;
if (parent_host_view_ != nullptr) {
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();
}
for (auto* proxy_view : proxy_views_)
proxy_view->RemoveObserver();
Hide();
}
}
delete this;
}
void OffScreenRenderWidgetHostView::SetTooltipText(const base::string16&) {}
uint32_t OffScreenRenderWidgetHostView::GetCaptureSequenceNumber() const {
return latest_capture_sequence_number_;
}
void OffScreenRenderWidgetHostView::CopyFromSurface(
const gfx::Rect& src_rect,
const gfx::Size& output_size,
base::OnceCallback<void(const SkBitmap&)> callback) {
GetDelegatedFrameHost()->CopyFromCompositingSurface(src_rect, output_size,
std::move(callback));
}
void OffScreenRenderWidgetHostView::GetScreenInfo(
blink::ScreenInfo* screen_info) {
screen_info->depth = 24;
screen_info->depth_per_component = 8;
screen_info->orientation_angle = 0;
screen_info->device_scale_factor = current_device_scale_factor_;
screen_info->orientation_type =
blink::mojom::ScreenOrientation::kLandscapePrimary;
screen_info->rect = gfx::Rect(size_);
screen_info->available_rect = gfx::Rect(size_);
}
void OffScreenRenderWidgetHostView::TransformPointToRootSurface(
gfx::PointF* point) {}
gfx::Rect OffScreenRenderWidgetHostView::GetBoundsInRootWindow() {
return gfx::Rect(size_);
}
viz::SurfaceId OffScreenRenderWidgetHostView::GetCurrentSurfaceId() const {
return GetDelegatedFrameHost()
? GetDelegatedFrameHost()->GetCurrentSurfaceId()
: viz::SurfaceId();
}
std::unique_ptr<content::SyntheticGestureTarget>
OffScreenRenderWidgetHostView::CreateSyntheticGestureTarget() {
NOTIMPLEMENTED();
return nullptr;
}
void OffScreenRenderWidgetHostView::ImeCompositionRangeChanged(
const gfx::Range&,
const std::vector<gfx::Rect>&) {}
gfx::Size OffScreenRenderWidgetHostView::GetCompositorViewportPixelSize() {
return gfx::ScaleToCeiledSize(GetRequestedRendererSize(),
current_device_scale_factor_);
}
content::RenderWidgetHostViewBase*
OffScreenRenderWidgetHostView::CreateViewForWidget(
content::RenderWidgetHost* render_widget_host,
content::RenderWidgetHost* embedder_render_widget_host,
content::WebContentsView* web_contents_view) {
if (render_widget_host->GetView()) {
return static_cast<content::RenderWidgetHostViewBase*>(
render_widget_host->GetView());
}
OffScreenRenderWidgetHostView* embedder_host_view = nullptr;
if (embedder_render_widget_host) {
embedder_host_view = static_cast<OffScreenRenderWidgetHostView*>(
embedder_render_widget_host->GetView());
}
return new OffScreenRenderWidgetHostView(
transparent_, true, embedder_host_view->GetFrameRate(), callback_,
render_widget_host, embedder_host_view, size());
}
const viz::FrameSinkId& OffScreenRenderWidgetHostView::GetFrameSinkId() const {
return GetDelegatedFrameHost()->frame_sink_id();
}
void OffScreenRenderWidgetHostView::DidNavigate() {
ResizeRootLayer(true);
if (delegated_frame_host_)
delegated_frame_host_->DidNavigate();
}
bool OffScreenRenderWidgetHostView::TransformPointToCoordSpaceForView(
const gfx::PointF& point,
RenderWidgetHostViewBase* target_view,
gfx::PointF* transformed_point) {
if (target_view == this) {
*transformed_point = point;
return true;
}
return false;
}
void OffScreenRenderWidgetHostView::CancelWidget() {
if (render_widget_host_)
render_widget_host_->LostCapture();
Hide();
if (parent_host_view_) {
if (parent_host_view_->popup_host_view_ == this) {
parent_host_view_->set_popup_host_view(nullptr);
} else if (parent_host_view_->child_host_view_ == this) {
parent_host_view_->set_child_host_view(nullptr);
parent_host_view_->Show();
} else {
parent_host_view_->RemoveGuestHostView(this);
}
parent_host_view_ = nullptr;
}
if (render_widget_host_ && !is_destroyed_) {
is_destroyed_ = true;
// Results in a call to Destroy().
render_widget_host_->ShutdownAndDestroyWidget(true);
}
}
void OffScreenRenderWidgetHostView::AddGuestHostView(
OffScreenRenderWidgetHostView* guest_host) {
guest_host_views_.insert(guest_host);
}
void OffScreenRenderWidgetHostView::RemoveGuestHostView(
OffScreenRenderWidgetHostView* guest_host) {
guest_host_views_.erase(guest_host);
}
void OffScreenRenderWidgetHostView::AddViewProxy(OffscreenViewProxy* proxy) {
proxy->SetObserver(this);
proxy_views_.insert(proxy);
}
void OffScreenRenderWidgetHostView::RemoveViewProxy(OffscreenViewProxy* proxy) {
proxy->RemoveObserver();
proxy_views_.erase(proxy);
}
void OffScreenRenderWidgetHostView::ProxyViewDestroyed(
OffscreenViewProxy* proxy) {
proxy_views_.erase(proxy);
Invalidate();
}
std::unique_ptr<viz::HostDisplayClient>
OffScreenRenderWidgetHostView::CreateHostDisplayClient(
ui::Compositor* compositor) {
host_display_client_ = new OffScreenHostDisplayClient(
gfx::kNullAcceleratedWidget,
base::BindRepeating(&OffScreenRenderWidgetHostView::OnPaint,
weak_ptr_factory_.GetWeakPtr()));
host_display_client_->SetActive(IsPainting());
return base::WrapUnique(host_display_client_);
}
bool OffScreenRenderWidgetHostView::InstallTransparency() {
if (transparent_) {
SetBackgroundColor(SkColor());
compositor_->SetBackgroundColor(SK_ColorTRANSPARENT);
return true;
}
return false;
}
#if defined(OS_MAC)
void OffScreenRenderWidgetHostView::SetActive(bool active) {}
void OffScreenRenderWidgetHostView::ShowDefinitionForSelection() {}
void OffScreenRenderWidgetHostView::SpeakSelection() {}
void OffScreenRenderWidgetHostView::SetWindowFrameInScreen(
const gfx::Rect& rect) {}
bool OffScreenRenderWidgetHostView::UpdateNSViewAndDisplay() {
return false;
}
#endif
void OffScreenRenderWidgetHostView::OnPaint(const gfx::Rect& damage_rect,
const SkBitmap& bitmap) {
backing_ = std::make_unique<SkBitmap>();
backing_->allocN32Pixels(bitmap.width(), bitmap.height(), !transparent_);
bitmap.readPixels(backing_->pixmap());
if (IsPopupWidget() && parent_callback_) {
parent_callback_.Run(this->popup_position_);
} else {
CompositeFrame(damage_rect);
}
}
gfx::Size OffScreenRenderWidgetHostView::SizeInPixels() {
if (IsPopupWidget()) {
return gfx::ConvertSizeToPixel(current_device_scale_factor_,
popup_position_.size());
} else {
return gfx::ConvertSizeToPixel(current_device_scale_factor_,
GetViewBounds().size());
}
}
void OffScreenRenderWidgetHostView::CompositeFrame(
const gfx::Rect& damage_rect) {
HoldResize();
gfx::Size size_in_pixels = SizeInPixels();
SkBitmap frame;
// Optimize for the case when there is no popup
if (proxy_views_.size() == 0 && !popup_host_view_) {
frame = GetBacking();
} else {
frame.allocN32Pixels(size_in_pixels.width(), size_in_pixels.height(),
false);
if (!GetBacking().drawsNothing()) {
SkCanvas canvas(frame);
canvas.writePixels(GetBacking(), 0, 0);
if (popup_host_view_ && !popup_host_view_->GetBacking().drawsNothing()) {
gfx::Rect rect = popup_host_view_->popup_position_;
gfx::Point origin_in_pixels = gfx::ConvertPointToPixel(
current_device_scale_factor_, rect.origin());
canvas.writePixels(popup_host_view_->GetBacking(), origin_in_pixels.x(),
origin_in_pixels.y());
}
for (auto* proxy_view : proxy_views_) {
gfx::Rect rect = proxy_view->GetBounds();
gfx::Point origin_in_pixels = gfx::ConvertPointToPixel(
current_device_scale_factor_, rect.origin());
canvas.writePixels(*proxy_view->GetBitmap(), origin_in_pixels.x(),
origin_in_pixels.y());
}
}
}
paint_callback_running_ = true;
callback_.Run(gfx::IntersectRects(gfx::Rect(size_in_pixels), damage_rect),
frame);
paint_callback_running_ = false;
ReleaseResize();
}
void OffScreenRenderWidgetHostView::OnPopupPaint(const gfx::Rect& damage_rect) {
InvalidateBounds(
gfx::ConvertRectToPixel(current_device_scale_factor_, damage_rect));
}
void OffScreenRenderWidgetHostView::OnProxyViewPaint(
const gfx::Rect& damage_rect) {
InvalidateBounds(
gfx::ConvertRectToPixel(current_device_scale_factor_, damage_rect));
}
void OffScreenRenderWidgetHostView::HoldResize() {
if (!hold_resize_)
hold_resize_ = true;
}
void OffScreenRenderWidgetHostView::ReleaseResize() {
if (!hold_resize_)
return;
hold_resize_ = false;
if (pending_resize_) {
pending_resize_ = false;
base::PostTask(
FROM_HERE, {content::BrowserThread::UI},
base::BindOnce(
&OffScreenRenderWidgetHostView::SynchronizeVisualProperties,
weak_ptr_factory_.GetWeakPtr()));
}
}
void OffScreenRenderWidgetHostView::SynchronizeVisualProperties() {
if (hold_resize_) {
if (!pending_resize_)
pending_resize_ = true;
return;
}
ResizeRootLayer(true);
}
void OffScreenRenderWidgetHostView::SendMouseEvent(
const blink::WebMouseEvent& event) {
for (auto* proxy_view : proxy_views_) {
gfx::Rect bounds = proxy_view->GetBounds();
if (bounds.Contains(event.PositionInWidget().x(),
event.PositionInWidget().y())) {
blink::WebMouseEvent proxy_event(event);
proxy_event.SetPositionInWidget(
proxy_event.PositionInWidget().x() - bounds.x(),
proxy_event.PositionInWidget().y() - bounds.y());
ui::MouseEvent ui_event = UiMouseEventFromWebMouseEvent(proxy_event);
proxy_view->OnEvent(&ui_event);
return;
}
}
if (!IsPopupWidget()) {
if (popup_host_view_ &&
popup_host_view_->popup_position_.Contains(
event.PositionInWidget().x(), event.PositionInWidget().y())) {
blink::WebMouseEvent popup_event(event);
popup_event.SetPositionInWidget(
popup_event.PositionInWidget().x() -
popup_host_view_->popup_position_.x(),
popup_event.PositionInWidget().y() -
popup_host_view_->popup_position_.y());
popup_host_view_->ProcessMouseEvent(popup_event, ui::LatencyInfo());
return;
}
}
if (!render_widget_host_)
return;
render_widget_host_->ForwardMouseEvent(event);
}
void OffScreenRenderWidgetHostView::SendMouseWheelEvent(
const blink::WebMouseWheelEvent& event) {
for (auto* proxy_view : proxy_views_) {
gfx::Rect bounds = proxy_view->GetBounds();
if (bounds.Contains(event.PositionInWidget().x(),
event.PositionInWidget().y())) {
blink::WebMouseWheelEvent proxy_event(event);
proxy_event.SetPositionInWidget(
proxy_event.PositionInWidget().x() - bounds.x(),
proxy_event.PositionInWidget().y() - bounds.y());
ui::MouseWheelEvent ui_event =
UiMouseWheelEventFromWebMouseEvent(proxy_event);
proxy_view->OnEvent(&ui_event);
return;
}
}
blink::WebMouseWheelEvent mouse_wheel_event(event);
bool should_route_event =
render_widget_host_->delegate() &&
render_widget_host_->delegate()->GetInputEventRouter();
mouse_wheel_phase_handler_.SendWheelEndForTouchpadScrollingIfNeeded(
should_route_event);
mouse_wheel_phase_handler_.AddPhaseIfNeededAndScheduleEndEvent(
mouse_wheel_event, false);
if (!IsPopupWidget()) {
if (popup_host_view_) {
if (popup_host_view_->popup_position_.Contains(
mouse_wheel_event.PositionInWidget().x(),
mouse_wheel_event.PositionInWidget().y())) {
blink::WebMouseWheelEvent popup_mouse_wheel_event(mouse_wheel_event);
popup_mouse_wheel_event.SetPositionInWidget(
mouse_wheel_event.PositionInWidget().x() -
popup_host_view_->popup_position_.x(),
mouse_wheel_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.
base::PostTask(
FROM_HERE, {content::BrowserThread::UI},
base::BindOnce(&OffScreenRenderWidgetHostView::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(mouse_wheel_event.PositionInWidget().x(),
mouse_wheel_event.PositionInWidget().y())) {
blink::WebMouseWheelEvent guest_mouse_wheel_event(mouse_wheel_event);
guest_mouse_wheel_event.SetPositionInWidget(
mouse_wheel_event.PositionInWidget().x() - guest_bounds.x(),
mouse_wheel_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_)
return;
render_widget_host_->ForwardWheelEvent(event);
}
void OffScreenRenderWidgetHostView::SetPainting(bool painting) {
painting_ = painting;
if (popup_host_view_) {
popup_host_view_->SetPainting(painting);
}
for (auto* guest_host_view : guest_host_views_)
guest_host_view->SetPainting(painting);
if (video_consumer_) {
video_consumer_->SetActive(IsPainting());
} else if (host_display_client_) {
host_display_client_->SetActive(IsPainting());
}
}
bool OffScreenRenderWidgetHostView::IsPainting() const {
return painting_;
}
void OffScreenRenderWidgetHostView::SetFrameRate(int frame_rate) {
if (parent_host_view_) {
if (parent_host_view_->GetFrameRate() == GetFrameRate())
return;
frame_rate_ = parent_host_view_->GetFrameRate();
} else {
if (frame_rate <= 0)
frame_rate = 1;
if (frame_rate > 240)
frame_rate = 240;
frame_rate_ = frame_rate;
}
SetupFrameRate(true);
if (video_consumer_) {
video_consumer_->SetFrameRate(GetFrameRate());
}
for (auto* guest_host_view : guest_host_views_)
guest_host_view->SetFrameRate(frame_rate);
}
int OffScreenRenderWidgetHostView::GetFrameRate() const {
return frame_rate_;
}
ui::Compositor* OffScreenRenderWidgetHostView::GetCompositor() const {
return compositor_.get();
}
ui::Layer* OffScreenRenderWidgetHostView::GetRootLayer() const {
return root_layer_.get();
}
const viz::LocalSurfaceIdAllocation&
OffScreenRenderWidgetHostView::GetLocalSurfaceIdAllocation() const {
return delegated_frame_host_allocation_;
}
content::DelegatedFrameHost*
OffScreenRenderWidgetHostView::GetDelegatedFrameHost() const {
return delegated_frame_host_.get();
}
void OffScreenRenderWidgetHostView::SetupFrameRate(bool force) {
if (!force && frame_rate_threshold_us_ != 0)
return;
frame_rate_threshold_us_ = 1000000 / frame_rate_;
if (compositor_) {
compositor_->SetDisplayVSyncParameters(
base::TimeTicks::Now(),
base::TimeDelta::FromMicroseconds(frame_rate_threshold_us_));
}
}
void OffScreenRenderWidgetHostView::Invalidate() {
InvalidateBounds(gfx::Rect(GetRequestedRendererSize()));
}
void OffScreenRenderWidgetHostView::InvalidateBounds(const gfx::Rect& bounds) {
CompositeFrame(bounds);
}
void OffScreenRenderWidgetHostView::ResizeRootLayer(bool force) {
SetupFrameRate(false);
display::Display display =
display::Screen::GetScreen()->GetDisplayNearestView(GetNativeView());
const float scaleFactor = display.device_scale_factor();
const bool scaleFactorDidChange =
(scaleFactor != current_device_scale_factor_);
current_device_scale_factor_ = scaleFactor;
gfx::Size size;
if (!IsPopupWidget())
size = GetViewBounds().size();
else
size = popup_position_.size();
if (!force && !scaleFactorDidChange &&
size == GetRootLayer()->bounds().size())
return;
GetRootLayer()->SetBounds(gfx::Rect(size));
const gfx::Size& size_in_pixels =
gfx::ConvertSizeToPixel(current_device_scale_factor_, size);
if (compositor_) {
compositor_allocator_.GenerateId();
compositor_allocation_ =
compositor_allocator_.GetCurrentLocalSurfaceIdAllocation();
compositor_->SetScaleAndSize(current_device_scale_factor_, size_in_pixels,
compositor_allocation_);
}
delegated_frame_host_allocator_.GenerateId();
delegated_frame_host_allocation_ =
delegated_frame_host_allocator_.GetCurrentLocalSurfaceIdAllocation();
GetDelegatedFrameHost()->EmbedSurface(
delegated_frame_host_allocation_.local_surface_id(), size,
cc::DeadlinePolicy::UseDefaultDeadline());
// Note that |render_widget_host_| will retrieve resize parameters from the
// DelegatedFrameHost, so it must have SynchronizeVisualProperties called
// after.
if (render_widget_host_) {
render_widget_host_->SynchronizeVisualProperties();
}
}
viz::FrameSinkId OffScreenRenderWidgetHostView::AllocateFrameSinkId() {
return viz::FrameSinkId(
base::checked_cast<uint32_t>(render_widget_host_->GetProcess()->GetID()),
base::checked_cast<uint32_t>(render_widget_host_->GetRoutingID()));
}
void OffScreenRenderWidgetHostView::UpdateBackgroundColorFromRenderer(
SkColor color) {
if (color == background_color_)
return;
background_color_ = color;
bool opaque = SkColorGetA(color) == SK_AlphaOPAQUE;
GetRootLayer()->SetFillsBoundsOpaquely(opaque);
GetRootLayer()->SetColor(color);
}
} // namespace electron