gfx/layers/ImageContainer.cpp

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6
   7 #include "ImageContainer.h"
   8 #include <string.h>                     // for memcpy, memset
   9 #include "GLImages.h"                   // for SurfaceTextureImage
  10 #include "gfx2DGlue.h"
  11 #include "gfxPlatform.h"                // for gfxPlatform
  12 #include "gfxUtils.h"                   // for gfxUtils
  13 #include "mozilla/RefPtr.h"             // for TemporaryRef
  14 #include "mozilla/ipc/CrossProcessMutex.h"  // for CrossProcessMutex, etc
  15 #include "mozilla/layers/CompositorTypes.h"
  16 #include "mozilla/layers/ImageBridgeChild.h"  // for ImageBridgeChild
  17 #include "mozilla/layers/ImageClient.h"  // for ImageClient
  18 #include "nsISupportsUtils.h"           // for NS_IF_ADDREF
  19 #include "YCbCrUtils.h"                 // for YCbCr conversions
  20 #ifdef MOZ_WIDGET_GONK
  21 #include "GrallocImages.h"
  22 #endif
  23 #include "gfx2DGlue.h"
  24 #include "mozilla/gfx/2D.h"
  25
  26 #ifdef XP_MACOSX
  27 #include "mozilla/gfx/QuartzSupport.h"
  28 #include "MacIOSurfaceImage.h"
  29 #endif
  30
  31 #ifdef XP_WIN
  32 #include "gfxD2DSurface.h"
  33 #include "gfxWindowsPlatform.h"
  34 #include <d3d10_1.h>
  35 #include "d3d10/ImageLayerD3D10.h"
  36 #include "D3D9SurfaceImage.h"
  37 #endif
  38
  39 namespace mozilla {
  40 namespace layers {
  41
  42 using namespace mozilla::ipc;
  43 using namespace android;
  44 using namespace mozilla::gfx;
  45
  46 Atomic<int32_t> Image::sSerialCounter(0);
  47
  48 already_AddRefed<Image>
  49 ImageFactory::CreateImage(ImageFormat aFormat,
  50                           const gfx::IntSize &,
  51                           BufferRecycleBin *aRecycleBin)
  52 {
  53   nsRefPtr<Image> img;
  54 #ifdef MOZ_WIDGET_GONK
  55   if (aFormat == ImageFormat::GRALLOC_PLANAR_YCBCR) {
  56     img = new GrallocImage();
  57     return img.forget();
  58   }
  59   if (aFormat == ImageFormat::OVERLAY_IMAGE) {
  60     img = new OverlayImage();
  61     return img.forget();
  62   }
  63 #endif
  64   if (aFormat == ImageFormat::PLANAR_YCBCR) {
  65     img = new PlanarYCbCrImage(aRecycleBin);
  66     return img.forget();
  67   }
  68   if (aFormat == ImageFormat::CAIRO_SURFACE) {
  69     img = new CairoImage();
  70     return img.forget();
  71   }
  72 #ifdef MOZ_WIDGET_ANDROID
  73   if (aFormat == ImageFormat::SURFACE_TEXTURE) {
  74     img = new SurfaceTextureImage();
  75     return img.forget();
  76   }
  77 #endif
  78   if (aFormat == ImageFormat::EGLIMAGE) {
  79     img = new EGLImageImage();
  80     return img.forget();
  81   }
  82 #ifdef XP_MACOSX
  83   if (aFormat == ImageFormat::MAC_IOSURFACE) {
  84     img = new MacIOSurfaceImage();
  85     return img.forget();
  86   }
  87 #endif
  88 #ifdef XP_WIN
  89   if (aFormat == ImageFormat::D3D9_RGB32_TEXTURE) {
  90     img = new D3D9SurfaceImage();
  91     return img.forget();
  92   }
  93 #endif
  94   return nullptr;
  95 }
  96
  97 BufferRecycleBin::BufferRecycleBin()
  98   : mLock("mozilla.layers.BufferRecycleBin.mLock")
  99 {
 100 }
 101
 102 void
 103 BufferRecycleBin::RecycleBuffer(uint8_t* aBuffer, uint32_t aSize)
 104 {
 105   MutexAutoLock lock(mLock);
 106
 107   if (!mRecycledBuffers.IsEmpty() && aSize != mRecycledBufferSize) {
 108     mRecycledBuffers.Clear();
 109   }
 110   mRecycledBufferSize = aSize;
 111   mRecycledBuffers.AppendElement(aBuffer);
 112 }
 113
 114 uint8_t*
 115 BufferRecycleBin::GetBuffer(uint32_t aSize)
 116 {
 117   MutexAutoLock lock(mLock);
 118
 119   if (mRecycledBuffers.IsEmpty() || mRecycledBufferSize != aSize)
 120     return new uint8_t[aSize];
 121
 122   uint32_t last = mRecycledBuffers.Length() - 1;
 123   uint8_t* result = mRecycledBuffers[last].forget();
 124   mRecycledBuffers.RemoveElementAt(last);
 125   return result;
 126 }
 127
 128 ImageContainer::ImageContainer(int flag)
 129 : mReentrantMonitor("ImageContainer.mReentrantMonitor"),
 130   mPaintCount(0),
 131   mPreviousImagePainted(false),
 132   mImageFactory(new ImageFactory()),
 133   mRecycleBin(new BufferRecycleBin()),
 134   mRemoteData(nullptr),
 135   mRemoteDataMutex(nullptr),
 136   mCompositionNotifySink(nullptr),
 137   mImageClient(nullptr)
 138 {
 139   if (flag == ENABLE_ASYNC && ImageBridgeChild::IsCreated()) {
 140     // the refcount of this ImageClient is 1. we don't use a RefPtr here because the refcount
 141     // of this class must be done on the ImageBridge thread.
 142     mImageClient = ImageBridgeChild::GetSingleton()->CreateImageClient(CompositableType::BUFFER_IMAGE_SINGLE).drop();
 143     MOZ_ASSERT(mImageClient);
 144   }
 145 }
 146
 147 ImageContainer::~ImageContainer()
 148 {
 149   if (IsAsync()) {
 150     ImageBridgeChild::DispatchReleaseImageClient(mImageClient);
 151   }
 152 }
 153
 154 already_AddRefed<Image>
 155 ImageContainer::CreateImage(ImageFormat aFormat)
 156 {
 157   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 158
 159 #ifdef MOZ_WIDGET_GONK
 160   if (aFormat == ImageFormat::OVERLAY_IMAGE) {
 161     if (mImageClient && mImageClient->GetTextureInfo().mCompositableType != CompositableType::IMAGE_OVERLAY) {
 162       // If this ImageContainer is async but the image type mismatch, fix it here
 163       if (ImageBridgeChild::IsCreated()) {
 164         ImageBridgeChild::DispatchReleaseImageClient(mImageClient);
 165         mImageClient = ImageBridgeChild::GetSingleton()->CreateImageClient(CompositableType::IMAGE_OVERLAY).drop();
 166       }
 167     }
 168   }
 169 #endif
 170   if (mImageClient) {
 171     nsRefPtr<Image> img = mImageClient->CreateImage(aFormat);
 172     if (img) {
 173       return img.forget();
 174     }
 175   }
 176   return mImageFactory->CreateImage(aFormat, mScaleHint, mRecycleBin);
 177 }
 178
 179 void
 180 ImageContainer::SetCurrentImageInternal(Image *aImage)
 181 {
 182   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 183
 184   if (mRemoteData) {
 185     NS_ASSERTION(mRemoteDataMutex, "Should have remote data mutex when having remote data!");
 186     mRemoteDataMutex->Lock();
 187     // This is important since it ensures we won't change the active image
 188     // when we currently have a locked image that depends on mRemoteData.
 189   }
 190
 191   mActiveImage = aImage;
 192   CurrentImageChanged();
 193
 194   if (mRemoteData) {
 195     mRemoteDataMutex->Unlock();
 196   }
 197 }
 198
 199 void
 200 ImageContainer::ClearCurrentImage()
 201 {
 202   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 203   SetCurrentImageInternal(nullptr);
 204 }
 205
 206 void
 207 ImageContainer::SetCurrentImage(Image *aImage)
 208 {
 209   if (!aImage) {
 210     ClearAllImages();
 211     return;
 212   }
 213
 214   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 215   if (IsAsync()) {
 216     ImageBridgeChild::DispatchImageClientUpdate(mImageClient, this);
 217   }
 218   SetCurrentImageInternal(aImage);
 219 }
 220
 221  void
 222 ImageContainer::ClearAllImages()
 223 {
 224   if (IsAsync()) {
 225     // Let ImageClient release all TextureClients.
 226     ImageBridgeChild::FlushAllImages(mImageClient, this, false);
 227     return;
 228   }
 229
 230   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 231   SetCurrentImageInternal(nullptr);
 232 }
 233
 234 void
 235 ImageContainer::ClearAllImagesExceptFront()
 236 {
 237   if (IsAsync()) {
 238     // Let ImageClient release all TextureClients except front one.
 239     ImageBridgeChild::FlushAllImages(mImageClient, this, true);
 240   }
 241 }
 242
 243 void
 244 ImageContainer::SetCurrentImageInTransaction(Image *aImage)
 245 {
 246   NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
 247   NS_ASSERTION(!mImageClient, "Should use async image transfer with ImageBridge.");
 248
 249   SetCurrentImageInternal(aImage);
 250 }
 251
 252 bool ImageContainer::IsAsync() const {
 253   return mImageClient != nullptr;
 254 }
 255
 256 uint64_t ImageContainer::GetAsyncContainerID() const
 257 {
 258   NS_ASSERTION(IsAsync(),"Shared image ID is only relevant to async ImageContainers");
 259   if (IsAsync()) {
 260     return mImageClient->GetAsyncID();
 261   } else {
 262     return 0; // zero is always an invalid AsyncID
 263   }
 264 }
 265
 266 bool
 267 ImageContainer::HasCurrentImage()
 268 {
 269   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 270
 271   if (mRemoteData) {
 272     CrossProcessMutexAutoLock autoLock(*mRemoteDataMutex);
 273
 274     EnsureActiveImage();
 275
 276     return !!mActiveImage.get();
 277   }
 278
 279   return !!mActiveImage.get();
 280 }
 281
 282 already_AddRefed<Image>
 283 ImageContainer::LockCurrentImage()
 284 {
 285   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 286
 287   if (mRemoteData) {
 288     NS_ASSERTION(mRemoteDataMutex, "Should have remote data mutex when having remote data!");
 289     mRemoteDataMutex->Lock();
 290   }
 291
 292   EnsureActiveImage();
 293
 294   nsRefPtr<Image> retval = mActiveImage;
 295   return retval.forget();
 296 }
 297
 298 TemporaryRef<gfx::SourceSurface>
 299 ImageContainer::LockCurrentAsSourceSurface(gfx::IntSize *aSize, Image** aCurrentImage)
 300 {
 301   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 302
 303   if (mRemoteData) {
 304     NS_ASSERTION(mRemoteDataMutex, "Should have remote data mutex when having remote data!");
 305     mRemoteDataMutex->Lock();
 306
 307     EnsureActiveImage();
 308
 309     if (aCurrentImage) {
 310       NS_IF_ADDREF(mActiveImage);
 311       *aCurrentImage = mActiveImage.get();
 312     }
 313
 314     if (!mActiveImage) {
 315       return nullptr;
 316     }
 317
 318     if (mActiveImage->GetFormat() == ImageFormat::REMOTE_IMAGE_BITMAP) {
 319       gfxImageFormat fmt = mRemoteData->mFormat == RemoteImageData::BGRX32
 320                            ? gfxImageFormat::ARGB32
 321                            : gfxImageFormat::RGB24;
 322
 323       RefPtr<gfx::DataSourceSurface> newSurf
 324         = gfx::Factory::CreateWrappingDataSourceSurface(mRemoteData->mBitmap.mData,
 325                                                         mRemoteData->mBitmap.mStride,
 326                                                         mRemoteData->mSize,
 327                                                         gfx::ImageFormatToSurfaceFormat(fmt));
 328       *aSize = newSurf->GetSize();
 329
 330       return newSurf;
 331     }
 332
 333     *aSize = mActiveImage->GetSize();
 334     return mActiveImage->GetAsSourceSurface();
 335   }
 336
 337   if (aCurrentImage) {
 338     NS_IF_ADDREF(mActiveImage);
 339     *aCurrentImage = mActiveImage.get();
 340   }
 341
 342   if (!mActiveImage) {
 343     return nullptr;
 344   }
 345
 346   *aSize = mActiveImage->GetSize();
 347   return mActiveImage->GetAsSourceSurface();
 348 }
 349
 350 void
 351 ImageContainer::UnlockCurrentImage()
 352 {
 353   if (mRemoteData) {
 354     NS_ASSERTION(mRemoteDataMutex, "Should have remote data mutex when having remote data!");
 355     mRemoteDataMutex->Unlock();
 356   }
 357 }
 358
 359 TemporaryRef<gfx::SourceSurface>
 360 ImageContainer::GetCurrentAsSourceSurface(gfx::IntSize *aSize)
 361 {
 362   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 363
 364   if (mRemoteData) {
 365     CrossProcessMutexAutoLock autoLock(*mRemoteDataMutex);
 366     EnsureActiveImage();
 367
 368     if (!mActiveImage)
 369       return nullptr;
 370     *aSize = mRemoteData->mSize;
 371   } else {
 372     if (!mActiveImage)
 373       return nullptr;
 374     *aSize = mActiveImage->GetSize();
 375   }
 376   return mActiveImage->GetAsSourceSurface();
 377 }
 378
 379 gfx::IntSize
 380 ImageContainer::GetCurrentSize()
 381 {
 382   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 383
 384   if (mRemoteData) {
 385     CrossProcessMutexAutoLock autoLock(*mRemoteDataMutex);
 386
 387     // We don't need to ensure we have an active image here, as we need to
 388     // be in the mutex anyway, and this is easiest to return from there.
 389     return mRemoteData->mSize;
 390   }
 391
 392   if (!mActiveImage) {
 393     return gfx::IntSize(0, 0);
 394   }
 395
 396   return mActiveImage->GetSize();
 397 }
 398
 399 void
 400 ImageContainer::SetRemoteImageData(RemoteImageData *aData, CrossProcessMutex *aMutex)
 401 {
 402   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 403
 404   NS_ASSERTION(!mActiveImage || !aData, "No active image expected when SetRemoteImageData is called with non-NULL aData.");
 405   NS_ASSERTION(!mRemoteData || !aData, "No remote data expected when SetRemoteImageData is called with non-NULL aData.");
 406
 407   mRemoteData = aData;
 408
 409   if (aData) {
 410     memset(aData, 0, sizeof(RemoteImageData));
 411   } else {
 412     mActiveImage = nullptr;
 413   }
 414
 415   mRemoteDataMutex = aMutex;
 416 }
 417
 418 void
 419 ImageContainer::EnsureActiveImage()
 420 {
 421   if (mRemoteData) {
 422     if (mRemoteData->mWasUpdated) {
 423       mActiveImage = nullptr;
 424     }
 425
 426     if (mRemoteData->mType == RemoteImageData::RAW_BITMAP &&
 427         mRemoteData->mBitmap.mData && !mActiveImage) {
 428       nsRefPtr<RemoteBitmapImage> newImg = new RemoteBitmapImage();
 429
 430       newImg->mFormat = mRemoteData->mFormat;
 431       newImg->mData = mRemoteData->mBitmap.mData;
 432       newImg->mSize = mRemoteData->mSize;
 433       newImg->mStride = mRemoteData->mBitmap.mStride;
 434       mRemoteData->mWasUpdated = false;
 435
 436       mActiveImage = newImg;
 437     }
 438 #ifdef XP_WIN
 439     else if (mRemoteData->mType == RemoteImageData::DXGI_TEXTURE_HANDLE &&
 440              mRemoteData->mTextureHandle && !mActiveImage) {
 441       nsRefPtr<RemoteDXGITextureImage> newImg = new RemoteDXGITextureImage();
 442       newImg->mSize = mRemoteData->mSize;
 443       newImg->mHandle = mRemoteData->mTextureHandle;
 444       newImg->mFormat = mRemoteData->mFormat;
 445       mRemoteData->mWasUpdated = false;
 446
 447       mActiveImage = newImg;
 448     }
 449 #endif
 450   }
 451 }
 452
 453
 454 PlanarYCbCrImage::PlanarYCbCrImage(BufferRecycleBin *aRecycleBin)
 455   : Image(nullptr, ImageFormat::PLANAR_YCBCR)
 456   , mBufferSize(0)
 457   , mOffscreenFormat(gfxImageFormat::Unknown)
 458   , mRecycleBin(aRecycleBin)
 459 {
 460 }
 461
 462 PlanarYCbCrImage::~PlanarYCbCrImage()
 463 {
 464   if (mBuffer) {
 465     mRecycleBin->RecycleBuffer(mBuffer.forget(), mBufferSize);
 466   }
 467 }
 468
 469 size_t
 470 PlanarYCbCrImage::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
 471 {
 472   // Ignoring:
 473   // - mData - just wraps mBuffer
 474   // - Surfaces should be reported under gfx-surfaces-*:
 475   //   - mSourceSurface
 476   // - Base class:
 477   //   - mImplData is not used
 478   // Not owned:
 479   // - mRecycleBin
 480   size_t size = mBuffer.SizeOfExcludingThis(aMallocSizeOf);
 481
 482   // Could add in the future:
 483   // - mBackendData (from base class)
 484
 485   return size;
 486 }
 487
 488 uint8_t*
 489 PlanarYCbCrImage::AllocateBuffer(uint32_t aSize)
 490 {
 491   return mRecycleBin->GetBuffer(aSize);
 492 }
 493
 494 static void
 495 CopyPlane(uint8_t *aDst, const uint8_t *aSrc,
 496           const gfx::IntSize &aSize, int32_t aStride, int32_t aSkip)
 497 {
 498   if (!aSkip) {
 499     // Fast path: planar input.
 500     memcpy(aDst, aSrc, aSize.height * aStride);
 501   } else {
 502     int32_t height = aSize.height;
 503     int32_t width = aSize.width;
 504     for (int y = 0; y < height; ++y) {
 505       const uint8_t *src = aSrc;
 506       uint8_t *dst = aDst;
 507       // Slow path
 508       for (int x = 0; x < width; ++x) {
 509         *dst++ = *src++;
 510         src += aSkip;
 511       }
 512       aSrc += aStride;
 513       aDst += aStride;
 514     }
 515   }
 516 }
 517
 518 void
 519 PlanarYCbCrImage::CopyData(const Data& aData)
 520 {
 521   mData = aData;
 522
 523   // update buffer size
 524   size_t size = mData.mCbCrStride * mData.mCbCrSize.height * 2 +
 525                 mData.mYStride * mData.mYSize.height;
 526
 527   // get new buffer
 528   mBuffer = AllocateBuffer(size);
 529   if (!mBuffer)
 530     return;
 531
 532   // update buffer size
 533   mBufferSize = size;
 534
 535   mData.mYChannel = mBuffer;
 536   mData.mCbChannel = mData.mYChannel + mData.mYStride * mData.mYSize.height;
 537   mData.mCrChannel = mData.mCbChannel + mData.mCbCrStride * mData.mCbCrSize.height;
 538
 539   CopyPlane(mData.mYChannel, aData.mYChannel,
 540             mData.mYSize, mData.mYStride, mData.mYSkip);
 541   CopyPlane(mData.mCbChannel, aData.mCbChannel,
 542             mData.mCbCrSize, mData.mCbCrStride, mData.mCbSkip);
 543   CopyPlane(mData.mCrChannel, aData.mCrChannel,
 544             mData.mCbCrSize, mData.mCbCrStride, mData.mCrSkip);
 545
 546   mSize = aData.mPicSize;
 547 }
 548
 549 void
 550 PlanarYCbCrImage::SetData(const Data &aData)
 551 {
 552   CopyData(aData);
 553 }
 554
 555 gfxImageFormat
 556 PlanarYCbCrImage::GetOffscreenFormat()
 557 {
 558   return mOffscreenFormat == gfxImageFormat::Unknown ?
 559     gfxPlatform::GetPlatform()->GetOffscreenFormat() :
 560     mOffscreenFormat;
 561 }
 562
 563 void
 564 PlanarYCbCrImage::SetDataNoCopy(const Data &aData)
 565 {
 566   mData = aData;
 567   mSize = aData.mPicSize;
 568 }
 569
 570 uint8_t*
 571 PlanarYCbCrImage::AllocateAndGetNewBuffer(uint32_t aSize)
 572 {
 573   // get new buffer
 574   mBuffer = AllocateBuffer(aSize);
 575   if (mBuffer) {
 576     // update buffer size
 577     mBufferSize = aSize;
 578   }
 579   return mBuffer;
 580 }
 581
 582 TemporaryRef<gfx::SourceSurface>
 583 PlanarYCbCrImage::GetAsSourceSurface()
 584 {
 585   if (mSourceSurface) {
 586     return mSourceSurface.get();
 587   }
 588
 589   gfx::IntSize size(mSize);
 590   gfx::SurfaceFormat format = gfx::ImageFormatToSurfaceFormat(GetOffscreenFormat());
 591   gfx::GetYCbCrToRGBDestFormatAndSize(mData, format, size);
 592   if (mSize.width > PlanarYCbCrImage::MAX_DIMENSION ||
 593       mSize.height > PlanarYCbCrImage::MAX_DIMENSION) {
 594     NS_ERROR("Illegal image dest width or height");
 595     return nullptr;
 596   }
 597
 598   RefPtr<gfx::DataSourceSurface> surface = gfx::Factory::CreateDataSourceSurface(size, format);
 599   if (NS_WARN_IF(!surface)) {
 600     return nullptr;
 601   }
 602
 603   gfx::ConvertYCbCrToRGB(mData, format, size, surface->GetData(), surface->Stride());
 604
 605   mSourceSurface = surface;
 606
 607   return surface.forget();
 608 }
 609
 610 TemporaryRef<gfx::SourceSurface>
 611 RemoteBitmapImage::GetAsSourceSurface()
 612 {
 613   gfx::SurfaceFormat fmt = mFormat == RemoteImageData::BGRX32
 614                          ? gfx::SurfaceFormat::B8G8R8X8
 615                          : gfx::SurfaceFormat::B8G8R8A8;
 616   RefPtr<gfx::DataSourceSurface> newSurf = gfx::Factory::CreateDataSourceSurface(mSize, fmt);
 617   if (NS_WARN_IF(!newSurf)) {
 618     return nullptr;
 619   }
 620
 621   for (int y = 0; y < mSize.height; y++) {
 622     memcpy(newSurf->GetData() + newSurf->Stride() * y,
 623            mData + mStride * y,
 624            mSize.width * 4);
 625   }
 626
 627   return newSurf;
 628 }
 629
 630 CairoImage::CairoImage()
 631   : Image(nullptr, ImageFormat::CAIRO_SURFACE)
 632 {}
 633
 634 CairoImage::~CairoImage()
 635 {
 636 }
 637
 638 TextureClient*
 639 CairoImage::GetTextureClient(CompositableClient *aClient)
 640 {
 641   if (!aClient) {
 642     return nullptr;
 643   }
 644
 645   CompositableForwarder* forwarder = aClient->GetForwarder();
 646   RefPtr<TextureClient> textureClient = mTextureClients.Get(forwarder->GetSerial());
 647   if (textureClient) {
 648     return textureClient;
 649   }
 650
 651   RefPtr<SourceSurface> surface = GetAsSourceSurface();
 652   MOZ_ASSERT(surface);
 653   if (!surface) {
 654     return nullptr;
 655   }
 656
 657
 658 // XXX windows' TextureClients do not hold ISurfaceAllocator,
 659 // recycler does not work on windows.
 660 #ifndef XP_WIN
 661
 662 // XXX only gonk ensure when TextureClient is recycled,
 663 // TextureHost is not used by CompositableHost.
 664 #ifdef MOZ_WIDGET_GONK
 665   RefPtr<TextureClientRecycleAllocator> recycler =
 666     aClient->GetTextureClientRecycler();
 667   if (recycler) {
 668     textureClient =
 669       recycler->CreateOrRecycleForDrawing(surface->GetFormat(),
 670                                           surface->GetSize(),
 671                                           gfx::BackendType::NONE,
 672                                           aClient->GetTextureFlags());
 673   }
 674 #endif
 675
 676 #endif
 677   if (!textureClient) {
 678     // gfx::BackendType::NONE means default to content backend
 679     textureClient = aClient->CreateTextureClientForDrawing(surface->GetFormat(),
 680                                                            surface->GetSize(),
 681                                                            gfx::BackendType::NONE,
 682                                                            TextureFlags::DEFAULT);
 683   }
 684   if (!textureClient) {
 685     return nullptr;
 686   }
 687   MOZ_ASSERT(textureClient->CanExposeDrawTarget());
 688   if (!textureClient->Lock(OpenMode::OPEN_WRITE_ONLY)) {
 689     return nullptr;
 690   }
 691
 692   TextureClientAutoUnlock autoUnolck(textureClient);
 693   {
 694     // We must not keep a reference to the DrawTarget after it has been unlocked.
 695     DrawTarget* dt = textureClient->BorrowDrawTarget();
 696     if (!dt) {
 697       return nullptr;
 698     }
 699     dt->CopySurface(surface, IntRect(IntPoint(), surface->GetSize()), IntPoint());
 700   }
 701
 702   mTextureClients.Put(forwarder->GetSerial(), textureClient);
 703   return textureClient;
 704 }
 705
 706 } // namespace
 707 } // namespace