gecko-dev/gfx/layers/client/ClientTiledPaintedLayer.h

151 строка
5.3 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 GFX_CLIENTTILEDPAINTEDLAYER_H
#define GFX_CLIENTTILEDPAINTEDLAYER_H
#include "ClientLayerManager.h" // for ClientLayer, etc
#include "Layers.h" // for PaintedLayer, etc
#include "mozilla/RefPtr.h" // for RefPtr
#include "mozilla/layers/TiledContentClient.h"
#include "nsRegion.h" // for nsIntRegion
namespace mozilla {
namespace layers {
class ShadowableLayer;
class SpecificLayerAttributes;
/**
* An implementation of PaintedLayer that ONLY supports remote
* composition that is backed by tiles. This painted layer implementation
* is better suited to mobile hardware to work around slow implementation
* of glTexImage2D (for OGL compositors), and restrait memory bandwidth.
*
* Tiled PaintedLayers use a different protocol compared with other
* layers. A copy of the tiled buffer is made and sent to the compositing
* thread via the layers protocol. Tiles are uploaded by the buffers
* asynchonously without using IPC, that means they are not safe for cross-
* process use (bug 747811). Each tile has a TextureHost/Client pair but
* they communicate directly rather than using the Texture protocol.
*
* There is no ContentClient for tiled layers. There is a ContentHost, however.
*/
class ClientTiledPaintedLayer : public PaintedLayer, public ClientLayer {
typedef PaintedLayer Base;
public:
explicit ClientTiledPaintedLayer(ClientLayerManager* const aManager,
ClientLayerManager::PaintedLayerCreationHint
aCreationHint = LayerManager::NONE);
protected:
virtual ~ClientTiledPaintedLayer();
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
public:
// Override name to distinguish it from ClientPaintedLayer in layer dumps
const char* Name() const override { return "TiledPaintedLayer"; }
// PaintedLayer
Layer* AsLayer() override { return this; }
void InvalidateRegion(const nsIntRegion& aRegion) override {
mInvalidRegion.Add(aRegion);
UpdateValidRegionAfterInvalidRegionChanged();
if (!mLowPrecisionValidRegion.IsEmpty()) {
// Also update mLowPrecisionValidRegion. Unfortunately we call
// mInvalidRegion.GetRegion() here, which is expensive.
mLowPrecisionValidRegion.SubOut(mInvalidRegion.GetRegion());
}
}
// Shadow methods
void FillSpecificAttributes(SpecificLayerAttributes& aAttrs) override;
ShadowableLayer* AsShadowableLayer() override { return this; }
void RenderLayer() override;
void ClearCachedResources() override;
void HandleMemoryPressure() override {
if (mContentClient) {
mContentClient->HandleMemoryPressure();
}
}
/**
* Helper method to find the nearest ancestor layers which
* scroll and have a displayport. The parameters are out-params
* which hold the return values; the values passed in may be null.
*/
void GetAncestorLayers(LayerMetricsWrapper* aOutScrollAncestor,
LayerMetricsWrapper* aOutDisplayPortAncestor,
bool* aOutHasTransformAnimation);
bool IsOptimizedFor(
LayerManager::PaintedLayerCreationHint aCreationHint) override;
private:
ClientLayerManager* ClientManager() {
return static_cast<ClientLayerManager*>(mManager);
}
/**
* For the initial PaintThebes of a transaction, calculates all the data
* needed for that paint and any repeated transactions.
*/
void BeginPaint();
/**
* Check if the layer is being scrolled by APZ on the compositor.
*/
bool IsScrollingOnCompositor(const FrameMetrics& aParentMetrics);
/**
* Check if we should use progressive draw on this layer. We will
* disable progressive draw based on a preference or if the layer
* is not being scrolled.
*/
bool UseProgressiveDraw();
/**
* Helper function to do the high-precision paint.
* This function returns true if it updated the paint buffer.
*/
bool RenderHighPrecision(const nsIntRegion& aInvalidRegion,
const nsIntRegion& aVisibleRegion,
LayerManager::DrawPaintedLayerCallback aCallback,
void* aCallbackData);
/**
* Helper function to do the low-precision paint.
* This function returns true if it updated the paint buffer.
*/
bool RenderLowPrecision(const nsIntRegion& aInvalidRegion,
const nsIntRegion& aVisibleRegion,
LayerManager::DrawPaintedLayerCallback aCallback,
void* aCallbackData);
/**
* This causes the paint to be marked as finished, and updates any data
* necessary to persist until the next paint.
*/
void EndPaint();
RefPtr<TiledContentClient> mContentClient;
// Flag to indicate if mContentClient is a SingleTiledContentClient. This is
// only valid when mContentClient is non-null.
bool mHaveSingleTiledContentClient;
nsIntRegion mLowPrecisionValidRegion;
BasicTiledLayerPaintData mPaintData;
};
} // namespace layers
} // namespace mozilla
#endif