2018-11-30 22:52:05 +03:00
|
|
|
/* -*- Mode: c++; c-basic-offset: 2; tab-width: 20; indent-tabs-mode: nil; -*-
|
2018-11-30 18:39:55 +03:00
|
|
|
* vim: set sw=2 ts=4 expandtab:
|
2012-05-21 15:12:37 +04:00
|
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
2010-06-04 00:56:36 +04:00
|
|
|
|
|
|
|
|
#ifndef NSWINDOW_H_
|
|
|
|
|
#define NSWINDOW_H_
|
|
|
|
|
|
|
|
|
|
#include "nsBaseWidget.h"
|
|
|
|
|
#include "gfxPoint.h"
|
2020-07-20 19:06:59 +03:00
|
|
|
#include "nsIUserIdleServiceInternal.h"
|
2010-06-04 00:56:36 +04:00
|
|
|
#include "nsTArray.h"
|
Bug 1307820 - Implement per-GeckoView messaging; r=snorp r=sebastian
Bug 1307820 - 1a. Move GeckoApp EventDispatcher to GeckoView; r=snorp
Make it a GeckoView-specific EventDispatcher instead of
GeckoApp-specific, so that GeckoView consumers can benefit from a
per-view EventDispatcher. In addition, a few events like Gecko:Ready are
moved back to the global EventDispatcher because that makes more sense.
Bug 1307820 - 1b. Don't use GeckoApp EventDispatcher during inflation; r=snorp
During layout inflation, we don't yet have GeckoView and therefore the
GeckoView EventDispatcher, so we should not register events until later,
typically during onAttachedToWindow.
Bug 1307820 - 2. Introduce GeckoBundle; r=snorp
The Android Bundle class has several disadvantages when used for holding
structured data from JS.
The most obvious one is the differentiation between int and double,
which doesn't exist in JS. So when a JS number is converted to either a
Bundle int or double, we run the risk of making a wrong conversion,
resulting in a type mismatch exception when Java uses the Bundle. This
extends to number arrays from JS.
There is one more gotcha when using arrays. When we receive an empty
array from JS, there is no way for us to determine the type of the
array, because even empty arrays in Java have types. We are forced to
pick an arbitrary type like boolean[], which can easily result in a type
mismatch exception when using the array on the Java side.
In addition, Bundle is fairly cumbersome, and we cannot access the inner
structures of Bundle from Java or JNI, making it harder to use.
With these factors in mind, this patch introduces GeckoBundle as a
better choice for Gecko/Java communication. It is almost fully
API-compatible with the Android Bundle; only the Bundle array methods
are different. It resolves the numbers problem by performing conversions
if necessary, and it is a lot more lightweight than Bundle.
Bug 1307820 - 3. Convert BundleEventListener to use GeckoBundle; r=snorp
Convert BundleEventListener from using Bundle to using GeckoBundle.
Because NativeJSContainer still only supports Bundle, we do an extra
conversion when sending Bundle messages, but eventually, as we eliminate
the use of NativeJSContainer, that will go away as well.
Bug 1307820 - 4. Introduce EventDispatcher interfaces; r=snorp
Introduce several new XPCOM interfaces for the new EventDispatcher API,
these interfaces are mostly mirrored after their Java counterparts.
* nsIAndroidEventDispatcher is the main interface for
registering/unregistering listeners and for dispatching events from
JS/C++.
* nsIAndroidEventListener is the interface that JS/C++ clients implement
to receive events.
* nsIAndroidEventCallback is the interface that JS/C++ clients implement
to receive responses from dispatched events.
* nsIAndroidView is the new interface that every window receives
that is specific to the window/GeckoView pair. It is passed to chrome
scripts through window arguments.
Bug 1307820 - 5. Remove EventDispatcher references from gfx code; r=snorp
EventDispatcher was used for JPZC, but NPZC doesn't use it anymore.
Bug 1307820 - 6. General JNI template improvements; r=snorp
This patch includes several improvements to the JNI templates.
* Context::RawClassRef is removed to avoid misuse, as Context::ClassRef
should be used instead.
* Fix a compile error, in certain usages, in the DisposeNative overload
in NativeStub.
* Add Ref::IsInstanceOf and Context::IsInstanceOf to mirror the
JNIEnv::IsInstanceOf call.
* Add Ref::operator* and Context::operator* to provide an easy way to
get a Context object.
* Add built-in declarations for boxed Java objects (e.g. Boolean,
Integer, etc).
* Add ObjectArray::New for creating new object arrays of specific types.
* Add lvalue qualifiers to LocalRef::operator= and GlobalRef::operator=,
to prevent accidentally assigning to rvalues. (e.g.
`objectArray->GetElement(0) = newObject;`, which won't work as intended.)
Bug 1307820 - 7. Support ownership through RefPtr for native JNI objects; r=snorp
In addition to direct ownership and weak pointer ownership, add a third
ownership model where a native JNI object owns a RefPtr that holds a
strong reference to the actual C++ object. This ownership model works
well with ref-counted objects such as XPCOM objects, and is activated
through the presence of public members AddRef() and Release() in the C++
object.
Bug 1307820 - 8. Implement Gecko-side EventDispatcher; r=snorp
Add a skeletal implementation of EventDispatcher on the Gecko side.
Each widget::EventDispatcher will be associated with a Java
EventDispatcher, so events can be dispatched from Gecko to Java and vice
versa. AndroidBridge and nsWindow will implement
nsIAndroidEventDispatcher through widget::EventDispatcher.
Other patches will add more complete functionality such as
GeckoBundle/JSObject translation and support for callbacks.
Bug 1307820 - 9. Implement dispatching between Gecko/Java; r=snorp
Implement translation between JSObject and GeckoBundle, and use that for
dispatching events from Gecko to Java and vice versa.
Bug 1307820 - 10. Implement callback support; r=snorp
Implement callback support for both Gecko-to-Java events and
Java-to-Gecko events.
For Gecko-to-Java, we translate nsIAndroidEventCallback to a Java
EventCallback through NativeCallbackDelegate and pass it to the Java
listener.
For Java-to-Gecko, we translate EventCallback to a
nsIAndroidEventCallback through JavaCallbackDelegate and pass it to the
Gecko listener. There is another JavaCallbackDelegate on the Java side
that redirects the callback to a particular thread. For example, if the
event was dispatched from the UI thread, we make sure the callback
happens on the UI thread as well.
Bug 1307820 - 11. Add BundleEventListener support for Gecko thread; r=snorp
Add support for BundleEventListener on the Gecko thread, so that we can
use it to replace any existing GeckoEventListener or NativeEventListener
implementations that require the listener be run synchronously on the
Gecko thread.
Bug 1307820 - 12. Add global EventDispatcher in AndroidBridge; r=snorp
Add an instance of EventDispatcher to AndroidBridge to act as a global
event dispatcher.
Bug 1307820 - 13. Add per-nsWindow EventDispatcher; r=snorp
Add an instance of EventDispatcher to each nsWindow through an
AndroidView object, which implements nsIAndroidView. The nsIAndroidView
is passed to the chrome script through the window argument when opening
the window.
Bug 1307820 - 14. Update auto-generated bindings; r=me
Bug 1307820 - 15. Update testEventDispatcher; r=snorp
Update testEventDispatcher to include new functionalities in
EventDisptcher.
* Add tests for dispatching events to UI/background thread through
nsIAndroidEventDispatcher::dispatch.
* Add tests for dispatching events to UI/background thread through
EventDispatcher.dispatch.
* Add tests for dispatching events to Gecko thread through
EventDispatcher.dispatch.
Each kind of test exercises both the global EventDispatcher through
EventDispatcher.getInstance() and the per-GeckoView EventDispatcher
through GeckoApp.getEventDispatcher().
2016-11-14 16:29:50 +03:00
|
|
|
#include "EventDispatcher.h"
|
2013-10-22 17:27:36 +04:00
|
|
|
#include "mozilla/EventForwards.h"
|
2020-09-22 00:48:26 +03:00
|
|
|
#include "mozilla/java/GeckoSessionNatives.h"
|
2020-08-31 20:30:57 +03:00
|
|
|
#include "mozilla/java/WebResponseWrappers.h"
|
2020-04-10 19:38:48 +03:00
|
|
|
#include "mozilla/MozPromise.h"
|
2016-08-19 01:03:04 +03:00
|
|
|
#include "mozilla/Mutex.h"
|
2013-08-13 17:32:03 +04:00
|
|
|
#include "mozilla/StaticPtr.h"
|
2013-10-22 17:27:36 +04:00
|
|
|
#include "mozilla/TextRange.h"
|
2015-09-21 17:13:32 +03:00
|
|
|
#include "mozilla/UniquePtr.h"
|
2012-02-10 11:55:13 +04:00
|
|
|
|
2012-04-19 21:49:31 +04:00
|
|
|
struct ANPEvent;
|
|
|
|
|
|
2010-06-04 00:56:36 +04:00
|
|
|
namespace mozilla {
|
2015-11-13 23:10:51 +03:00
|
|
|
class WidgetTouchEvent;
|
2012-03-14 08:15:11 +04:00
|
|
|
|
|
|
|
|
namespace layers {
|
2016-03-22 21:08:38 +03:00
|
|
|
class CompositorBridgeChild;
|
2012-07-31 04:42:26 +04:00
|
|
|
class LayerManager;
|
2013-07-30 22:03:40 +04:00
|
|
|
class APZCTreeManager;
|
2017-04-06 01:42:50 +03:00
|
|
|
class UiCompositorControllerChild;
|
2012-03-14 08:15:11 +04:00
|
|
|
} // namespace layers
|
2017-03-01 23:29:30 +03:00
|
|
|
|
|
|
|
|
namespace widget {
|
2020-09-22 00:48:26 +03:00
|
|
|
class AndroidView;
|
2017-03-01 23:29:30 +03:00
|
|
|
class GeckoEditableSupport;
|
2020-09-22 00:48:26 +03:00
|
|
|
class GeckoViewSupport;
|
|
|
|
|
class LayerViewSupport;
|
|
|
|
|
class NPZCSupport;
|
Bug 1741156 - Initial GPU process implementation on Android. r=aosmond,agi
Declare a GPU process and corresponding Service in the
AndroidManifest. This is of a new class GeckoServiceGpuProcess which
inherits from GeckoServiceChildProcess, and provides a binder
interface ICompositorSurfaceManager which allows the parent process to
set the compositor Surface for a given widget ID, and the compositor
in the GPU process to look up the Surface for a widget ID. The
ICompositorSurfaceManager interface is exposed to the parent process
through a new method getCompositorSurfaceManager() in the
IChildProcess interface.
Add a new connection type for GPU processes to GeckoProcessManager,
along with a function to look up the GPU process connection and fetch
the ICompositorSurfaceManager binder. When the GPU process is launched
we store the returned binder in the GPUProcessHost, and when each
widget's compositor is created we store a reference to the binder in
the UiCompositorControllerChild.
Each nsWindow is given a unique ID, and whenever the Surface changes
due to an Android resume event, it sends the new surface for that ID
to the GPU process (if enabled) by calling
ICompositorSurfaceManager.onSurfaceChanged().
Stop inheriting AndroidCompositorWidget from InProcessCompositorWidget
and instead inherit from CompositorWidget directly. This class holds a
reference to the Surface that will be rendered in to. The
CompositorBridgeParent notifies the CompositorWidget whenever it has
been resumed, allowing it to fetch the new Surface. For the
cross-process CompositorWidgetParent implementation it fetches that
Surface from the CompositorSurfaceManagerService, whereas the
InProcessAndroidCompositorWidget can read it directly from the real
widget.
AndroidCompositorWidget::GetClientSize() can now calculate its size
from the Surface, rather than racily reading the value from the
nsWindow. This means RenderCompositorEGL and RenderCompositorOGLSWGL
can now use GetClientSize() again rather than querying their own size
from the Surface.
With this patch, setting layers.gpu-process.enabled to true will cause
us to launch a GPU process and render from it. We do not yet
gracefully recover from a GPU process crash, nor can we render
anything using SurfaceTextures (eg video or webgl). Those will come in
future patches.
Differential Revision: https://phabricator.services.mozilla.com/D131231
2021-11-29 23:52:31 +03:00
|
|
|
class PlatformCompositorWidgetDelegate;
|
2017-03-01 23:29:30 +03:00
|
|
|
} // namespace widget
|
2017-04-06 01:42:50 +03:00
|
|
|
|
|
|
|
|
namespace ipc {
|
|
|
|
|
class Shmem;
|
|
|
|
|
} // namespace ipc
|
2018-09-20 02:01:40 +03:00
|
|
|
|
|
|
|
|
namespace a11y {
|
|
|
|
|
class SessionAccessibility;
|
2020-09-22 00:48:26 +03:00
|
|
|
} // namespace a11y
|
2010-06-04 00:56:36 +04:00
|
|
|
} // namespace mozilla
|
|
|
|
|
|
2017-07-01 20:59:21 +03:00
|
|
|
class nsWindow final : public nsBaseWidget {
|
2014-08-26 23:07:59 +04:00
|
|
|
private:
|
|
|
|
|
virtual ~nsWindow();
|
|
|
|
|
|
2010-06-04 00:56:36 +04:00
|
|
|
public:
|
2021-07-23 01:58:57 +03:00
|
|
|
using nsBaseWidget::GetWindowRenderer;
|
2010-12-07 05:05:52 +03:00
|
|
|
|
2010-06-04 00:56:36 +04:00
|
|
|
nsWindow();
|
|
|
|
|
|
2018-02-12 23:44:40 +03:00
|
|
|
NS_INLINE_DECL_REFCOUNTING_INHERITED(nsWindow, nsBaseWidget)
|
2010-06-04 00:56:36 +04:00
|
|
|
|
2015-09-21 17:13:32 +03:00
|
|
|
static void InitNatives();
|
2018-03-09 20:34:38 +03:00
|
|
|
void OnGeckoViewReady();
|
2020-04-10 19:38:48 +03:00
|
|
|
RefPtr<mozilla::MozPromise<bool, bool, false>> OnLoadRequest(
|
|
|
|
|
nsIURI* aUri, int32_t aWindowType, int32_t aFlags,
|
2020-05-19 20:05:42 +03:00
|
|
|
nsIPrincipal* aTriggeringPrincipal, bool aHasUserGesture,
|
|
|
|
|
bool aIsTopLevel);
|
2015-12-24 06:03:34 +03:00
|
|
|
|
2022-07-15 23:44:55 +03:00
|
|
|
void OnUpdateSessionStore(mozilla::jni::Object::Param aBundle);
|
|
|
|
|
|
2015-12-24 06:03:34 +03:00
|
|
|
private:
|
Bug 1741156 - Initial GPU process implementation on Android. r=aosmond,agi
Declare a GPU process and corresponding Service in the
AndroidManifest. This is of a new class GeckoServiceGpuProcess which
inherits from GeckoServiceChildProcess, and provides a binder
interface ICompositorSurfaceManager which allows the parent process to
set the compositor Surface for a given widget ID, and the compositor
in the GPU process to look up the Surface for a widget ID. The
ICompositorSurfaceManager interface is exposed to the parent process
through a new method getCompositorSurfaceManager() in the
IChildProcess interface.
Add a new connection type for GPU processes to GeckoProcessManager,
along with a function to look up the GPU process connection and fetch
the ICompositorSurfaceManager binder. When the GPU process is launched
we store the returned binder in the GPUProcessHost, and when each
widget's compositor is created we store a reference to the binder in
the UiCompositorControllerChild.
Each nsWindow is given a unique ID, and whenever the Surface changes
due to an Android resume event, it sends the new surface for that ID
to the GPU process (if enabled) by calling
ICompositorSurfaceManager.onSurfaceChanged().
Stop inheriting AndroidCompositorWidget from InProcessCompositorWidget
and instead inherit from CompositorWidget directly. This class holds a
reference to the Surface that will be rendered in to. The
CompositorBridgeParent notifies the CompositorWidget whenever it has
been resumed, allowing it to fetch the new Surface. For the
cross-process CompositorWidgetParent implementation it fetches that
Surface from the CompositorSurfaceManagerService, whereas the
InProcessAndroidCompositorWidget can read it directly from the real
widget.
AndroidCompositorWidget::GetClientSize() can now calculate its size
from the Surface, rather than racily reading the value from the
nsWindow. This means RenderCompositorEGL and RenderCompositorOGLSWGL
can now use GetClientSize() again rather than querying their own size
from the Surface.
With this patch, setting layers.gpu-process.enabled to true will cause
us to launch a GPU process and render from it. We do not yet
gracefully recover from a GPU process crash, nor can we render
anything using SurfaceTextures (eg video or webgl). Those will come in
future patches.
Differential Revision: https://phabricator.services.mozilla.com/D131231
2021-11-29 23:52:31 +03:00
|
|
|
// Unique ID given to each widget, used to map Surfaces to widgets
|
|
|
|
|
// in the CompositorSurfaceManager.
|
|
|
|
|
int32_t mWidgetId;
|
2016-09-29 09:23:56 +03:00
|
|
|
|
Bug 1307820 - Implement per-GeckoView messaging; r=snorp r=sebastian
Bug 1307820 - 1a. Move GeckoApp EventDispatcher to GeckoView; r=snorp
Make it a GeckoView-specific EventDispatcher instead of
GeckoApp-specific, so that GeckoView consumers can benefit from a
per-view EventDispatcher. In addition, a few events like Gecko:Ready are
moved back to the global EventDispatcher because that makes more sense.
Bug 1307820 - 1b. Don't use GeckoApp EventDispatcher during inflation; r=snorp
During layout inflation, we don't yet have GeckoView and therefore the
GeckoView EventDispatcher, so we should not register events until later,
typically during onAttachedToWindow.
Bug 1307820 - 2. Introduce GeckoBundle; r=snorp
The Android Bundle class has several disadvantages when used for holding
structured data from JS.
The most obvious one is the differentiation between int and double,
which doesn't exist in JS. So when a JS number is converted to either a
Bundle int or double, we run the risk of making a wrong conversion,
resulting in a type mismatch exception when Java uses the Bundle. This
extends to number arrays from JS.
There is one more gotcha when using arrays. When we receive an empty
array from JS, there is no way for us to determine the type of the
array, because even empty arrays in Java have types. We are forced to
pick an arbitrary type like boolean[], which can easily result in a type
mismatch exception when using the array on the Java side.
In addition, Bundle is fairly cumbersome, and we cannot access the inner
structures of Bundle from Java or JNI, making it harder to use.
With these factors in mind, this patch introduces GeckoBundle as a
better choice for Gecko/Java communication. It is almost fully
API-compatible with the Android Bundle; only the Bundle array methods
are different. It resolves the numbers problem by performing conversions
if necessary, and it is a lot more lightweight than Bundle.
Bug 1307820 - 3. Convert BundleEventListener to use GeckoBundle; r=snorp
Convert BundleEventListener from using Bundle to using GeckoBundle.
Because NativeJSContainer still only supports Bundle, we do an extra
conversion when sending Bundle messages, but eventually, as we eliminate
the use of NativeJSContainer, that will go away as well.
Bug 1307820 - 4. Introduce EventDispatcher interfaces; r=snorp
Introduce several new XPCOM interfaces for the new EventDispatcher API,
these interfaces are mostly mirrored after their Java counterparts.
* nsIAndroidEventDispatcher is the main interface for
registering/unregistering listeners and for dispatching events from
JS/C++.
* nsIAndroidEventListener is the interface that JS/C++ clients implement
to receive events.
* nsIAndroidEventCallback is the interface that JS/C++ clients implement
to receive responses from dispatched events.
* nsIAndroidView is the new interface that every window receives
that is specific to the window/GeckoView pair. It is passed to chrome
scripts through window arguments.
Bug 1307820 - 5. Remove EventDispatcher references from gfx code; r=snorp
EventDispatcher was used for JPZC, but NPZC doesn't use it anymore.
Bug 1307820 - 6. General JNI template improvements; r=snorp
This patch includes several improvements to the JNI templates.
* Context::RawClassRef is removed to avoid misuse, as Context::ClassRef
should be used instead.
* Fix a compile error, in certain usages, in the DisposeNative overload
in NativeStub.
* Add Ref::IsInstanceOf and Context::IsInstanceOf to mirror the
JNIEnv::IsInstanceOf call.
* Add Ref::operator* and Context::operator* to provide an easy way to
get a Context object.
* Add built-in declarations for boxed Java objects (e.g. Boolean,
Integer, etc).
* Add ObjectArray::New for creating new object arrays of specific types.
* Add lvalue qualifiers to LocalRef::operator= and GlobalRef::operator=,
to prevent accidentally assigning to rvalues. (e.g.
`objectArray->GetElement(0) = newObject;`, which won't work as intended.)
Bug 1307820 - 7. Support ownership through RefPtr for native JNI objects; r=snorp
In addition to direct ownership and weak pointer ownership, add a third
ownership model where a native JNI object owns a RefPtr that holds a
strong reference to the actual C++ object. This ownership model works
well with ref-counted objects such as XPCOM objects, and is activated
through the presence of public members AddRef() and Release() in the C++
object.
Bug 1307820 - 8. Implement Gecko-side EventDispatcher; r=snorp
Add a skeletal implementation of EventDispatcher on the Gecko side.
Each widget::EventDispatcher will be associated with a Java
EventDispatcher, so events can be dispatched from Gecko to Java and vice
versa. AndroidBridge and nsWindow will implement
nsIAndroidEventDispatcher through widget::EventDispatcher.
Other patches will add more complete functionality such as
GeckoBundle/JSObject translation and support for callbacks.
Bug 1307820 - 9. Implement dispatching between Gecko/Java; r=snorp
Implement translation between JSObject and GeckoBundle, and use that for
dispatching events from Gecko to Java and vice versa.
Bug 1307820 - 10. Implement callback support; r=snorp
Implement callback support for both Gecko-to-Java events and
Java-to-Gecko events.
For Gecko-to-Java, we translate nsIAndroidEventCallback to a Java
EventCallback through NativeCallbackDelegate and pass it to the Java
listener.
For Java-to-Gecko, we translate EventCallback to a
nsIAndroidEventCallback through JavaCallbackDelegate and pass it to the
Gecko listener. There is another JavaCallbackDelegate on the Java side
that redirects the callback to a particular thread. For example, if the
event was dispatched from the UI thread, we make sure the callback
happens on the UI thread as well.
Bug 1307820 - 11. Add BundleEventListener support for Gecko thread; r=snorp
Add support for BundleEventListener on the Gecko thread, so that we can
use it to replace any existing GeckoEventListener or NativeEventListener
implementations that require the listener be run synchronously on the
Gecko thread.
Bug 1307820 - 12. Add global EventDispatcher in AndroidBridge; r=snorp
Add an instance of EventDispatcher to AndroidBridge to act as a global
event dispatcher.
Bug 1307820 - 13. Add per-nsWindow EventDispatcher; r=snorp
Add an instance of EventDispatcher to each nsWindow through an
AndroidView object, which implements nsIAndroidView. The nsIAndroidView
is passed to the chrome script through the window argument when opening
the window.
Bug 1307820 - 14. Update auto-generated bindings; r=me
Bug 1307820 - 15. Update testEventDispatcher; r=snorp
Update testEventDispatcher to include new functionalities in
EventDisptcher.
* Add tests for dispatching events to UI/background thread through
nsIAndroidEventDispatcher::dispatch.
* Add tests for dispatching events to UI/background thread through
EventDispatcher.dispatch.
* Add tests for dispatching events to Gecko thread through
EventDispatcher.dispatch.
Each kind of test exercises both the global EventDispatcher through
EventDispatcher.getInstance() and the per-GeckoView EventDispatcher
through GeckoApp.getEventDispatcher().
2016-11-14 16:29:50 +03:00
|
|
|
private:
|
2020-09-22 00:48:26 +03:00
|
|
|
RefPtr<mozilla::widget::AndroidView> mAndroidView;
|
2017-03-01 23:29:30 +03:00
|
|
|
|
2016-08-19 01:03:04 +03:00
|
|
|
// Object that implements native LayerView calls.
|
2020-09-22 00:48:26 +03:00
|
|
|
// Owned by the Java Compositor instance.
|
|
|
|
|
mozilla::jni::NativeWeakPtr<mozilla::widget::LayerViewSupport>
|
|
|
|
|
mLayerViewSupport;
|
2016-01-15 21:05:45 +03:00
|
|
|
|
2017-11-22 22:12:22 +03:00
|
|
|
// Object that implements native NativePanZoomController calls.
|
|
|
|
|
// Owned by the Java NativePanZoomController instance.
|
2020-09-22 00:48:26 +03:00
|
|
|
mozilla::jni::NativeWeakPtr<mozilla::widget::NPZCSupport> mNPZCSupport;
|
2017-11-22 22:12:22 +03:00
|
|
|
|
2018-11-16 20:31:58 +03:00
|
|
|
// Object that implements native GeckoEditable calls.
|
|
|
|
|
// Strong referenced by the Java instance.
|
2020-09-22 00:48:26 +03:00
|
|
|
mozilla::jni::NativeWeakPtr<mozilla::widget::GeckoEditableSupport>
|
|
|
|
|
mEditableSupport;
|
2018-11-16 20:31:58 +03:00
|
|
|
mozilla::jni::Object::GlobalRef mEditableParent;
|
|
|
|
|
|
2012-04-20 20:49:50 +04:00
|
|
|
// Object that implements native SessionAccessibility calls.
|
|
|
|
|
// Strong referenced by the Java instance.
|
2020-09-22 00:48:26 +03:00
|
|
|
mozilla::jni::NativeWeakPtr<mozilla::a11y::SessionAccessibility>
|
|
|
|
|
mSessionAccessibility;
|
2010-06-04 00:56:36 +04:00
|
|
|
|
2017-03-01 23:29:30 +03:00
|
|
|
// Object that implements native GeckoView calls and associated states.
|
|
|
|
|
// nullptr for nsWindows that were not opened from GeckoView.
|
2020-09-22 00:48:26 +03:00
|
|
|
mozilla::jni::NativeWeakPtr<mozilla::widget::GeckoViewSupport>
|
|
|
|
|
mGeckoViewSupport;
|
2017-03-01 23:29:30 +03:00
|
|
|
|
2015-09-23 21:49:05 +03:00
|
|
|
mozilla::Atomic<bool, mozilla::ReleaseAcquire> mContentDocumentDisplayed;
|
2010-06-04 00:56:36 +04:00
|
|
|
|
2018-11-30 13:46:48 +03:00
|
|
|
public:
|
2015-11-13 12:37:02 +03:00
|
|
|
static already_AddRefed<nsWindow> From(nsPIDOMWindowOuter* aDOMWindow);
|
|
|
|
|
static already_AddRefed<nsWindow> From(nsIWidget* aWidget);
|
2010-06-04 00:56:36 +04:00
|
|
|
|
2016-01-26 04:30:55 +03:00
|
|
|
static nsWindow* TopWindow();
|
|
|
|
|
|
2018-11-16 20:30:26 +03:00
|
|
|
static mozilla::Modifiers GetModifiers(int32_t aMetaState);
|
|
|
|
|
static mozilla::TimeStamp GetEventTimeStamp(int64_t aEventTime);
|
|
|
|
|
|
2010-06-04 00:56:36 +04:00
|
|
|
void InitEvent(mozilla::WidgetGUIEvent& event,
|
|
|
|
|
LayoutDeviceIntPoint* aPoint = 0);
|
|
|
|
|
|
2018-04-25 23:04:14 +03:00
|
|
|
void UpdateOverscrollVelocity(const float aX, const float aY);
|
2011-11-15 07:12:14 +04:00
|
|
|
void UpdateOverscrollOffset(const float aX, const float aY);
|
|
|
|
|
|
2020-09-22 00:48:26 +03:00
|
|
|
mozilla::widget::EventDispatcher* GetEventDispatcher() const;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2020-08-31 20:30:57 +03:00
|
|
|
void PassExternalResponse(mozilla::java::WebResponse::Param aResponse);
|
|
|
|
|
|
2021-07-28 00:50:03 +03:00
|
|
|
void ShowDynamicToolbar();
|
|
|
|
|
|
2020-09-22 00:48:26 +03:00
|
|
|
void DetachNatives();
|
|
|
|
|
|
2023-04-04 07:00:09 +03:00
|
|
|
mozilla::Mutex& GetDestroyMutex() { return mDestroyMutex; }
|
|
|
|
|
|
2018-11-30 13:46:48 +03:00
|
|
|
//
|
2010-06-04 00:56:36 +04:00
|
|
|
// nsIWidget
|
2018-11-30 13:46:48 +03:00
|
|
|
//
|
|
|
|
|
|
2016-01-13 10:32:55 +03:00
|
|
|
using nsBaseWidget::Create; // for Create signature not overridden here
|
2020-03-25 18:13:43 +03:00
|
|
|
[[nodiscard]] virtual nsresult Create(nsIWidget* aParent,
|
|
|
|
|
nsNativeWidget aNativeParent,
|
|
|
|
|
const LayoutDeviceIntRect& aRect,
|
2023-01-24 02:58:41 +03:00
|
|
|
InitData* aInitData) override;
|
2016-08-10 03:04:11 +03:00
|
|
|
virtual void Destroy() override;
|
2016-12-16 02:54:11 +03:00
|
|
|
virtual void SetParent(nsIWidget* aNewParent) override;
|
2015-08-15 05:06:20 +03:00
|
|
|
virtual nsIWidget* GetParent(void) override;
|
|
|
|
|
virtual float GetDPI() override;
|
|
|
|
|
virtual double GetDefaultScaleInternal() override;
|
2016-12-21 03:12:54 +03:00
|
|
|
virtual void Show(bool aState) override;
|
2015-08-15 05:06:20 +03:00
|
|
|
virtual bool IsVisible() const override;
|
2023-05-23 13:30:05 +03:00
|
|
|
virtual void ConstrainPosition(DesktopIntPoint&) override;
|
2018-05-30 22:15:35 +03:00
|
|
|
virtual void Move(double aX, double aY) override;
|
|
|
|
|
virtual void Resize(double aWidth, double aHeight, bool aRepaint) override;
|
|
|
|
|
virtual void Resize(double aX, double aY, double aWidth, double aHeight,
|
2016-12-19 12:54:03 +03:00
|
|
|
bool aRepaint) override;
|
2015-08-15 05:06:20 +03:00
|
|
|
void SetZIndex(int32_t aZIndex) override;
|
2022-05-02 17:06:17 +03:00
|
|
|
virtual nsSizeMode SizeMode() override { return mSizeMode; }
|
2016-08-22 02:15:49 +03:00
|
|
|
virtual void SetSizeMode(nsSizeMode aMode) override;
|
2016-12-19 12:54:16 +03:00
|
|
|
virtual void Enable(bool aState) override;
|
2015-08-15 05:06:20 +03:00
|
|
|
virtual bool IsEnabled() const override;
|
2016-12-20 01:55:32 +03:00
|
|
|
virtual void Invalidate(const LayoutDeviceIntRect& aRect) override;
|
2020-01-16 17:38:40 +03:00
|
|
|
virtual void SetFocus(Raise, mozilla::dom::CallerType aCallerType) override;
|
2016-08-19 02:03:04 +03:00
|
|
|
virtual LayoutDeviceIntRect GetScreenBounds() override;
|
2015-11-13 12:37:02 +03:00
|
|
|
virtual LayoutDeviceIntPoint WidgetToScreenOffset() override;
|
2016-12-21 03:18:40 +03:00
|
|
|
virtual nsresult DispatchEvent(mozilla::WidgetGUIEvent* aEvent,
|
|
|
|
|
nsEventStatus& aStatus) override;
|
2013-10-02 07:46:03 +04:00
|
|
|
nsEventStatus DispatchEvent(mozilla::WidgetGUIEvent* aEvent);
|
2022-02-01 01:07:23 +03:00
|
|
|
virtual nsresult MakeFullScreen(bool aFullScreen) override;
|
2021-10-05 14:42:00 +03:00
|
|
|
void SetCursor(const Cursor& aDefaultCursor) override;
|
2016-08-20 00:17:24 +03:00
|
|
|
void* GetNativeData(uint32_t aDataType) override;
|
2016-12-21 03:13:08 +03:00
|
|
|
virtual nsresult SetTitle(const nsAString& aTitle) override { return NS_OK; }
|
2020-03-25 18:13:43 +03:00
|
|
|
[[nodiscard]] virtual nsresult GetAttention(int32_t aCycleCount) override {
|
2016-12-21 03:13:08 +03:00
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
2018-11-30 13:46:48 +03:00
|
|
|
}
|
|
|
|
|
|
2017-03-01 23:29:30 +03:00
|
|
|
TextEventDispatcherListener* GetNativeTextEventDispatcherListener() override;
|
2016-12-21 07:27:20 +03:00
|
|
|
virtual void SetInputContext(const InputContext& aContext,
|
|
|
|
|
const InputContextAction& aAction) override;
|
|
|
|
|
virtual InputContext GetInputContext() override;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2021-07-23 01:58:57 +03:00
|
|
|
WindowRenderer* GetWindowRenderer() override;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
Bug 1741156 - Reinitialize compositor and request repaint after GPU process restart. r=aosmond,geckoview-reviewers,agi
This patch ensures that, following a GPU process crash, we
re-initialize the compositor and resume painting on Android.
nsWindow::GetWindowRenderer() is made to always reinitialize the
window renderer if there is none, like on other platforms. We
therefore no longer need to track whether webrender is being disabled,
as this is no longer a special case.
Previously we started the compositor as initially paused in
nsBaseWidget::CreateCompositorSession only if the widget did not yet
have a surface. Now we must unconditionally (re)start it as initially
paused, as even though the widget in the parent process may have a
surface, we will not have been able to send it to the GPU process
yet. We will send the surface to the compositor once control flow
returns to nsWindow::CreateLayerManager, where we will also now resume
the compositor if required.
Finally, we must ensure that we manually trigger a paint, both in the
parent and content processes. On other platforms this occurs
automatically following a GPU process loss through various refresh
driver events. On Android, however, nothing causes the refresh driver
to paint by itself, and we cannot receive input without first
initializing our APZ controllers, which does not happen until the
compositor receives a display list. We therefore must manually
schedule a paint. We do so from nsWindow::NotifyCompositorSessionLost
for the parent process, and BrowserChild::ReinitRendering for content
processes.
Differential Revision: https://phabricator.services.mozilla.com/D131232
2021-11-29 23:52:31 +03:00
|
|
|
void NotifyCompositorSessionLost(
|
|
|
|
|
mozilla::layers::CompositorSession* aSession) override;
|
|
|
|
|
|
2015-08-15 05:06:20 +03:00
|
|
|
virtual bool NeedsPaint() override;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2015-08-15 05:06:20 +03:00
|
|
|
virtual bool WidgetPaintsBackground() override;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2015-04-24 12:43:31 +03:00
|
|
|
virtual uint32_t GetMaxTouchPoints() const override;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2015-09-03 17:30:41 +03:00
|
|
|
void UpdateZoomConstraints(
|
2018-11-01 23:15:46 +03:00
|
|
|
const uint32_t& aPresShellId, const ScrollableLayerGuid::ViewID& aViewId,
|
2015-09-03 17:30:41 +03:00
|
|
|
const mozilla::Maybe<ZoomConstraints>& aConstraints) override;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2016-02-23 18:17:46 +03:00
|
|
|
nsresult SynthesizeNativeTouchPoint(uint32_t aPointerId,
|
|
|
|
|
TouchPointerState aPointerState,
|
2016-04-15 13:39:36 +03:00
|
|
|
LayoutDeviceIntPoint aPoint,
|
2016-02-23 18:17:46 +03:00
|
|
|
double aPointerPressure,
|
|
|
|
|
uint32_t aPointerOrientation,
|
|
|
|
|
nsIObserver* aObserver) override;
|
2016-05-16 19:17:17 +03:00
|
|
|
nsresult SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
|
2021-02-24 04:27:10 +03:00
|
|
|
NativeMouseMessage aNativeMessage,
|
|
|
|
|
mozilla::MouseButton aButton,
|
Bug 1691622 - part 4: Make `synthesizeNativeMouseClick*()` aware of modifiers r=smaug,geckoview-reviewers,m_kato
Surprisingly, they don't take modifiers, and
`nsIWidget::SynthesizeNativeMouseEvent()` which are implementations of
`nsIDOMWindowUtils::SendNativeMouseEvent()` treat given modifier flags
are native's ones, and handle modifiers only on macOS. Therefore, this
patch makes them handle native modifiers of Gecko.
Unfortunately, I'm not so familiar with Android API, and in the short
term, I don't need the support on Android. Therefore, this patch just
adds a TODO comment on Android widget.
Additionally, we don't have a simple way to set modifier only while
posting a mouse input on Windows too. It requires complicated code.
Therefore, I don't add the support for it on Windows too.
Differential Revision: https://phabricator.services.mozilla.com/D105758
2021-02-24 04:27:07 +03:00
|
|
|
nsIWidget::Modifiers aModifierFlags,
|
2016-02-23 18:17:46 +03:00
|
|
|
nsIObserver* aObserver) override;
|
2016-05-16 19:17:17 +03:00
|
|
|
nsresult SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
|
2016-02-23 18:17:46 +03:00
|
|
|
nsIObserver* aObserver) override;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
Bug 1741156 - Initial GPU process implementation on Android. r=aosmond,agi
Declare a GPU process and corresponding Service in the
AndroidManifest. This is of a new class GeckoServiceGpuProcess which
inherits from GeckoServiceChildProcess, and provides a binder
interface ICompositorSurfaceManager which allows the parent process to
set the compositor Surface for a given widget ID, and the compositor
in the GPU process to look up the Surface for a widget ID. The
ICompositorSurfaceManager interface is exposed to the parent process
through a new method getCompositorSurfaceManager() in the
IChildProcess interface.
Add a new connection type for GPU processes to GeckoProcessManager,
along with a function to look up the GPU process connection and fetch
the ICompositorSurfaceManager binder. When the GPU process is launched
we store the returned binder in the GPUProcessHost, and when each
widget's compositor is created we store a reference to the binder in
the UiCompositorControllerChild.
Each nsWindow is given a unique ID, and whenever the Surface changes
due to an Android resume event, it sends the new surface for that ID
to the GPU process (if enabled) by calling
ICompositorSurfaceManager.onSurfaceChanged().
Stop inheriting AndroidCompositorWidget from InProcessCompositorWidget
and instead inherit from CompositorWidget directly. This class holds a
reference to the Surface that will be rendered in to. The
CompositorBridgeParent notifies the CompositorWidget whenever it has
been resumed, allowing it to fetch the new Surface. For the
cross-process CompositorWidgetParent implementation it fetches that
Surface from the CompositorSurfaceManagerService, whereas the
InProcessAndroidCompositorWidget can read it directly from the real
widget.
AndroidCompositorWidget::GetClientSize() can now calculate its size
from the Surface, rather than racily reading the value from the
nsWindow. This means RenderCompositorEGL and RenderCompositorOGLSWGL
can now use GetClientSize() again rather than querying their own size
from the Surface.
With this patch, setting layers.gpu-process.enabled to true will cause
us to launch a GPU process and render from it. We do not yet
gracefully recover from a GPU process crash, nor can we render
anything using SurfaceTextures (eg video or webgl). Those will come in
future patches.
Differential Revision: https://phabricator.services.mozilla.com/D131231
2021-11-29 23:52:31 +03:00
|
|
|
void SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) override;
|
|
|
|
|
|
|
|
|
|
virtual void GetCompositorWidgetInitData(
|
|
|
|
|
mozilla::widget::CompositorWidgetInitData* aInitData) override;
|
|
|
|
|
|
2017-04-06 01:42:50 +03:00
|
|
|
mozilla::layers::CompositorBridgeChild* GetCompositorBridgeChild() const;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2017-11-22 22:12:22 +03:00
|
|
|
void SetContentDocumentDisplayed(bool aDisplayed);
|
|
|
|
|
bool IsContentDocumentDisplayed();
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2017-03-01 23:29:30 +03:00
|
|
|
// Call this function when the users activity is the direct cause of an
|
|
|
|
|
// event (like a keypress or mouse click).
|
|
|
|
|
void UserActivity();
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2017-12-14 06:57:21 +03:00
|
|
|
mozilla::jni::Object::Ref& GetEditableParent() { return mEditableParent; }
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2020-09-22 00:48:26 +03:00
|
|
|
RefPtr<mozilla::a11y::SessionAccessibility> GetSessionAccessibility();
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2017-04-06 01:42:50 +03:00
|
|
|
void RecvToolbarAnimatorMessageFromCompositor(int32_t aMessage) override;
|
2017-07-07 21:56:10 +03:00
|
|
|
void UpdateRootFrameMetrics(const ScreenPoint& aScrollOffset,
|
|
|
|
|
const CSSToScreenScale& aZoom) override;
|
2020-08-14 21:40:09 +03:00
|
|
|
void RecvScreenPixels(mozilla::ipc::Shmem&& aMem, const ScreenIntSize& aSize,
|
|
|
|
|
bool aNeedsYFlip) override;
|
2019-11-14 08:59:47 +03:00
|
|
|
void UpdateDynamicToolbarMaxHeight(mozilla::ScreenIntCoord aHeight) override;
|
|
|
|
|
mozilla::ScreenIntCoord GetDynamicToolbarMaxHeight() const override {
|
|
|
|
|
return mDynamicToolbarMaxHeight;
|
|
|
|
|
}
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2019-11-22 00:15:46 +03:00
|
|
|
void UpdateDynamicToolbarOffset(mozilla::ScreenIntCoord aOffset);
|
|
|
|
|
|
2020-03-04 11:17:09 +03:00
|
|
|
virtual mozilla::ScreenIntMargin GetSafeAreaInsets() const override;
|
|
|
|
|
void UpdateSafeAreaInsets(const mozilla::ScreenIntMargin& aSafeAreaInsets);
|
|
|
|
|
|
2022-12-20 00:05:44 +03:00
|
|
|
mozilla::jni::NativeWeakPtr<mozilla::widget::NPZCSupport>
|
|
|
|
|
GetNPZCSupportWeakPtr();
|
|
|
|
|
|
2010-06-04 00:56:36 +04:00
|
|
|
protected:
|
|
|
|
|
void BringToFront();
|
|
|
|
|
nsWindow* FindTopLevel();
|
2011-09-29 10:19:26 +04:00
|
|
|
bool IsTopLevel();
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2015-04-20 23:16:17 +03:00
|
|
|
void ConfigureAPZControllerThread() override;
|
2015-11-13 23:10:51 +03:00
|
|
|
void DispatchHitTest(const mozilla::WidgetTouchEvent& aEvent);
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2015-03-21 19:28:04 +03:00
|
|
|
already_AddRefed<GeckoContentController> CreateRootContentController()
|
2018-09-15 13:05:37 +03:00
|
|
|
override;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mIsVisible;
|
2010-06-04 00:56:36 +04:00
|
|
|
nsTArray<nsWindow*> mChildren;
|
|
|
|
|
nsWindow* mParent;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2020-07-20 19:06:59 +03:00
|
|
|
nsCOMPtr<nsIUserIdleServiceInternal> mIdleService;
|
2019-11-14 08:59:47 +03:00
|
|
|
mozilla::ScreenIntCoord mDynamicToolbarMaxHeight;
|
2020-03-04 11:17:09 +03:00
|
|
|
mozilla::ScreenIntMargin mSafeAreaInsets;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2022-05-02 17:06:17 +03:00
|
|
|
nsSizeMode mSizeMode;
|
2015-07-02 23:00:44 +03:00
|
|
|
bool mIsFullScreen;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2016-05-18 08:33:21 +03:00
|
|
|
bool UseExternalCompositingSurface() const override { return true; }
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2010-06-04 00:56:36 +04:00
|
|
|
static void DumpWindows();
|
|
|
|
|
static void DumpWindows(const nsTArray<nsWindow*>& wins, int indent = 0);
|
|
|
|
|
static void LogWindow(nsWindow* win, int index, int indent);
|
2018-11-30 13:46:48 +03:00
|
|
|
|
|
|
|
|
private:
|
2017-04-06 01:42:50 +03:00
|
|
|
void CreateLayerManager();
|
2011-11-15 07:12:14 +04:00
|
|
|
void RedrawAll();
|
2018-11-30 13:46:48 +03:00
|
|
|
|
Bug 1756700 - Enforce widget size constraints on Android. r=gfx-reviewers,geckoview-reviewers,calu,aosmond
With the later patch in this series to delay initializing the
compositor, we started crashing in ScreenshotTest#giantScreenshot due
to webrender's window size sanity check.
This check panics early if we attempt to render an area larger than
webrender can handle (rather than panicing internally in
webrender). However, this test deliberately creates a 999999x999999
sized window, to ensure that attempting to allocate a bitmap this size
for a screenshot results in an out of memory exception.
Previously this test only succeeded because we created the compositor
early with a default size of 0x0, whereas now we create it after the
widget has its very large size. Additionally, the test completes
before we have a chance to render anything, otherwise it would indeed
have crashed.
To ensure users do not hit the panic in the wild, in bug 1653649 we
added the necessary limit to the default widget size constraints,
ensuring we never create widgets that are too large. On Android,
however, we do not use the size constraints, so this had no effect.
This patch starts applying size constraints to android widgets,
meaning we do not attempt to render too large an area, and webrender
does not panic. The test still attempts to allocate a large bitmap,
and therefore still throws an out of memory exception and passes.
Differential Revision: https://phabricator.services.mozilla.com/D140050
2022-03-02 19:56:28 +03:00
|
|
|
void OnSizeChanged(const mozilla::gfx::IntSize& aSize);
|
|
|
|
|
|
2018-03-25 02:06:01 +03:00
|
|
|
mozilla::layers::LayersId GetRootLayerId() const;
|
2017-04-06 01:42:50 +03:00
|
|
|
RefPtr<mozilla::layers::UiCompositorControllerChild>
|
|
|
|
|
GetUiCompositorControllerChild();
|
2020-08-28 23:06:39 +03:00
|
|
|
|
Bug 1741156 - Initial GPU process implementation on Android. r=aosmond,agi
Declare a GPU process and corresponding Service in the
AndroidManifest. This is of a new class GeckoServiceGpuProcess which
inherits from GeckoServiceChildProcess, and provides a binder
interface ICompositorSurfaceManager which allows the parent process to
set the compositor Surface for a given widget ID, and the compositor
in the GPU process to look up the Surface for a widget ID. The
ICompositorSurfaceManager interface is exposed to the parent process
through a new method getCompositorSurfaceManager() in the
IChildProcess interface.
Add a new connection type for GPU processes to GeckoProcessManager,
along with a function to look up the GPU process connection and fetch
the ICompositorSurfaceManager binder. When the GPU process is launched
we store the returned binder in the GPUProcessHost, and when each
widget's compositor is created we store a reference to the binder in
the UiCompositorControllerChild.
Each nsWindow is given a unique ID, and whenever the Surface changes
due to an Android resume event, it sends the new surface for that ID
to the GPU process (if enabled) by calling
ICompositorSurfaceManager.onSurfaceChanged().
Stop inheriting AndroidCompositorWidget from InProcessCompositorWidget
and instead inherit from CompositorWidget directly. This class holds a
reference to the Surface that will be rendered in to. The
CompositorBridgeParent notifies the CompositorWidget whenever it has
been resumed, allowing it to fetch the new Surface. For the
cross-process CompositorWidgetParent implementation it fetches that
Surface from the CompositorSurfaceManagerService, whereas the
InProcessAndroidCompositorWidget can read it directly from the real
widget.
AndroidCompositorWidget::GetClientSize() can now calculate its size
from the Surface, rather than racily reading the value from the
nsWindow. This means RenderCompositorEGL and RenderCompositorOGLSWGL
can now use GetClientSize() again rather than querying their own size
from the Surface.
With this patch, setting layers.gpu-process.enabled to true will cause
us to launch a GPU process and render from it. We do not yet
gracefully recover from a GPU process crash, nor can we render
anything using SurfaceTextures (eg video or webgl). Those will come in
future patches.
Differential Revision: https://phabricator.services.mozilla.com/D131231
2021-11-29 23:52:31 +03:00
|
|
|
mozilla::widget::PlatformCompositorWidgetDelegate* mCompositorWidgetDelegate;
|
|
|
|
|
|
2023-04-04 07:00:09 +03:00
|
|
|
mozilla::Mutex mDestroyMutex;
|
|
|
|
|
|
2020-09-22 00:48:26 +03:00
|
|
|
friend class mozilla::widget::GeckoViewSupport;
|
|
|
|
|
friend class mozilla::widget::LayerViewSupport;
|
|
|
|
|
friend class mozilla::widget::NPZCSupport;
|
|
|
|
|
};
|
2020-09-01 20:39:15 +03:00
|
|
|
|
2010-06-04 00:56:36 +04:00
|
|
|
#endif /* NSWINDOW_H_ */
|
