自学教程：C++ GetForwarder函数代码示例

voidContentClientDoubleBuffered::Updated(const nsIntRegion& aRegionToDraw,                                     const nsIntRegion& aVisibleRegion,                                     bool aDidSelfCopy){  ContentClientRemoteBuffer::Updated(aRegionToDraw, aVisibleRegion, aDidSelfCopy);#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17  if (mFrontClient) {    // remove old buffer from CompositableHost    RefPtr<AsyncTransactionWaiter> waiter = new AsyncTransactionWaiter();    RefPtr<AsyncTransactionTracker> tracker =        new RemoveTextureFromCompositableTracker(waiter);    // Hold TextureClient until transaction complete.    tracker->SetTextureClient(mFrontClient);    mFrontClient->SetRemoveFromCompositableWaiter(waiter);    // RemoveTextureFromCompositableAsync() expects CompositorChild's presence.    GetForwarder()->RemoveTextureFromCompositableAsync(tracker, this, mFrontClient);  }  if (mFrontClientOnWhite) {    // remove old buffer from CompositableHost    RefPtr<AsyncTransactionWaiter> waiter = new AsyncTransactionWaiter();    RefPtr<AsyncTransactionTracker> tracker =        new RemoveTextureFromCompositableTracker(waiter);    // Hold TextureClient until transaction complete.    tracker->SetTextureClient(mFrontClientOnWhite);    mFrontClientOnWhite->SetRemoveFromCompositableWaiter(waiter);    // RemoveTextureFromCompositableAsync() expects CompositorChild's presence.    GetForwarder()->RemoveTextureFromCompositableAsync(tracker, this, mFrontClientOnWhite);  }#endif}

TemporaryRef<TextureClient>CompositableClient::CreateTextureClientForDrawing(SurfaceFormat aFormat,                                                  TextureFlags aTextureFlags){  RefPtr<TextureClient> result;#ifdef XP_WIN  LayersBackend parentBackend = GetForwarder()->GetCompositorBackendType();  if (parentBackend == LAYERS_D3D11 && gfxWindowsPlatform::GetPlatform()->GetD2DDevice() &&      !(aTextureFlags & TEXTURE_ALLOC_FALLBACK)) {    result = new TextureClientD3D11(aFormat, aTextureFlags);  }  if (parentBackend == LAYERS_D3D9 &&      !GetForwarder()->ForwardsToDifferentProcess() &&      !(aTextureFlags & TEXTURE_ALLOC_FALLBACK)) {    // non-DIB textures don't work with alpha, see notes in TextureD3D9.    if (ContentForFormat(aFormat) != GFX_CONTENT_COLOR) {      result = new DIBTextureClientD3D9(aFormat, aTextureFlags);    } else {      result = new CairoTextureClientD3D9(aFormat, aTextureFlags);    }  }#endif  // Can't do any better than a buffer texture client.  if (!result) {    result = CreateBufferTextureClient(aFormat, aTextureFlags);  }  MOZ_ASSERT(!result || result->AsTextureClientDrawTarget(),             "Not a TextureClientDrawTarget?");  return result;}

voidCanvasClientSharedSurface::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer){  if (mFront) {    mPrevFront = mFront;    mFront = nullptr;  }  auto gl = aLayer->mGLContext;  gl->MakeCurrent();  if (aLayer->mGLFrontbuffer) {    mFront = CloneSurface(aLayer->mGLFrontbuffer.get(), aLayer->mFactory.get());    if (mFront)      mFront->Surf()->Fence();  } else {    mFront = gl->Screen()->Front();    if (!mFront)      return;  }  MOZ_ASSERT(mFront);  // Alright, now sort out the IPC goop.  SharedSurface* surf = mFront->Surf();  auto forwarder = GetForwarder();  auto flags = GetTextureFlags() | TextureFlags::IMMUTABLE;  // Get a TexClient from our surf.  RefPtr<TextureClient> newTex = TexClientFromShSurf(surf, flags);  if (!newTex) {    auto manager = aLayer->ClientManager();    auto shadowForwarder = manager->AsShadowForwarder();    auto layersBackend = shadowForwarder->GetCompositorBackendType();    newTex = TexClientFromReadback(surf, forwarder, flags, layersBackend);  }  MOZ_ASSERT(newTex);  // Add the new TexClient.  MOZ_ALWAYS_TRUE( AddTextureClient(newTex) );  // Remove the old TexClient.  if (mFrontTex) {    // remove old buffer from CompositableHost    RefPtr<AsyncTransactionTracker> tracker = new RemoveTextureFromCompositableTracker();    // Hold TextureClient until transaction complete.    tracker->SetTextureClient(mFrontTex);    mFrontTex->SetRemoveFromCompositableTracker(tracker);    // RemoveTextureFromCompositableAsync() expects CompositorChild's presence.    GetForwarder()->RemoveTextureFromCompositableAsync(tracker, this, mFrontTex);    mFrontTex = nullptr;  }  // Use the new TexClient.  mFrontTex = newTex;  forwarder->UpdatedTexture(this, mFrontTex, nullptr);  forwarder->UseTexture(this, mFrontTex);}

bool ClientCanvasRenderer::CreateCompositable() {  if (!mCanvasClient) {    TextureFlags flags = TextureFlags::DEFAULT;    if (mOriginPos == gl::OriginPos::BottomLeft) {      flags |= TextureFlags::ORIGIN_BOTTOM_LEFT;    }    if (!mIsAlphaPremultiplied) {      flags |= TextureFlags::NON_PREMULTIPLIED;    }    mCanvasClient = CanvasClient::CreateCanvasClient(GetCanvasClientType(),                                                     GetForwarder(), flags);    if (!mCanvasClient) {      return false;    }    if (mLayer->HasShadow()) {      if (mAsyncRenderer) {        static_cast<CanvasClientBridge*>(mCanvasClient.get())->SetLayer(mLayer);      } else {        mCanvasClient->Connect();        GetForwarder()->AsLayerForwarder()->Attach(mCanvasClient, mLayer);      }    }  }  return true;}

voidCanvasClientSurfaceStream::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer){  GLScreenBuffer* screen = aLayer->mGLContext->Screen();  SurfaceStream* stream = screen->Stream();  bool isCrossProcess = !(XRE_GetProcessType() == GeckoProcessType_Default);  bool bufferCreated = false;  if (isCrossProcess) {#ifdef MOZ_WIDGET_GONK    SharedSurface* surf = stream->SwapConsumer();    if (!surf) {      printf_stderr("surf is null post-SwapConsumer!/n");      return;    }    if (surf->Type() != SharedSurfaceType::Gralloc) {      printf_stderr("Unexpected non-Gralloc SharedSurface in IPC path!");      MOZ_ASSERT(false);      return;    }    SharedSurface_Gralloc* grallocSurf = SharedSurface_Gralloc::Cast(surf);    GrallocTextureClientOGL* grallocTextureClient =      static_cast<GrallocTextureClientOGL*>(grallocSurf->GetTextureClient());    // If IPDLActor is null means this TextureClient didn't AddTextureClient yet    if (!grallocTextureClient->GetIPDLActor()) {      grallocTextureClient->SetTextureFlags(mTextureInfo.mTextureFlags);      AddTextureClient(grallocTextureClient);    }    if (grallocTextureClient->GetIPDLActor()) {      GetForwarder()->UseTexture(this, grallocTextureClient);    }#else    printf_stderr("isCrossProcess, but not MOZ_WIDGET_GONK! Someone needs to write some code!");    MOZ_ASSERT(false);#endif  } else {    if (!mBuffer) {      StreamTextureClientOGL* textureClient =        new StreamTextureClientOGL(mTextureInfo.mTextureFlags);      textureClient->InitWith(stream);      mBuffer = textureClient;      bufferCreated = true;    }    if (bufferCreated && !AddTextureClient(mBuffer)) {      mBuffer = nullptr;    }    if (mBuffer) {      GetForwarder()->UseTexture(this, mBuffer);    }  }  aLayer->Painted();}

already_AddRefed<TextureClient>CanvasClient2D::CreateTextureClientForCanvas(gfx::SurfaceFormat aFormat,                                             gfx::IntSize aSize,                                             TextureFlags aFlags,                                             ClientCanvasLayer* aLayer){  if (aLayer->IsGLLayer()) {    // We want a cairo backend here as we don't want to be copying into    // an accelerated backend and we like LockBits to work. This is currently    // the most effective way to make this work.    return TextureClient::CreateForRawBufferAccess(GetForwarder(),                                                   aFormat, aSize, BackendType::CAIRO,                                                   mTextureFlags | aFlags);  }#ifdef XP_WIN  return CreateTextureClientForDrawing(aFormat, aSize, BackendSelector::Canvas, aFlags);#else  // XXX - We should use CreateTextureClientForDrawing, but we first need  // to use double buffering.  gfx::BackendType backend = gfxPlatform::GetPlatform()->GetPreferredCanvasBackend();  return TextureClient::CreateForRawBufferAccess(GetForwarder(),                                                 aFormat, aSize, backend,                                                 mTextureFlags | aFlags);#endif}

voidCanvasClient2D::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer){  AutoRemoveTexture autoRemove(this);  if (mBuffer &&      (mBuffer->IsImmutable() || mBuffer->GetSize() != aSize)) {    autoRemove.mTexture = mBuffer;    mBuffer = nullptr;  }  bool bufferCreated = false;  if (!mBuffer) {    bool isOpaque = (aLayer->GetContentFlags() & Layer::CONTENT_OPAQUE);    gfxContentType contentType = isOpaque                                                ? gfxContentType::COLOR                                                : gfxContentType::COLOR_ALPHA;    gfxImageFormat format      = gfxPlatform::GetPlatform()->OptimalFormatForContent(contentType);    TextureFlags flags = TextureFlags::DEFAULT;    if (mTextureFlags & TextureFlags::NEEDS_Y_FLIP) {      flags |= TextureFlags::NEEDS_Y_FLIP;    }    gfx::SurfaceFormat surfaceFormat = gfx::ImageFormatToSurfaceFormat(format);    mBuffer = CreateTextureClientForCanvas(surfaceFormat, aSize, flags, aLayer);    MOZ_ASSERT(mBuffer->CanExposeDrawTarget());    mBuffer->AllocateForSurface(aSize);    bufferCreated = true;  }  if (!mBuffer->Lock(OpenMode::OPEN_WRITE_ONLY)) {    mBuffer = nullptr;    return;  }  bool updated = false;  {    // Restrict drawTarget to a scope so that terminates before Unlock.    RefPtr<DrawTarget> target =      mBuffer->BorrowDrawTarget();    if (target) {      aLayer->UpdateTarget(target);      updated = true;    }  }  mBuffer->Unlock();  if (bufferCreated && !AddTextureClient(mBuffer)) {    mBuffer = nullptr;    return;  }  if (updated) {    GetForwarder()->UpdatedTexture(this, mBuffer, nullptr);    GetForwarder()->UseTexture(this, mBuffer);  }}

boolCompositableClient::Connect(){  if (!GetForwarder() || GetIPDLActor()) {    return false;  }  GetForwarder()->Connect(this);  return true;}

voidImageClientBuffered::FlushAllImages(bool aExceptFront){  if (!aExceptFront && mFrontBuffer) {    GetForwarder()->RemoveTextureFromCompositable(this, mFrontBuffer);    mFrontBuffer = nullptr;  }  if (mBackBuffer) {    GetForwarder()->RemoveTextureFromCompositable(this, mBackBuffer);    mBackBuffer = nullptr;  }}

voidCanvasClient2D::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer){  if (mBuffer &&      (mBuffer->IsImmutable() || mBuffer->GetSize() != aSize)) {    GetForwarder()->RemoveTextureFromCompositable(this, mBuffer);    mBuffer = nullptr;  }  bool bufferCreated = false;  if (!mBuffer) {    bool isOpaque = (aLayer->GetContentFlags() & Layer::CONTENT_OPAQUE);    gfxContentType contentType = isOpaque                                                ? gfxContentType::COLOR                                                : gfxContentType::COLOR_ALPHA;    gfxImageFormat format      = gfxPlatform::GetPlatform()->OptimalFormatForContent(contentType);    mBuffer = CreateBufferTextureClient(gfx::ImageFormatToSurfaceFormat(format));    MOZ_ASSERT(mBuffer->AsTextureClientSurface());    mBuffer->AsTextureClientSurface()->AllocateForSurface(aSize);    bufferCreated = true;  }  if (!mBuffer->Lock(OPEN_WRITE_ONLY)) {    return;  }  bool updated = false;  {    // Restrict drawTarget to a scope so that terminates before Unlock.    RefPtr<DrawTarget> drawTarget =      mBuffer->AsTextureClientDrawTarget()->GetAsDrawTarget();    if (drawTarget) {      aLayer->UpdateTarget(drawTarget);      updated = true;    }  }  mBuffer->Unlock();  if (bufferCreated && !AddTextureClient(mBuffer)) {    mBuffer = nullptr;    return;  }  if (updated) {    GetForwarder()->UpdatedTexture(this, mBuffer, nullptr);    GetForwarder()->UseTexture(this, mBuffer);  }}

TemporaryRef<DeprecatedTextureClient>CompositableClient::CreateDeprecatedTextureClient(DeprecatedTextureClientType aDeprecatedTextureClientType){  MOZ_ASSERT(GetForwarder(), "Can't create a texture client if the compositable is not connected to the compositor.");  LayersBackend parentBackend = GetForwarder()->GetCompositorBackendType();  RefPtr<DeprecatedTextureClient> result;  switch (aDeprecatedTextureClientType) {  case TEXTURE_SHARED_GL:    if (parentBackend == LAYERS_OPENGL) {      result = new DeprecatedTextureClientSharedOGL(GetForwarder(), GetTextureInfo());    }     break;  case TEXTURE_SHARED_GL_EXTERNAL:    if (parentBackend == LAYERS_OPENGL) {      result = new DeprecatedTextureClientSharedOGLExternal(GetForwarder(), GetTextureInfo());    }    break;  case TEXTURE_STREAM_GL:    if (parentBackend == LAYERS_OPENGL) {      result = new DeprecatedTextureClientStreamOGL(GetForwarder(), GetTextureInfo());    }    break;  case TEXTURE_YCBCR:    if (parentBackend == LAYERS_OPENGL ||        parentBackend == LAYERS_D3D11 ||        parentBackend == LAYERS_BASIC) {      result = new DeprecatedTextureClientShmemYCbCr(GetForwarder(), GetTextureInfo());    }    break;  case TEXTURE_CONTENT:#ifdef XP_WIN    if (parentBackend == LAYERS_D3D11 && gfxWindowsPlatform::GetPlatform()->GetD2DDevice()) {      result = new DeprecatedTextureClientD3D11(GetForwarder(), GetTextureInfo());      break;    }#endif     // fall through to TEXTURE_SHMEM  case TEXTURE_SHMEM:    result = new DeprecatedTextureClientShmem(GetForwarder(), GetTextureInfo());    break;  default:    MOZ_ASSERT(false, "Unhandled texture client type");  }  // If we couldn't create an appropriate texture client,  // then return nullptr so the caller can chose another  // type.  if (!result) {    return nullptr;  }  MOZ_ASSERT(result->SupportsType(aDeprecatedTextureClientType),             "Created the wrong texture client?");  result->SetFlags(GetTextureInfo().mTextureFlags);  return result.forget();}

voidShareableCanvasRenderer::UpdateCompositableClient(){  if (!CreateCompositable()) {    return;  }  if (mCanvasClient && mAsyncRenderer) {    mCanvasClient->UpdateAsync(mAsyncRenderer);  }  if (!IsDirty()) {    return;  }  ResetDirty();  FirePreTransactionCallback();  if (mBufferProvider && mBufferProvider->GetTextureClient()) {    if (!mBufferProvider->SetKnowsCompositor(GetForwarder())) {      gfxCriticalNote << "BufferProvider::SetForwarder failed";      return;    }    mCanvasClient->UpdateFromTexture(mBufferProvider->GetTextureClient());  } else {    mCanvasClient->Update(gfx::IntSize(mSize.width, mSize.height), this);  }  FireDidTransactionCallback();  mCanvasClient->Updated();}

bool WebRenderCanvasRendererAsync::CreateCompositable() {  if (!mCanvasClient) {    TextureFlags flags = TextureFlags::DEFAULT;    if (mOriginPos == gl::OriginPos::BottomLeft) {      flags |= TextureFlags::ORIGIN_BOTTOM_LEFT;    }    if (!mIsAlphaPremultiplied) {      flags |= TextureFlags::NON_PREMULTIPLIED;    }    mCanvasClient = CanvasClient::CreateCanvasClient(GetCanvasClientType(),                                                     GetForwarder(), flags);    if (!mCanvasClient) {      return false;    }    mCanvasClient->Connect();  }  if (!mPipelineId) {    // Alloc async image pipeline id.    mPipelineId = Some(        mManager->WrBridge()->GetCompositorBridgeChild()->GetNextPipelineId());    mManager->AddPipelineIdForCompositable(mPipelineId.ref(),                                           mCanvasClient->GetIPCHandle());  }  return true;}

boolWebRenderCanvasRendererSync::CreateCompositable(){  if (!mCanvasClient) {    TextureFlags flags = TextureFlags::DEFAULT;    if (mOriginPos == gl::OriginPos::BottomLeft) {      flags |= TextureFlags::ORIGIN_BOTTOM_LEFT;    }    if (!mIsAlphaPremultiplied) {      flags |= TextureFlags::NON_PREMULTIPLIED;    }    mCanvasClient = CanvasClient::CreateCanvasClient(GetCanvasClientType(),                                                     GetForwarder(),                                                     flags);    if (!mCanvasClient) {      return false;    }    mCanvasClient->Connect();  }  if (mExternalImageId.isNothing()) {    mExternalImageId = Some(mManager->WrBridge()->AllocExternalImageIdForCompositable(mCanvasClient));  }  return true;}

voidContentClientRemoteBuffer::Updated(const nsIntRegion& aRegionToDraw,                                   const nsIntRegion& aVisibleRegion,                                   bool aDidSelfCopy){  nsIntRegion updatedRegion = GetUpdatedRegion(aRegionToDraw,                                               aVisibleRegion,                                               aDidSelfCopy);  MOZ_ASSERT(mTextureClient);  if (mTextureClientOnWhite) {    mForwarder->UseComponentAlphaTextures(this, mTextureClient,                                          mTextureClientOnWhite);  } else {    nsAutoTArray<CompositableForwarder::TimedTextureClient,1> textures;    CompositableForwarder::TimedTextureClient* t = textures.AppendElement();    t->mTextureClient = mTextureClient;    IntSize size = mTextureClient->GetSize();    t->mPictureRect = nsIntRect(0, 0, size.width, size.height);    GetForwarder()->UseTextures(this, textures);  }  mForwarder->UpdateTextureRegion(this,                                  ThebesBufferData(BufferRect(),                                                   BufferRotation()),                                  updatedRegion);}

voidCanvasClientBridge::UpdateAsync(AsyncCanvasRenderer* aRenderer){  if (!GetForwarder() || !mLayer || !aRenderer ||      !aRenderer->GetCanvasClient()) {    return;  }  uint64_t asyncID = aRenderer->GetCanvasClientAsyncID();  if (asyncID == 0 || mAsyncID == asyncID) {    return;  }  static_cast<ShadowLayerForwarder*>(GetForwarder())    ->AttachAsyncCompositable(asyncID, mLayer);  mAsyncID = asyncID;}

voidCanvasClient2D::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer){  if (mBuffer &&      (mBuffer->IsImmutable() || mBuffer->GetSize() != aSize)) {    mBuffer->ForceRemove();    mBuffer = nullptr;  }  bool bufferCreated = false;  if (!mBuffer) {    bool isOpaque = (aLayer->GetContentFlags() & Layer::CONTENT_OPAQUE);    gfxContentType contentType = isOpaque                                                ? GFX_CONTENT_COLOR                                                : GFX_CONTENT_COLOR_ALPHA;    gfxImageFormat format      = gfxPlatform::GetPlatform()->OptimalFormatForContent(contentType);    mBuffer = CreateBufferTextureClient(gfx::ImageFormatToSurfaceFormat(format));    MOZ_ASSERT(mBuffer->AsTextureClientSurface());    mBuffer->AsTextureClientSurface()->AllocateForSurface(aSize);    bufferCreated = true;  }  if (!mBuffer->Lock(OPEN_WRITE_ONLY)) {    return;  }  nsRefPtr<gfxASurface> surface = mBuffer->AsTextureClientSurface()->GetAsSurface();  if (surface) {    aLayer->UpdateSurface(surface);  }  mBuffer->Unlock();  if (bufferCreated && !AddTextureClient(mBuffer)) {    mBuffer = nullptr;    return;  }  if (surface) {    GetForwarder()->UpdatedTexture(this, mBuffer, nullptr);    GetForwarder()->UseTexture(this, mBuffer);  }}

TemporaryRef<BufferTextureClient>CompositableClient::CreateBufferTextureClient(gfx::SurfaceFormat aFormat,                                              gfx::IntSize aSize,                                              gfx::BackendType aMoz2DBackend,                                              TextureFlags aTextureFlags){  return TextureClient::CreateForRawBufferAccess(GetForwarder(),                                                 aFormat, aSize, aMoz2DBackend,                                                 aTextureFlags | mTextureFlags);}

already_AddRefed<Image>DeprecatedImageClientSingle::CreateImage(ImageFormat aFormat){  nsRefPtr<Image> img;  switch (aFormat) {    case ImageFormat::PLANAR_YCBCR:      img = new DeprecatedSharedPlanarYCbCrImage(GetForwarder());      return img.forget();    case ImageFormat::SHARED_RGB:      img = new DeprecatedSharedRGBImage(GetForwarder());      return img.forget();#ifdef MOZ_WIDGET_GONK    case ImageFormat::GRALLOC_PLANAR_YCBCR:      img = new GrallocImage();      return img.forget();#endif    default:      return nullptr;  }}

voidCompositableClient::OnReplyTextureRemoved(uint64_t aTextureID){  std::map<uint64_t,TextureClientData*>::iterator it    = mTexturesToRemoveCallbacks.find(aTextureID);  if (it != mTexturesToRemoveCallbacks.end()) {    it->second->DeallocateSharedData(GetForwarder());    delete it->second;    mTexturesToRemoveCallbacks.erase(it);  }}

voidDeprecatedTextureClientShmemYCbCr::SetDescriptor(const SurfaceDescriptor& aDescriptor){  MOZ_ASSERT(aDescriptor.type() == SurfaceDescriptor::TYCbCrImage ||             aDescriptor.type() == SurfaceDescriptor::T__None);  if (IsSurfaceDescriptorValid(mDescriptor)) {    GetForwarder()->DestroySharedSurface(&mDescriptor);  }  mDescriptor = aDescriptor;}

TemporaryRef<TextureClient>CompositableClient::CreateTextureClientForDrawing(gfx::SurfaceFormat aFormat,                                                  gfx::IntSize aSize,                                                  gfx::BackendType aMoz2DBackend,                                                  TextureFlags aTextureFlags,                                                  TextureAllocationFlags aAllocFlags){  return TextureClient::CreateForDrawing(GetForwarder(),                                         aFormat, aSize, aMoz2DBackend,                                         aTextureFlags | mTextureFlags,                                         aAllocFlags);}

voidCanvasClientSharedSurface::Updated(){  if (!mNewFront) {    return;  }  auto forwarder = GetForwarder();#ifndef MOZ_WIDGET_GONK  if (mFront) {    if (mFront->GetFlags() & TextureFlags::RECYCLE) {      mFront->WaitForCompositorRecycle();    }  }#else  // AutoRemoveTexture does the followings.  // - Ensure to deliver FenceHandle from TextureHost to TextureClient, before  //   next TextureClient usage.  // - Control TextureClient's recycling timing.  // - Call RemoveTexture() after newFront's UseTextures() call.  //   It could improve performance of Host side's EGL handling on gonk  AutoRemoveTexture autoRemove(this);  if (mFront && mFront != mNewFront) {    autoRemove.mTexture = mFront;  }#endif  mFront = mNewFront;  mNewFront = nullptr;  // Add the new TexClient.  MOZ_ALWAYS_TRUE( AddTextureClient(mFront) );  AutoTArray<CompositableForwarder::TimedTextureClient,1> textures;  CompositableForwarder::TimedTextureClient* t = textures.AppendElement();  t->mTextureClient = mFront;  t->mPictureRect = nsIntRect(nsIntPoint(0, 0), mFront->GetSize());  t->mFrameID = mFrameID;  // XXX TODO - This reference to VRManagerChild will be moved with the  //            implementation of the WebVR 1.0 API, which will enable  //            the inputFrameID to be passed through Javascript with  //            the new VRDisplay API.  t->mInputFrameID = VRManagerChild::Get()->GetInputFrameID();  forwarder->UseTextures(this, textures);}

voidShareableCanvasRenderer::Initialize(const CanvasInitializeData& aData){  CopyableCanvasRenderer::Initialize(aData);  mCanvasClient = nullptr;  if (!mGLContext)    return;  gl::GLScreenBuffer* screen = mGLContext->Screen();  gl::SurfaceCaps caps;  if (mGLFrontbuffer) {    // The screen caps are irrelevant if we're using a separate frontbuffer.    caps = mGLFrontbuffer->mHasAlpha ? gl::SurfaceCaps::ForRGBA()                                     : gl::SurfaceCaps::ForRGB();  } else {    MOZ_ASSERT(screen);    caps = screen->mCaps;  }  auto forwarder = GetForwarder();  mFlags = TextureFlags::ORIGIN_BOTTOM_LEFT;  if (!aData.mIsGLAlphaPremult) {    mFlags |= TextureFlags::NON_PREMULTIPLIED;  }  UniquePtr<gl::SurfaceFactory> factory =    gl::GLScreenBuffer::CreateFactory(mGLContext, caps, forwarder, mFlags);  if (mGLFrontbuffer) {    // We're using a source other than the one in the default screen.    // (SkiaGL)    mFactory = Move(factory);    if (!mFactory) {      // Absolutely must have a factory here, so create a basic one      mFactory = MakeUnique<gl::SurfaceFactory_Basic>(mGLContext, caps, mFlags);    }  } else {    if (factory)      screen->Morph(Move(factory));  }}