thunderbird-dev 1:52.8.0-1~deb8u1 / usr / include / thunderbird / mozilla / layers / SingleTiledContentClient.h

This file is indexed.

/usr/include/thunderbird/mozilla/layers/SingleTiledContentClient.h is in thunderbird-dev 1:52.8.0-1~deb8u1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * 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 MOZILLA_GFX_SINGLETILEDCONTENTCLIENT_H
#define MOZILLA_GFX_SINGLETILEDCONTENTCLIENT_H

#include "TiledContentClient.h"

namespace mozilla {
namespace layers {

class ClientTiledPaintedLayer;
class ClientLayerManager;

/**
 * Provide an instance of TiledLayerBuffer backed by drawable TextureClients.
 * This buffer provides an implementation of ValidateTile using a
 * thebes callback and can support painting using a single paint buffer.
 * Whether a single paint buffer is used is controlled by
 * gfxPrefs::PerTileDrawing().
 */
class ClientSingleTiledLayerBuffer
  : public ClientTiledLayerBuffer
  , public TextureClientAllocator
{
  virtual ~ClientSingleTiledLayerBuffer() {}
public:
  ClientSingleTiledLayerBuffer(ClientTiledPaintedLayer& aPaintedLayer,
                               CompositableClient& aCompositableClient,
                               ClientLayerManager* aManager);

  // TextureClientAllocator
  already_AddRefed<TextureClient> GetTextureClient() override;
  void ReturnTextureClientDeferred(TextureClient* aClient) override {}
  void ReportClientLost() override {}

  // ClientTiledLayerBuffer
  void PaintThebes(const nsIntRegion& aNewValidRegion,
                   const nsIntRegion& aPaintRegion,
                   const nsIntRegion& aDirtyRegion,
                   LayerManager::DrawPaintedLayerCallback aCallback,
                   void* aCallbackData,
                   bool aIsProgressive = false) override;
 
  bool SupportsProgressiveUpdate() override { return false; }
  bool ProgressiveUpdate(nsIntRegion& aValidRegion,
                         nsIntRegion& aInvalidRegion,
                         const nsIntRegion& aOldValidRegion,
                         BasicTiledLayerPaintData* aPaintData,
                         LayerManager::DrawPaintedLayerCallback aCallback,
                         void* aCallbackData) override
  {
    MOZ_ASSERT(false, "ProgressiveUpdate not supported!");
    return false;
  }
  
  void ResetPaintedAndValidState() override {
    mPaintedRegion.SetEmpty();
    mValidRegion.SetEmpty();
    mTile.DiscardBuffers();
  }
  
  const nsIntRegion& GetValidRegion() override {
    return mValidRegion;
  }
  
  bool IsLowPrecision() const override {
    return false;
  }

  void ReleaseTiles();

  void DiscardBuffers();

  SurfaceDescriptorTiles GetSurfaceDescriptorTiles();

  void ClearPaintedRegion() {
    mPaintedRegion.SetEmpty();
  }

private:
  TileClient mTile;

  nsIntRegion mPaintedRegion;
  nsIntRegion mValidRegion;
  bool mWasLastPaintProgressive;

  /**
   * While we're adding tiles, this is used to keep track of the position of
   * the top-left of the top-left-most tile.  When we come to wrap the tiles in
   * TiledDrawTarget we subtract the value of this member from each tile's
   * offset so that all the tiles have a positive offset, then add a
   * translation to the TiledDrawTarget to compensate.  This is important so
   * that the mRect of the TiledDrawTarget is always at a positive x/y
   * position, otherwise its GetSize() methods will be broken.
   */
  gfx::IntPoint mTilingOrigin;
  gfx::IntSize mSize;
  gfxImageFormat mFormat;
};

class SingleTiledContentClient : public TiledContentClient
{
public:
  SingleTiledContentClient(ClientTiledPaintedLayer& aPaintedLayer,
                           ClientLayerManager* aManager);

protected:
  ~SingleTiledContentClient()
  {
    MOZ_COUNT_DTOR(SingleTiledContentClient);

    mTiledBuffer->ReleaseTiles();
  }

public:
  static bool ClientSupportsLayerSize(const gfx::IntSize& aSize, ClientLayerManager* aManager);

  virtual void ClearCachedResources() override;

  virtual void UpdatedBuffer(TiledBufferType aType) override;

  virtual ClientTiledLayerBuffer* GetTiledBuffer() override { return mTiledBuffer; }
  virtual ClientTiledLayerBuffer* GetLowPrecisionTiledBuffer() override { return nullptr; }

private:
  RefPtr<ClientSingleTiledLayerBuffer> mTiledBuffer;
};

}
}

#endif

APT Browse - Built by Thomas Orozco.