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

/* -*- 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