The Tor Browser: gfx/layers/composite/TiledContentHost.h@129ffea94266 (annotated)

gfx/layers/composite/TiledContentHost.h@129ffea94266 (annotated)

gfx/layers/composite/TiledContentHost.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- 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 GFX_TILEDCONTENTHOST_H
 #define GFX_TILEDCONTENTHOST_H
 #include <stdint.h>                     // for uint16_t
 #include <stdio.h>                      // for FILE
 #include <algorithm>                    // for swap
 #include "ContentHost.h"                // for ContentHost
 #include "TiledLayerBuffer.h"           // for TiledLayerBuffer, etc
 #include "CompositableHost.h"
 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
 #include "mozilla/Attributes.h"         // for MOZ_OVERRIDE
 #include "mozilla/RefPtr.h"             // for RefPtr
 #include "mozilla/gfx/Point.h"          // for Point
 #include "mozilla/gfx/Rect.h"           // for Rect
 #include "mozilla/gfx/Types.h"          // for Filter
 #include "mozilla/layers/CompositorTypes.h"  // for TextureInfo, etc
 #include "mozilla/layers/LayersSurfaces.h"  // for SurfaceDescriptor
 #include "mozilla/layers/LayersTypes.h"  // for LayerRenderState, etc
 #include "mozilla/layers/TextureHost.h"  // for TextureHost
 #include "mozilla/layers/TiledContentClient.h"
 #include "mozilla/mozalloc.h"           // for operator delete
 #include "nsRegion.h"                   // for nsIntRegion
 #include "nscore.h"                     // for nsACString
 #if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
 #include <ui/Fence.h>
 #endif
 class gfxReusableSurfaceWrapper;
 struct nsIntPoint;
 struct nsIntRect;
 struct nsIntSize;
 namespace mozilla {
 namespace gfx {
 class Matrix4x4;
 }
 namespace layers {
 class Compositor;
 class ISurfaceAllocator;
 class Layer;
 class ThebesBufferData;
 struct EffectChain;
 class TileHost {
 public:
   // Constructs a placeholder TileHost. See the comments above
   // TiledLayerBuffer for more information on what this is used for;
   // essentially, this is a sentinel used to represent an invalid or blank
   // tile.
   TileHost()
     : mSharedLock(nullptr)
     , mTextureHost(nullptr)
   {}
   // Constructs a TileHost from a gfxSharedReadLock and TextureHost.
   TileHost(gfxSharedReadLock* aSharedLock,
                TextureHost* aTextureHost)
     : mSharedLock(aSharedLock)
     , mTextureHost(aTextureHost)
   {}
   TileHost(const TileHost& o) {
     mTextureHost = o.mTextureHost;
     mSharedLock = o.mSharedLock;
   }
   TileHost& operator=(const TileHost& o) {
     if (this == &o) {
       return *this;
     }
     mTextureHost = o.mTextureHost;
     mSharedLock = o.mSharedLock;
     return *this;
   }
   bool operator== (const TileHost& o) const {
     return mTextureHost == o.mTextureHost;
   }
   bool operator!= (const TileHost& o) const {
     return mTextureHost != o.mTextureHost;
   }
   bool IsPlaceholderTile() const { return mTextureHost == nullptr; }
   void ReadUnlock() {
     if (mSharedLock) {
       mSharedLock->ReadUnlock();
     }
   }
   RefPtr<gfxSharedReadLock> mSharedLock;
   RefPtr<TextureHost> mTextureHost;
 };
 class TiledLayerBufferComposite
   : public TiledLayerBuffer<TiledLayerBufferComposite, TileHost>
 {
   friend class TiledLayerBuffer<TiledLayerBufferComposite, TileHost>;
 public:
   typedef TiledLayerBuffer<TiledLayerBufferComposite, TileHost>::Iterator Iterator;
   TiledLayerBufferComposite();
   TiledLayerBufferComposite(ISurfaceAllocator* aAllocator,
                             const SurfaceDescriptorTiles& aDescriptor,
                             const nsIntRegion& aOldPaintedRegion);
   TileHost GetPlaceholderTile() const { return TileHost(); }
   // Stores the absolute resolution of the containing frame, calculated
   // by the sum of the resolutions of all parent layers' FrameMetrics.
   const CSSToParentLayerScale& GetFrameResolution() { return mFrameResolution; }
   void ReadUnlock();
   void ReleaseTextureHosts();
   /**
    * This will synchronously upload any necessary texture contents, making the
    * sources immediately available for compositing. For texture hosts that
    * don't have an internal buffer, this is unlikely to actually do anything.
    */
   void Upload();
   void SetCompositor(Compositor* aCompositor);
   bool HasDoubleBufferedTiles() { return mHasDoubleBufferedTiles; }
   bool IsValid() const { return !mUninitialized; }
 #if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
   virtual void SetReleaseFence(const android::sp<android::Fence>& aReleaseFence);
 #endif
   // Recycle callback for TextureHost.
   // Used when TiledContentClient is present in client side.
   static void RecycleCallback(TextureHost* textureHost, void* aClosure);
 protected:
   TileHost ValidateTile(TileHost aTile,
                         const nsIntPoint& aTileRect,
                         const nsIntRegion& dirtyRect);
   // do nothing, the desctructor in the texture host takes care of releasing resources
   void ReleaseTile(TileHost aTile) {}
   void SwapTiles(TileHost& aTileA, TileHost& aTileB) { std::swap(aTileA, aTileB); }
 private:
   CSSToParentLayerScale mFrameResolution;
   bool mHasDoubleBufferedTiles;
   bool mUninitialized;
 };
 /**
  * ContentHost for tiled Thebes layers. Since tiled layers are special snow
  * flakes, we have a unique update process. All the textures that back the
  * tiles are added in the usual way, but Updated is called on the host side
  * in response to a message that describes the transaction for every tile.
  * Composition happens in the normal way.
  *
  * TiledContentHost has a TiledLayerBufferComposite which keeps hold of the tiles.
  * Each tile has a reference to a texture host. During the layers transaction, we
  * receive a list of descriptors for the client-side tile buffer tiles
  * (UseTiledLayerBuffer). If we receive two transactions before a composition,
  * we immediately unlock and discard the unused buffer.
  *
  * When the content host is composited, we first validate the TiledLayerBuffer
  * (Upload), which calls Updated on each tile's texture host to make sure the
  * texture data has been uploaded. For single-buffered tiles, we unlock at this
  * point, for double-buffered tiles we unlock and discard the last composited
  * buffer after compositing a new one. Rendering takes us to RenderTile which
  * is similar to Composite for non-tiled ContentHosts.
  */
 class TiledContentHost : public ContentHost,
                          public TiledLayerComposer
 {
 public:
   TiledContentHost(const TextureInfo& aTextureInfo);
   ~TiledContentHost();
   virtual LayerRenderState GetRenderState() MOZ_OVERRIDE
   {
     return LayerRenderState();
   }
   virtual bool UpdateThebes(const ThebesBufferData& aData,
                             const nsIntRegion& aUpdated,
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack)
   {
     NS_ERROR("N/A for tiled layers");
     return false;
   }
   const nsIntRegion& GetValidLowPrecisionRegion() const
   {
     return mLowPrecisionTiledBuffer.GetValidRegion();
   }
   void UseTiledLayerBuffer(ISurfaceAllocator* aAllocator,
                            const SurfaceDescriptorTiles& aTiledDescriptor);
   void Composite(EffectChain& aEffectChain,
                  float aOpacity,
                  const gfx::Matrix4x4& aTransform,
                  const gfx::Filter& aFilter,
                  const gfx::Rect& aClipRect,
                  const nsIntRegion* aVisibleRegion = nullptr,
                  TiledLayerProperties* aLayerProperties = nullptr);
   virtual CompositableType GetType() { return BUFFER_TILED; }
   virtual TiledLayerComposer* AsTiledLayerComposer() MOZ_OVERRIDE { return this; }
   virtual void Attach(Layer* aLayer,
                       Compositor* aCompositor,
                       AttachFlags aFlags = NO_FLAGS) MOZ_OVERRIDE;
 #ifdef MOZ_DUMP_PAINTING
   virtual void Dump(FILE* aFile=nullptr,
                     const char* aPrefix="",
                     bool aDumpHtml=false) MOZ_OVERRIDE;
 #endif
   virtual void PrintInfo(nsACString& aTo, const char* aPrefix);
 #if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
   /**
    * Store a fence that will signal when the current buffer is no longer being read.
    * Similar to android's GLConsumer::setReleaseFence()
    */
   virtual void SetReleaseFence(const android::sp<android::Fence>& aReleaseFence)
   {
     mTiledBuffer.SetReleaseFence(aReleaseFence);
     mLowPrecisionTiledBuffer.SetReleaseFence(aReleaseFence);
   }
 #endif
 private:
   void RenderLayerBuffer(TiledLayerBufferComposite& aLayerBuffer,
                          EffectChain& aEffectChain,
                          float aOpacity,
                          const gfx::Filter& aFilter,
                          const gfx::Rect& aClipRect,
                          nsIntRegion aMaskRegion,
                          gfx::Matrix4x4 aTransform);
   // Renders a single given tile.
   void RenderTile(const TileHost& aTile,
                   EffectChain& aEffectChain,
                   float aOpacity,
                   const gfx::Matrix4x4& aTransform,
                   const gfx::Filter& aFilter,
                   const gfx::Rect& aClipRect,
                   const nsIntRegion& aScreenRegion,
                   const nsIntPoint& aTextureOffset,
                   const nsIntSize& aTextureBounds);
   void EnsureTileStore() {}
   TiledLayerBufferComposite    mTiledBuffer;
   TiledLayerBufferComposite    mLowPrecisionTiledBuffer;
   TiledLayerBufferComposite    mOldTiledBuffer;
   TiledLayerBufferComposite    mOldLowPrecisionTiledBuffer;
   bool                         mPendingUpload;
   bool                         mPendingLowPrecisionUpload;
 };
 }
 }
 #endif

The Tor Browser / annotate

gfx/layers/composite/TiledContentHost.h@129ffea94266 (annotated)

gfx/layers/composite/TiledContentHost.h