mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-24 13:21:05 +00:00
0155e30e96
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
106 lines
3.5 KiB
C++
106 lines
3.5 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/. */
|
|
#ifndef _include_mozilla_gfx_ipc_CompositorSession_h_
|
|
#define _include_mozilla_gfx_ipc_CompositorSession_h_
|
|
|
|
#include "base/basictypes.h"
|
|
#include "mozilla/layers/LayersTypes.h"
|
|
#include "mozilla/layers/CompositorTypes.h"
|
|
#include "nsISupportsImpl.h"
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
# include "mozilla/layers/UiCompositorControllerChild.h"
|
|
#endif // defined(MOZ_WIDGET_ANDROID)
|
|
|
|
class nsBaseWidget;
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
class CompositorWidget;
|
|
class CompositorWidgetDelegate;
|
|
} // namespace widget
|
|
namespace gfx {
|
|
class GPUProcessHost;
|
|
class GPUProcessManager;
|
|
} // namespace gfx
|
|
namespace layers {
|
|
|
|
class GeckoContentController;
|
|
class IAPZCTreeManager;
|
|
class CompositorBridgeParent;
|
|
class CompositorBridgeChild;
|
|
class ClientLayerManager;
|
|
|
|
// A CompositorSession provides access to a compositor without exposing whether
|
|
// or not it's in-process or out-of-process.
|
|
class CompositorSession {
|
|
friend class gfx::GPUProcessManager;
|
|
|
|
protected:
|
|
typedef gfx::GPUProcessHost GPUProcessHost;
|
|
typedef widget::CompositorWidget CompositorWidget;
|
|
typedef widget::CompositorWidgetDelegate CompositorWidgetDelegate;
|
|
|
|
public:
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CompositorSession)
|
|
|
|
virtual void Shutdown() = 0;
|
|
|
|
// This returns a CompositorBridgeParent if the compositor resides in the same
|
|
// process.
|
|
virtual CompositorBridgeParent* GetInProcessBridge() const = 0;
|
|
|
|
// Set the GeckoContentController for the root of the layer tree.
|
|
virtual void SetContentController(GeckoContentController* aController) = 0;
|
|
|
|
// Return the Async Pan/Zoom Tree Manager for this compositor.
|
|
virtual RefPtr<IAPZCTreeManager> GetAPZCTreeManager() const = 0;
|
|
|
|
// Return the child end of the compositor IPC bridge.
|
|
CompositorBridgeChild* GetCompositorBridgeChild();
|
|
|
|
// Return the proxy for accessing the compositor's widget.
|
|
CompositorWidgetDelegate* GetCompositorWidgetDelegate() {
|
|
return mCompositorWidgetDelegate;
|
|
}
|
|
|
|
// Return the id of the root layer tree.
|
|
LayersId RootLayerTreeId() const { return mRootLayerTreeId; }
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
// Set the UiCompositorControllerChild after Session creation so the Session
|
|
// constructor doesn't get mucked up for other platforms.
|
|
void SetUiCompositorControllerChild(
|
|
RefPtr<UiCompositorControllerChild> aUiController) {
|
|
mUiCompositorControllerChild = aUiController;
|
|
}
|
|
|
|
RefPtr<UiCompositorControllerChild> GetUiCompositorControllerChild() {
|
|
return mUiCompositorControllerChild;
|
|
}
|
|
#endif // defined(MOZ_WIDGET_ANDROID)
|
|
protected:
|
|
CompositorSession(nsBaseWidget* aWidget, CompositorWidgetDelegate* aDelegate,
|
|
CompositorBridgeChild* aChild,
|
|
const LayersId& aRootLayerTreeId);
|
|
virtual ~CompositorSession();
|
|
|
|
protected:
|
|
nsBaseWidget* mWidget;
|
|
CompositorWidgetDelegate* mCompositorWidgetDelegate;
|
|
RefPtr<CompositorBridgeChild> mCompositorBridgeChild;
|
|
LayersId mRootLayerTreeId;
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
RefPtr<UiCompositorControllerChild> mUiCompositorControllerChild;
|
|
#endif // defined(MOZ_WIDGET_ANDROID)
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(CompositorSession);
|
|
};
|
|
|
|
} // namespace layers
|
|
} // namespace mozilla
|
|
|
|
#endif // _include_mozilla_gfx_ipc_CompositorSession_h_
|