The Tor Browser / file revision

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

 #include "ImageHost.h"

 #include "LayersLogging.h"              // for AppendToString

 #include "composite/CompositableHost.h"  // for CompositableHost, etc

 #include "ipc/IPCMessageUtils.h"        // for null_t

 #include "mozilla/layers/Compositor.h"  // for Compositor

 #include "mozilla/layers/Effects.h"     // for TexturedEffect, Effect, etc

 #include "nsAString.h"

 #include "nsDebug.h"                    // for NS_WARNING, NS_ASSERTION

 #include "nsPrintfCString.h"            // for nsPrintfCString

 #include "nsString.h"                   // for nsAutoCString

 class nsIntRegion;

 namespace mozilla {

 namespace gfx {

 class Matrix4x4;

 }

 using namespace gfx;

 namespace layers {

 class ISurfaceAllocator;

 ImageHost::ImageHost(const TextureInfo& aTextureInfo)

   : CompositableHost(aTextureInfo)

   , mFrontBuffer(nullptr)

   , mHasPictureRect(false)

 {}

 ImageHost::~ImageHost() {}

 void

 ImageHost::UseTextureHost(TextureHost* aTexture)

 {

   CompositableHost::UseTextureHost(aTexture);

   mFrontBuffer = aTexture;

 }

 void

 ImageHost::RemoveTextureHost(TextureHost* aTexture)

 {

   CompositableHost::RemoveTextureHost(aTexture);

   if (aTexture && mFrontBuffer == aTexture) {

     aTexture->SetCompositableBackendSpecificData(nullptr);

     mFrontBuffer = nullptr;

   }

 }

 TextureHost*

 ImageHost::GetAsTextureHost()

 {

   return mFrontBuffer;

 }

 void

 ImageHost::Composite(EffectChain& aEffectChain,

                      float aOpacity,

                      const gfx::Matrix4x4& aTransform,

                      const gfx::Filter& aFilter,

                      const gfx::Rect& aClipRect,

                      const nsIntRegion* aVisibleRegion,

                      TiledLayerProperties* aLayerProperties)

 {

   if (!GetCompositor()) {

     // should only happen when a tab is dragged to another window and

     // async-video is still sending frames but we haven't attached the

     // set the new compositor yet.

     return;

   }

   if (!mFrontBuffer) {

     return;

   }

   // Make sure the front buffer has a compositor

   mFrontBuffer->SetCompositor(GetCompositor());

   mFrontBuffer->SetCompositableBackendSpecificData(GetCompositableBackendSpecificData());

   AutoLockTextureHost autoLock(mFrontBuffer);

   if (autoLock.Failed()) {

     NS_WARNING("failed to lock front buffer");

     return;

   }

   RefPtr<NewTextureSource> source = mFrontBuffer->GetTextureSources();

   if (!source) {

     return;

   }

   RefPtr<TexturedEffect> effect = CreateTexturedEffect(mFrontBuffer->GetFormat(),

                                                        source,

                                                        aFilter);

   if (!effect) {

     return;

   }

   aEffectChain.mPrimaryEffect = effect;

   IntSize textureSize = source->GetSize();

   gfx::Rect gfxPictureRect

     = mHasPictureRect ? gfx::Rect(0, 0, mPictureRect.width, mPictureRect.height)

                       : gfx::Rect(0, 0, textureSize.width, textureSize.height);

   gfx::Rect pictureRect(0, 0,

                         mPictureRect.width,

                         mPictureRect.height);

   //XXX: We might have multiple texture sources here (e.g. 3 YCbCr textures), and we're

   // only iterating over the tiles of the first one. Are we assuming that the tiling

   // will be identical? Can we ensure that somehow?

   TileIterator* it = source->AsTileIterator();

   if (it) {

     it->BeginTileIteration();

     do {

       nsIntRect tileRect = it->GetTileRect();

       gfx::Rect rect(tileRect.x, tileRect.y, tileRect.width, tileRect.height);

       if (mHasPictureRect) {

         rect = rect.Intersect(pictureRect);

         effect->mTextureCoords = Rect(Float(rect.x - tileRect.x)/ tileRect.width,

                                       Float(rect.y - tileRect.y) / tileRect.height,

                                       Float(rect.width) / tileRect.width,

                                       Float(rect.height) / tileRect.height);

       } else {

         effect->mTextureCoords = Rect(0, 0, 1, 1);

       }

       GetCompositor()->DrawQuad(rect, aClipRect, aEffectChain,

                                 aOpacity, aTransform);

       GetCompositor()->DrawDiagnostics(DIAGNOSTIC_IMAGE|DIAGNOSTIC_BIGIMAGE,

                                        rect, aClipRect, aTransform, mFlashCounter);

     } while (it->NextTile());

     it->EndTileIteration();

     // layer border

     GetCompositor()->DrawDiagnostics(DIAGNOSTIC_IMAGE,

                                      gfxPictureRect, aClipRect,

                                      aTransform, mFlashCounter);

   } else {

     IntSize textureSize = source->GetSize();

     gfx::Rect rect;

     if (mHasPictureRect) {

       effect->mTextureCoords = Rect(Float(mPictureRect.x) / textureSize.width,

                                     Float(mPictureRect.y) / textureSize.height,

                                     Float(mPictureRect.width) / textureSize.width,

                                     Float(mPictureRect.height) / textureSize.height);

       rect = pictureRect;

     } else {

       effect->mTextureCoords = Rect(0, 0, 1, 1);

       rect = gfx::Rect(0, 0, textureSize.width, textureSize.height);

     }

     if (mFrontBuffer->GetFlags() & TEXTURE_NEEDS_Y_FLIP) {

       effect->mTextureCoords.y = effect->mTextureCoords.YMost();

       effect->mTextureCoords.height = -effect->mTextureCoords.height;

     }

     GetCompositor()->DrawQuad(rect, aClipRect, aEffectChain,

                               aOpacity, aTransform);

     GetCompositor()->DrawDiagnostics(DIAGNOSTIC_IMAGE,

                                      rect, aClipRect,

                                      aTransform, mFlashCounter);

   }

 }

 void

 ImageHost::SetCompositor(Compositor* aCompositor)

 {

   if (mFrontBuffer && mCompositor != aCompositor) {

     mFrontBuffer->SetCompositor(aCompositor);

   }

   CompositableHost::SetCompositor(aCompositor);

 }

 void

 ImageHost::PrintInfo(nsACString& aTo, const char* aPrefix)

 {

   aTo += aPrefix;

   aTo += nsPrintfCString("ImageHost (0x%p)", this);

   AppendToString(aTo, mPictureRect, " [picture-rect=", "]");

   if (mFrontBuffer) {

     nsAutoCString pfx(aPrefix);

     pfx += "  ";

     aTo += "\n";

     mFrontBuffer->PrintInfo(aTo, pfx.get());

   }

 }

 #ifdef MOZ_DUMP_PAINTING

 void

 ImageHost::Dump(FILE* aFile,

                 const char* aPrefix,

                 bool aDumpHtml)

 {

   if (!aFile) {

     aFile = stderr;

   }

   if (mFrontBuffer) {

     fprintf_stderr(aFile, "%s", aPrefix);

     fprintf_stderr(aFile, aDumpHtml ? "<ul><li>TextureHost: "

                              : "TextureHost: ");

     DumpTextureHost(aFile, mFrontBuffer);

     fprintf_stderr(aFile, aDumpHtml ? " </li></ul> " : " ");

   }

 }

 #endif

 LayerRenderState

 ImageHost::GetRenderState()

 {

   if (mFrontBuffer) {

     return mFrontBuffer->GetRenderState();

   }

   return LayerRenderState();

 }

 #ifdef MOZ_DUMP_PAINTING

 TemporaryRef<gfx::DataSourceSurface>

 ImageHost::GetAsSurface()

 {

   return mFrontBuffer->GetAsSurface();

 }

 #endif

 }

 }