gfx/layers/client/ClientContainerLayer.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef GFX_CLIENTCONTAINERLAYER_H
   8 #define GFX_CLIENTCONTAINERLAYER_H
   9
  10 #include <stdint.h>              // for uint32_t
  11 #include "ClientLayerManager.h"  // for ClientLayerManager, etc
  12 #include "Layers.h"              // for Layer, ContainerLayer, etc
  13 #include "nsDebug.h"             // for NS_ASSERTION
  14 #include "nsISupportsImpl.h"     // for MOZ_COUNT_CTOR, etc
  15 #include "nsISupportsUtils.h"    // for NS_ADDREF, NS_RELEASE
  16 #include "nsRegion.h"            // for nsIntRegion
  17 #include "nsTArray.h"            // for AutoTArray
  18 #include "ReadbackProcessor.h"
  19 #include "ClientPaintedLayer.h"
  20
  21 namespace mozilla {
  22 namespace layers {
  23
  24 class ShadowableLayer;
  25
  26 class ClientContainerLayer : public ContainerLayer, public ClientLayer {
  27  public:
  28   explicit ClientContainerLayer(ClientLayerManager* aManager)
  29       : ContainerLayer(aManager, static_cast<ClientLayer*>(this)) {
  30     MOZ_COUNT_CTOR(ClientContainerLayer);
  31     mSupportsComponentAlphaChildren = true;
  32   }
  33
  34  protected:
  35   virtual ~ClientContainerLayer() {
  36     ContainerLayer::RemoveAllChildren();
  37     MOZ_COUNT_DTOR(ClientContainerLayer);
  38   }
  39
  40  public:
  41   void RenderLayer() override {
  42     RenderMaskLayers(this);
  43
  44     DefaultComputeSupportsComponentAlphaChildren();
  45
  46     ReadbackProcessor readback;
  47     readback.BuildUpdates(this);
  48
  49     nsTArray<Layer*> children = CollectChildren();
  50     for (uint32_t i = 0; i < children.Length(); i++) {
  51       Layer* child = children.ElementAt(i);
  52
  53       ToClientLayer(child)->RenderLayerWithReadback(&readback);
  54
  55       if (!ClientManager()->GetRepeatTransaction() &&
  56           !child->GetInvalidRegion().IsEmpty()) {
  57         child->Mutated();
  58       }
  59     }
  60   }
  61
  62   void SetVisibleRegion(const LayerIntRegion& aRegion) override {
  63     NS_ASSERTION(ClientManager()->InConstruction(),
  64                  "Can only set properties in construction phase");
  65     ContainerLayer::SetVisibleRegion(aRegion);
  66   }
  67   bool InsertAfter(Layer* aChild, Layer* aAfter) override {
  68     if (!ClientManager()->InConstruction()) {
  69       NS_ERROR("Can only set properties in construction phase");
  70       return false;
  71     }
  72
  73     if (!ContainerLayer::InsertAfter(aChild, aAfter)) {
  74       return false;
  75     }
  76
  77     ClientManager()->AsShadowForwarder()->InsertAfter(
  78         ClientManager()->Hold(this), ClientManager()->Hold(aChild),
  79         aAfter ? ClientManager()->Hold(aAfter) : nullptr);
  80     return true;
  81   }
  82
  83   bool RemoveChild(Layer* aChild) override {
  84     if (!ClientManager()->InConstruction()) {
  85       NS_ERROR("Can only set properties in construction phase");
  86       return false;
  87     }
  88     // hold on to aChild before we remove it!
  89     ShadowableLayer* heldChild = ClientManager()->Hold(aChild);
  90     if (!ContainerLayer::RemoveChild(aChild)) {
  91       return false;
  92     }
  93     ClientManager()->AsShadowForwarder()->RemoveChild(
  94         ClientManager()->Hold(this), heldChild);
  95     return true;
  96   }
  97
  98   bool RepositionChild(Layer* aChild, Layer* aAfter) override {
  99     if (!ClientManager()->InConstruction()) {
 100       NS_ERROR("Can only set properties in construction phase");
 101       return false;
 102     }
 103     if (!ContainerLayer::RepositionChild(aChild, aAfter)) {
 104       return false;
 105     }
 106     ClientManager()->AsShadowForwarder()->RepositionChild(
 107         ClientManager()->Hold(this), ClientManager()->Hold(aChild),
 108         aAfter ? ClientManager()->Hold(aAfter) : nullptr);
 109     return true;
 110   }
 111
 112   Layer* AsLayer() override { return this; }
 113   ShadowableLayer* AsShadowableLayer() override { return this; }
 114
 115   void ComputeEffectiveTransforms(
 116       const gfx::Matrix4x4& aTransformToSurface) override {
 117     DefaultComputeEffectiveTransforms(aTransformToSurface);
 118   }
 119
 120   void ForceIntermediateSurface() { mUseIntermediateSurface = true; }
 121
 122   void SetSupportsComponentAlphaChildren(bool aSupports) {
 123     mSupportsComponentAlphaChildren = aSupports;
 124   }
 125
 126  protected:
 127   ClientLayerManager* ClientManager() {
 128     return static_cast<ClientLayerManager*>(mManager);
 129   }
 130 };
 131
 132 class ClientRefLayer : public RefLayer, public ClientLayer {
 133  public:
 134   explicit ClientRefLayer(ClientLayerManager* aManager)
 135       : RefLayer(aManager, static_cast<ClientLayer*>(this)) {
 136     MOZ_COUNT_CTOR(ClientRefLayer);
 137   }
 138
 139  protected:
 140   MOZ_COUNTED_DTOR_OVERRIDE(ClientRefLayer)
 141
 142  public:
 143   Layer* AsLayer() override { return this; }
 144   ShadowableLayer* AsShadowableLayer() override { return this; }
 145
 146   void RenderLayer() override { RenderMaskLayers(this); }
 147
 148   void ComputeEffectiveTransforms(
 149       const gfx::Matrix4x4& aTransformToSurface) override {
 150     DefaultComputeEffectiveTransforms(aTransformToSurface);
 151   }
 152
 153  private:
 154   ClientLayerManager* ClientManager() {
 155     return static_cast<ClientLayerManager*>(mManager);
 156   }
 157 };
 158
 159 }  // namespace layers
 160 }  // namespace mozilla
 161
 162 #endif