gecko-dev/gfx/layers/client/ClientLayerManager.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "ClientLayerManager.h"
#include "GeckoProfiler.h"       // for AUTO_PROFILER_LABEL
#include "gfxEnv.h"              // for gfxEnv
#include "mozilla/Assertions.h"  // for MOZ_ASSERT, etc
#include "mozilla/Hal.h"
#include "mozilla/StaticPrefs_apz.h"
#include "mozilla/StaticPrefs_gfx.h"
#include "mozilla/StaticPrefs_layers.h"
#include "mozilla/dom/BrowserChild.h"  // for BrowserChild
#include "mozilla/hal_sandbox/PHal.h"  // for ScreenConfiguration
#include "mozilla/layers/CompositableClient.h"
#include "mozilla/layers/CompositorBridgeChild.h"  // for CompositorBridgeChild
#include "mozilla/layers/FrameUniformityData.h"
#include "mozilla/layers/ISurfaceAllocator.h"
#include "mozilla/layers/LayersMessages.h"  // for EditReply, etc
#include "mozilla/layers/LayersSurfaces.h"  // for SurfaceDescriptor
#include "mozilla/layers/LayerTransactionChild.h"
#include "mozilla/layers/PersistentBufferProvider.h"
#include "mozilla/layers/SyncObject.h"
#include "mozilla/PerfStats.h"
#include "ClientReadbackLayer.h"  // for ClientReadbackLayer
#include "nsAString.h"
#include "nsDisplayList.h"
#include "nsIWidgetListener.h"
#include "nsTArray.h"     // for AutoTArray
#include "nsXULAppAPI.h"  // for XRE_GetProcessType, etc
#include "TiledLayerBuffer.h"
#include "FrameLayerBuilder.h"  // for FrameLayerbuilder
#ifdef MOZ_WIDGET_ANDROID
#  include "AndroidBridge.h"
#  include "LayerMetricsWrapper.h"
#endif
#ifdef XP_WIN
#  include "mozilla/gfx/DeviceManagerDx.h"
#  include "gfxDWriteFonts.h"
#endif

namespace mozilla {
namespace layers {

using namespace mozilla::gfx;

ClientLayerManager::ClientLayerManager(nsIWidget* aWidget)
    : mPhase(PHASE_NONE),
      mWidget(aWidget),
      mPaintedLayerCallback(nullptr),
      mPaintedLayerCallbackData(nullptr),
      mLatestTransactionId{0},
      mLastPaintTime(TimeDuration::Forever()),
      mTargetRotation(ROTATION_0),
      mRepeatTransaction(false),
      mIsRepeatTransaction(false),
      mTransactionIncomplete(false),
      mCompositorMightResample(false),
      mNeedsComposite(false),
      mQueuedAsyncPaints(false),
      mNotifyingWidgetListener(false),
      mPaintSequenceNumber(0),
      mForwarder(new ShadowLayerForwarder(this)) {
  MOZ_COUNT_CTOR(ClientLayerManager);
  mMemoryPressureObserver = MemoryPressureObserver::Create(this);
}

ClientLayerManager::~ClientLayerManager() {
  mMemoryPressureObserver->Unregister();
  ClearCachedResources();
  // Stop receiveing AsyncParentMessage at Forwarder.
  // After the call, the message is directly handled by LayerTransactionChild.
  // Basically this function should be called in ShadowLayerForwarder's
  // destructor. But when the destructor is triggered by
  // CompositorBridgeChild::Destroy(), the destructor can not handle it
  // correctly. See Bug 1000525.
  mForwarder->StopReceiveAsyncParentMessge();
  mRoot = nullptr;

  MOZ_COUNT_DTOR(ClientLayerManager);
}

bool ClientLayerManager::Initialize(
    PCompositorBridgeChild* aCBChild, bool aShouldAccelerate,
    TextureFactoryIdentifier* aTextureFactoryIdentifier) {
  MOZ_ASSERT(mForwarder);
  MOZ_ASSERT(aTextureFactoryIdentifier);

  nsTArray<LayersBackend> backendHints;
  gfxPlatform::GetPlatform()->GetCompositorBackends(aShouldAccelerate,
                                                    backendHints);
  if (backendHints.IsEmpty()) {
    gfxCriticalNote << "Failed to get backend hints.";
    return false;
  }

  PLayerTransactionChild* shadowManager =
      aCBChild->SendPLayerTransactionConstructor(backendHints, LayersId{0});

  TextureFactoryIdentifier textureFactoryIdentifier;
  shadowManager->SendGetTextureFactoryIdentifier(&textureFactoryIdentifier);
  if (textureFactoryIdentifier.mParentBackend == LayersBackend::LAYERS_NONE) {
    gfxCriticalNote << "Failed to create an OMT compositor.";
    return false;
  }

  mForwarder->SetShadowManager(shadowManager);
  UpdateTextureFactoryIdentifier(textureFactoryIdentifier);
  *aTextureFactoryIdentifier = textureFactoryIdentifier;
  return true;
}

void ClientLayerManager::Destroy() {
  MOZ_DIAGNOSTIC_ASSERT(!mNotifyingWidgetListener,
                        "Try to avoid destroying widgets and layer managers "
                        "during DidCompositeWindow, if you can");

  // It's important to call ClearCachedResource before Destroy because the
  // former will early-return if the later has already run.
  ClearCachedResources();
  LayerManager::Destroy();

  if (mTransactionIdAllocator) {
    // Make sure to notify the refresh driver just in case it's waiting on a
    // pending transaction. Do this at the top of the event loop so we don't
    // cause a paint to occur during compositor shutdown.
    RefPtr<TransactionIdAllocator> allocator = mTransactionIdAllocator;
    TransactionId id = mLatestTransactionId;

    RefPtr<Runnable> task = NS_NewRunnableFunction(
        "TransactionIdAllocator::NotifyTransactionCompleted",
        [allocator, id]() -> void {
          allocator->NotifyTransactionCompleted(id);
        });
    NS_DispatchToMainThread(task.forget());
  }

  // Forget the widget pointer in case we outlive our owning widget.
  mWidget = nullptr;
}

int32_t ClientLayerManager::GetMaxTextureSize() const {
  return mForwarder->GetMaxTextureSize();
}

void ClientLayerManager::SetDefaultTargetConfiguration(
    BufferMode aDoubleBuffering, ScreenRotation aRotation) {
  mTargetRotation = aRotation;
}

void ClientLayerManager::SetRoot(Layer* aLayer) {
  if (mRoot != aLayer) {
    // Have to hold the old root and its children in order to
    // maintain the same view of the layer tree in this process as
    // the parent sees.  Otherwise layers can be destroyed
    // mid-transaction and bad things can happen (v. bug 612573)
    if (mRoot) {
      Hold(mRoot);
    }
    mForwarder->SetRoot(Hold(aLayer));
    NS_ASSERTION(aLayer, "Root can't be null");
    NS_ASSERTION(aLayer->Manager() == this, "Wrong manager");
    NS_ASSERTION(InConstruction(), "Only allowed in construction phase");
    mRoot = aLayer;
  }
}

void ClientLayerManager::Mutated(Layer* aLayer) {
  LayerManager::Mutated(aLayer);

  NS_ASSERTION(InConstruction() || InDrawing(), "wrong phase");
  mForwarder->Mutated(Hold(aLayer));
}

void ClientLayerManager::MutatedSimple(Layer* aLayer) {
  LayerManager::MutatedSimple(aLayer);

  NS_ASSERTION(InConstruction() || InDrawing(), "wrong phase");
  mForwarder->MutatedSimple(Hold(aLayer));
}

already_AddRefed<ReadbackLayer> ClientLayerManager::CreateReadbackLayer() {
  RefPtr<ReadbackLayer> layer = new ClientReadbackLayer(this);
  return layer.forget();
}

bool ClientLayerManager::BeginTransactionWithTarget(gfxContext* aTarget,
                                                    const nsCString& aURL) {
#ifdef MOZ_DUMP_PAINTING
  // When we are dump painting, we expect to be able to read the contents of
  // compositable clients from previous paints inside this layer transaction
  // before we flush async paints in EndTransactionInternal.
  // So to work around this flush async paints now.
  if (gfxEnv::DumpPaint()) {
    FlushAsyncPaints();
  }
#endif

  MOZ_ASSERT(mForwarder,
             "ClientLayerManager::BeginTransaction without forwarder");
  if (!mForwarder->IPCOpen()) {
    gfxCriticalNote << "ClientLayerManager::BeginTransaction with IPC channel "
                       "down. GPU process may have died.";
    return false;
  }

  mInTransaction = true;
  mTransactionStart = TimeStamp::Now();
  mURL = aURL;

#ifdef MOZ_LAYERS_HAVE_LOG
  MOZ_LAYERS_LOG(("[----- BeginTransaction"));
  Log();
#endif

  NS_ASSERTION(!InTransaction(), "Nested transactions not allowed");
  mPhase = PHASE_CONSTRUCTION;

  MOZ_ASSERT(mKeepAlive.IsEmpty(), "uncommitted txn?");

  // If the last transaction was incomplete (a failed DoEmptyTransaction),
  // don't signal a new transaction to ShadowLayerForwarder. Carry on adding
  // to the previous transaction.
  hal::ScreenOrientation orientation;
  if (dom::BrowserChild* window = mWidget->GetOwningBrowserChild()) {
    orientation = window->GetOrientation();
  } else {
    hal::ScreenConfiguration currentConfig;
    hal::GetCurrentScreenConfiguration(&currentConfig);
    orientation = currentConfig.orientation();
  }
  LayoutDeviceIntRect targetBounds = mWidget->GetNaturalBounds();
  targetBounds.MoveTo(0, 0);
  mForwarder->BeginTransaction(targetBounds.ToUnknownRect(), mTargetRotation,
                               orientation);

  // If we're drawing on behalf of a context with async pan/zoom
  // enabled, then the entire buffer of painted layers might be
  // composited (including resampling) asynchronously before we get
  // a chance to repaint, so we have to ensure that it's all valid
  // and not rotated.
  //
  // Desktop does not support async zoom yet, so we ignore this for those
  // platforms.
#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_UIKIT)
  if (mWidget && mWidget->GetOwningBrowserChild()) {
    mCompositorMightResample = AsyncPanZoomEnabled();
  }
#endif

  // If we have a non-default target, we need to let our shadow manager draw
  // to it. This will happen at the end of the transaction.
  if (aTarget && XRE_IsParentProcess()) {
    mShadowTarget = aTarget;
  } else {
    NS_ASSERTION(
        !aTarget,
        "Content-process ClientLayerManager::BeginTransactionWithTarget not "
        "supported");
  }

  // If this is a new paint, increment the paint sequence number.
  if (!mIsRepeatTransaction) {
    // Increment the paint sequence number even if test logging isn't
    // enabled in this process; it may be enabled in the parent process,
    // and the parent process expects unique sequence numbers.
    ++mPaintSequenceNumber;
    if (StaticPrefs::apz_test_logging_enabled()) {
      mApzTestData.StartNewPaint(mPaintSequenceNumber);
    }
  }
  return true;
}

bool ClientLayerManager::BeginTransaction(const nsCString& aURL) {
  return BeginTransactionWithTarget(nullptr, aURL);
}

bool ClientLayerManager::EndTransactionInternal(
    DrawPaintedLayerCallback aCallback, void* aCallbackData,
    EndTransactionFlags) {
  // This just causes the compositor to check whether the GPU is done with its
  // textures or not and unlock them if it is. This helps us avoid the case
  // where we take a long time painting asynchronously, turn IPC back on at
  // the end of that, and then have to wait for the compositor to to get into
  // TiledLayerBufferComposite::UseTiles before getting a response.
  if (mForwarder) {
    mForwarder->UpdateTextureLocks();
  }

  // Wait for any previous async paints to complete before starting to paint
  // again. Do this outside the profiler and telemetry block so this doesn't
  // count as time spent rasterizing.
  {
    PaintTelemetry::AutoRecord record(
        PaintTelemetry::Metric::FlushRasterization);
    FlushAsyncPaints();
  }

  PaintTelemetry::AutoRecord record(PaintTelemetry::Metric::Rasterization);
  AUTO_PROFILER_TRACING_MARKER("Paint", "Rasterize", GRAPHICS);
  PerfStats::AutoMetricRecording<PerfStats::Metric::Rasterizing> autoRecording;

  Maybe<TimeStamp> startTime;
  if (StaticPrefs::layers_acceleration_draw_fps()) {
    startTime = Some(TimeStamp::Now());
  }

  AUTO_PROFILER_LABEL("ClientLayerManager::EndTransactionInternal", GRAPHICS);

#ifdef MOZ_LAYERS_HAVE_LOG
  MOZ_LAYERS_LOG(("  ----- (beginning paint)"));
  Log();
#endif

  NS_ASSERTION(InConstruction(), "Should be in construction phase");
  mPhase = PHASE_DRAWING;

  ClientLayer* root = ClientLayer::ToClientLayer(GetRoot());

  mTransactionIncomplete = false;
  mQueuedAsyncPaints = false;

  // Apply pending tree updates before recomputing effective
  // properties.
  auto scrollIdsUpdated = GetRoot()->ApplyPendingUpdatesToSubtree();

  mPaintedLayerCallback = aCallback;
  mPaintedLayerCallbackData = aCallbackData;

  GetRoot()->ComputeEffectiveTransforms(Matrix4x4());

  // Skip the painting if the device is in device-reset status.
  if (!gfxPlatform::GetPlatform()->DidRenderingDeviceReset()) {
    if (StaticPrefs::gfx_content_always_paint() && XRE_IsContentProcess()) {
      TimeStamp start = TimeStamp::Now();
      root->RenderLayer();
      mLastPaintTime = TimeStamp::Now() - start;
    } else {
      root->RenderLayer();
    }
  } else {
    gfxCriticalNote << "LayerManager::EndTransaction skip RenderLayer().";
  }

  // Once we're sure we're not going to fall back to a full paint,
  // notify the scroll frames which had pending updates.
  if (!mTransactionIncomplete) {
    for (ScrollableLayerGuid::ViewID scrollId : scrollIdsUpdated) {
      nsLayoutUtils::NotifyPaintSkipTransaction(scrollId);
    }
  }

  if (!mRepeatTransaction && !GetRoot()->GetInvalidRegion().IsEmpty()) {
    GetRoot()->Mutated();
  }

  if (!mIsRepeatTransaction) {
    mAnimationReadyTime = TimeStamp::Now();
    GetRoot()->StartPendingAnimations(mAnimationReadyTime);
  }

  mPaintedLayerCallback = nullptr;
  mPaintedLayerCallbackData = nullptr;

  // Go back to the construction phase if the transaction isn't complete.
  // Layout will update the layer tree and call EndTransaction().
  mPhase = mTransactionIncomplete ? PHASE_CONSTRUCTION : PHASE_NONE;

  NS_ASSERTION(!aCallback || !mTransactionIncomplete,
               "If callback is not null, transaction must be complete");

  if (gfxPlatform::GetPlatform()->DidRenderingDeviceReset()) {
    FrameLayerBuilder::InvalidateAllLayers(this);
  }

  if (startTime) {
    PaintTiming& pt = mForwarder->GetPaintTiming();
    pt.rasterMs() = (TimeStamp::Now() - startTime.value()).ToMilliseconds();
  }

  return !mTransactionIncomplete;
}

void ClientLayerManager::StorePluginWidgetConfigurations(
    const nsTArray<nsIWidget::Configuration>& aConfigurations) {
  if (mForwarder) {
    mForwarder->StorePluginWidgetConfigurations(aConfigurations);
  }
}

void ClientLayerManager::EndTransaction(DrawPaintedLayerCallback aCallback,
                                        void* aCallbackData,
                                        EndTransactionFlags aFlags) {
  if (!mForwarder->IPCOpen()) {
    mInTransaction = false;
    return;
  }

  if (mWidget) {
    mWidget->PrepareWindowEffects();
  }
  EndTransactionInternal(aCallback, aCallbackData, aFlags);
  if (XRE_IsContentProcess()) {
    RegisterPayload({CompositionPayloadType::eContentPaint, TimeStamp::Now()});
  }
  ForwardTransaction(!(aFlags & END_NO_REMOTE_COMPOSITE));

  if (mRepeatTransaction) {
    mRepeatTransaction = false;
    mIsRepeatTransaction = true;

    // BeginTransaction will reset the transaction start time, but we
    // would like to keep the original time for telemetry purposes.
    TimeStamp transactionStart = mTransactionStart;
    if (BeginTransaction(mURL)) {
      mTransactionStart = transactionStart;
      ClientLayerManager::EndTransaction(aCallback, aCallbackData, aFlags);
    }

    mIsRepeatTransaction = false;
  } else {
    MakeSnapshotIfRequired();
  }

  mInTransaction = false;
  mTransactionStart = TimeStamp();
}

bool ClientLayerManager::EndEmptyTransaction(EndTransactionFlags aFlags) {
  mInTransaction = false;

  if (!mRoot || !mForwarder->IPCOpen()) {
    return false;
  }

  if (!EndTransactionInternal(nullptr, nullptr, aFlags)) {
    // Return without calling ForwardTransaction. This leaves the
    // ShadowLayerForwarder transaction open; the following
    // EndTransaction will complete it.
    if (PaintThread::Get() && mQueuedAsyncPaints) {
      PaintThread::Get()->QueueEndLayerTransaction(nullptr);
    }
    return false;
  }
  if (mWidget) {
    mWidget->PrepareWindowEffects();
  }
  ForwardTransaction(!(aFlags & END_NO_REMOTE_COMPOSITE));
  MakeSnapshotIfRequired();
  return true;
}

CompositorBridgeChild* ClientLayerManager::GetRemoteRenderer() {
  if (!mWidget) {
    return nullptr;
  }

  return mWidget->GetRemoteRenderer();
}

CompositorBridgeChild* ClientLayerManager::GetCompositorBridgeChild() {
  if (!XRE_IsParentProcess()) {
    return CompositorBridgeChild::Get();
  }
  return GetRemoteRenderer();
}

void ClientLayerManager::FlushAsyncPaints() {
  AUTO_PROFILER_LABEL_CATEGORY_PAIR(GRAPHICS_FlushingAsyncPaints);

  CompositorBridgeChild* cbc = GetCompositorBridgeChild();
  if (cbc) {
    cbc->FlushAsyncPaints();
  }
}

void ClientLayerManager::ScheduleComposite() {
  mForwarder->ScheduleComposite();
}

void ClientLayerManager::DidComposite(TransactionId aTransactionId,
                                      const TimeStamp& aCompositeStart,
                                      const TimeStamp& aCompositeEnd) {
  if (!mWidget) {
    return;
  }

  // Notifying the observers may tick the refresh driver which can cause
  // a lot of different things to happen that may affect the lifetime of
  // this layer manager. So let's make sure this object stays alive until
  // the end of the method invocation.
  RefPtr<ClientLayerManager> selfRef = this;

  // |aTransactionId| will be > 0 if the compositor is acknowledging a shadow
  // layers transaction.
  if (aTransactionId.IsValid()) {
    nsIWidgetListener* listener = mWidget->GetWidgetListener();
    if (listener) {
      mNotifyingWidgetListener = true;
      listener->DidCompositeWindow(aTransactionId, aCompositeStart,
                                   aCompositeEnd);
      mNotifyingWidgetListener = false;
    }
    // DidCompositeWindow might have called Destroy on us and nulled out
    // mWidget, see bug 1510058. Re-check it here.
    if (mWidget) {
      listener = mWidget->GetAttachedWidgetListener();
      if (listener) {
        listener->DidCompositeWindow(aTransactionId, aCompositeStart,
                                     aCompositeEnd);
      }
    }
    if (mTransactionIdAllocator) {
      mTransactionIdAllocator->NotifyTransactionCompleted(aTransactionId);
    }
  }

  // These observers fire whether or not we were in a transaction.
  for (size_t i = 0; i < mDidCompositeObservers.Length(); i++) {
    mDidCompositeObservers[i]->DidComposite();
  }
}

void ClientLayerManager::GetCompositorSideAPZTestData(
    APZTestData* aData) const {
  if (mForwarder->HasShadowManager()) {
    if (!mForwarder->GetShadowManager()->SendGetAPZTestData(aData)) {
      NS_WARNING("Call to PLayerTransactionChild::SendGetAPZTestData() failed");
    }
  }
}

void ClientLayerManager::SetTransactionIdAllocator(
    TransactionIdAllocator* aAllocator) {
  // When changing the refresh driver, the previous refresh driver may never
  // receive updates of pending transactions it's waiting for. So clear the
  // waiting state before assigning another refresh driver.
  if (mTransactionIdAllocator && (aAllocator != mTransactionIdAllocator)) {
    mTransactionIdAllocator->ClearPendingTransactions();

    // We should also reset the transaction id of the new allocator to previous
    // allocator's last transaction id, so that completed transactions for
    // previous allocator will be ignored and won't confuse the new allocator.
    if (aAllocator) {
      aAllocator->ResetInitialTransactionId(
          mTransactionIdAllocator->LastTransactionId());
    }
  }

  mTransactionIdAllocator = aAllocator;
}

float ClientLayerManager::RequestProperty(const nsAString& aProperty) {
  if (mForwarder->HasShadowManager()) {
    float value;
    if (!mForwarder->GetShadowManager()->SendRequestProperty(
            nsString(aProperty), &value)) {
      NS_WARNING("Call to PLayerTransactionChild::SendGetAPZTestData() failed");
    }
    return value;
  }
  return -1;
}

void ClientLayerManager::StartNewRepaintRequest(
    SequenceNumber aSequenceNumber) {
  if (StaticPrefs::apz_test_logging_enabled()) {
    mApzTestData.StartNewRepaintRequest(aSequenceNumber);
  }
}

void ClientLayerManager::GetFrameUniformity(FrameUniformityData* aOutData) {
  MOZ_ASSERT(XRE_IsParentProcess(),
             "Frame Uniformity only supported in parent process");

  if (HasShadowManager()) {
    CompositorBridgeChild* child = GetRemoteRenderer();
    child->SendGetFrameUniformity(aOutData);
    return;
  }

  return LayerManager::GetFrameUniformity(aOutData);
}

void ClientLayerManager::MakeSnapshotIfRequired() {
  if (!mShadowTarget) {
    return;
  }
  if (mWidget) {
    if (CompositorBridgeChild* remoteRenderer = GetRemoteRenderer()) {
      // The compositor doesn't draw to a different sized surface
      // when there's a rotation. Instead we rotate the result
      // when drawing into dt
      LayoutDeviceIntRect outerBounds = mWidget->GetBounds();

      IntRect bounds = ToOutsideIntRect(mShadowTarget->GetClipExtents());
      if (mTargetRotation) {
        bounds =
            RotateRect(bounds, outerBounds.ToUnknownRect(), mTargetRotation);
      }

      SurfaceDescriptor inSnapshot;
      if (!bounds.IsEmpty() &&
          mForwarder->AllocSurfaceDescriptor(
              bounds.Size(), gfxContentType::COLOR_ALPHA, &inSnapshot)) {
        // Make a copy of |inSnapshot| because the call to send it over IPC
        // will call forget() on the Shmem inside, and zero it out.
        SurfaceDescriptor outSnapshot = inSnapshot;

        if (remoteRenderer->SendMakeSnapshot(inSnapshot, bounds)) {
          RefPtr<DataSourceSurface> surf = GetSurfaceForDescriptor(outSnapshot);
          DrawTarget* dt = mShadowTarget->GetDrawTarget();

          Rect dstRect(bounds.X(), bounds.Y(), bounds.Width(), bounds.Height());
          Rect srcRect(0, 0, bounds.Width(), bounds.Height());

          gfx::Matrix rotate = ComputeTransformForUnRotation(
              outerBounds.ToUnknownRect(), mTargetRotation);

          gfx::Matrix oldMatrix = dt->GetTransform();
          dt->SetTransform(rotate * oldMatrix);
          dt->DrawSurface(surf, dstRect, srcRect, DrawSurfaceOptions(),
                          DrawOptions(1.0f, CompositionOp::OP_OVER));
          dt->SetTransform(oldMatrix);
        }
        mForwarder->DestroySurfaceDescriptor(&outSnapshot);
      }
    }
  }
  mShadowTarget = nullptr;
}

void ClientLayerManager::FlushRendering() {
  if (mWidget) {
    if (CompositorBridgeChild* remoteRenderer = mWidget->GetRemoteRenderer()) {
      if (mWidget->SynchronouslyRepaintOnResize() ||
          StaticPrefs::layers_force_synchronous_resize()) {
        remoteRenderer->SendFlushRendering();
      } else {
        remoteRenderer->SendFlushRenderingAsync();
      }
    }
  }
}

void ClientLayerManager::WaitOnTransactionProcessed() {
  CompositorBridgeChild* remoteRenderer = GetCompositorBridgeChild();
  if (remoteRenderer) {
    remoteRenderer->SendWaitOnTransactionProcessed();
  }
}
void ClientLayerManager::UpdateTextureFactoryIdentifier(
    const TextureFactoryIdentifier& aNewIdentifier) {
  mForwarder->IdentifyTextureHost(aNewIdentifier);
}

void ClientLayerManager::SendInvalidRegion(const nsIntRegion& aRegion) {
  if (mWidget) {
    if (CompositorBridgeChild* remoteRenderer = mWidget->GetRemoteRenderer()) {
      remoteRenderer->SendNotifyRegionInvalidated(aRegion);
    }
  }
}

uint32_t ClientLayerManager::StartFrameTimeRecording(int32_t aBufferSize) {
  CompositorBridgeChild* renderer = GetRemoteRenderer();
  if (renderer) {
    uint32_t startIndex;
    renderer->SendStartFrameTimeRecording(aBufferSize, &startIndex);
    return startIndex;
  }
  return -1;
}

void ClientLayerManager::StopFrameTimeRecording(
    uint32_t aStartIndex, nsTArray<float>& aFrameIntervals) {
  CompositorBridgeChild* renderer = GetRemoteRenderer();
  if (renderer) {
    renderer->SendStopFrameTimeRecording(aStartIndex, &aFrameIntervals);
  }
}

void ClientLayerManager::ForwardTransaction(bool aScheduleComposite) {
  AUTO_PROFILER_TRACING_MARKER("Paint", "ForwardTransaction", GRAPHICS);
  TimeStamp start = TimeStamp::Now();

  GetCompositorBridgeChild()->EndCanvasTransaction();

  // Skip the synchronization for buffer since we also skip the painting during
  // device-reset status. With OMTP, we have to wait for async paints
  // before we synchronize and it's done on the paint thread.
  RefPtr<SyncObjectClient> syncObject = nullptr;
  if (!gfxPlatform::GetPlatform()->DidRenderingDeviceReset()) {
    if (mForwarder->GetSyncObject() &&
        mForwarder->GetSyncObject()->IsSyncObjectValid()) {
      syncObject = mForwarder->GetSyncObject();
    }
  }

  // If there were async paints queued, then we need to notify the paint thread
  // that we finished queuing async paints so it can schedule a runnable after
  // all async painting is finished to do a texture sync and unblock the main
  // thread if it is waiting before doing a new layer transaction.
  if (mQueuedAsyncPaints) {
    MOZ_ASSERT(PaintThread::Get());
    PaintThread::Get()->QueueEndLayerTransaction(syncObject);
  } else if (syncObject) {
    syncObject->Synchronize();
  }

  mPhase = PHASE_FORWARD;

  mLatestTransactionId =
      mTransactionIdAllocator->GetTransactionId(!mIsRepeatTransaction);
  TimeStamp refreshStart = mTransactionIdAllocator->GetTransactionStart();
  if (!refreshStart) {
    refreshStart = mTransactionStart;
  }

  if (StaticPrefs::gfx_content_always_paint() && XRE_IsContentProcess()) {
    mForwarder->SendPaintTime(mLatestTransactionId, mLastPaintTime);
  }

  // forward this transaction's changeset to our LayerManagerComposite
  bool sent = false;
  bool ok = mForwarder->EndTransaction(
      mRegionToClear, mLatestTransactionId, aScheduleComposite,
      mPaintSequenceNumber, mIsRepeatTransaction,
      mTransactionIdAllocator->GetVsyncId(),
      mTransactionIdAllocator->GetVsyncStart(), refreshStart, mTransactionStart,
      mContainsSVG, mURL, &sent, mPayload);

  if (ok) {
    if (sent) {
      // Our payload has now been dispatched.
      mPayload.Clear();
      mNeedsComposite = false;
    }
  } else if (HasShadowManager()) {
    NS_WARNING("failed to forward Layers transaction");
  }

  if (!sent) {
    // Clear the transaction id so that it doesn't get returned
    // unless we forwarded to somewhere that doesn't actually
    // have a compositor.
    mTransactionIdAllocator->RevokeTransactionId(mLatestTransactionId);
    mLatestTransactionId = mLatestTransactionId.Prev();
  }

  mPhase = PHASE_NONE;

  // this may result in Layers being deleted, which results in
  // PLayer::Send__delete__() and DeallocShmem()
  mKeepAlive.Clear();

  BrowserChild* window = mWidget ? mWidget->GetOwningBrowserChild() : nullptr;
  if (window) {
    TimeStamp end = TimeStamp::Now();
    window->DidRequestComposite(start, end);
  }
}

ShadowableLayer* ClientLayerManager::Hold(Layer* aLayer) {
  MOZ_ASSERT(HasShadowManager(), "top-level tree, no shadow tree to remote to");

  ShadowableLayer* shadowable = ClientLayer::ToClientLayer(aLayer);
  MOZ_ASSERT(shadowable, "trying to remote an unshadowable layer");

  mKeepAlive.AppendElement(aLayer);
  return shadowable;
}

bool ClientLayerManager::IsCompositingCheap() {
  // Whether compositing is cheap depends on the parent backend.
  return mForwarder->mShadowManager &&
         LayerManager::IsCompositingCheap(
             mForwarder->GetCompositorBackendType());
}

bool ClientLayerManager::AreComponentAlphaLayersEnabled() {
  return GetCompositorBackendType() != LayersBackend::LAYERS_BASIC &&
         AsShadowForwarder()->SupportsComponentAlpha() &&
         LayerManager::AreComponentAlphaLayersEnabled();
}

void ClientLayerManager::SetIsFirstPaint() { mForwarder->SetIsFirstPaint(); }

void ClientLayerManager::SetFocusTarget(const FocusTarget& aFocusTarget) {
  mForwarder->SetFocusTarget(aFocusTarget);
}

void ClientLayerManager::ClearCachedResources(Layer* aSubtree) {
  if (mDestroyed) {
    // ClearCachedResource was already called by ClientLayerManager::Destroy
    return;
  }
  MOZ_ASSERT(!HasShadowManager() || !aSubtree);
  mForwarder->ClearCachedResources();
  if (aSubtree) {
    ClearLayer(aSubtree);
  } else if (mRoot) {
    ClearLayer(mRoot);
  }
}

void ClientLayerManager::OnMemoryPressure(MemoryPressureReason aWhy) {
  if (mRoot) {
    HandleMemoryPressureLayer(mRoot);
  }

  if (GetCompositorBridgeChild()) {
    GetCompositorBridgeChild()->HandleMemoryPressure();
  }
}

void ClientLayerManager::ClearLayer(Layer* aLayer) {
  aLayer->ClearCachedResources();
  for (Layer* child = aLayer->GetFirstChild(); child;
       child = child->GetNextSibling()) {
    ClearLayer(child);
  }
}

void ClientLayerManager::HandleMemoryPressureLayer(Layer* aLayer) {
  ClientLayer::ToClientLayer(aLayer)->HandleMemoryPressure();
  for (Layer* child = aLayer->GetFirstChild(); child;
       child = child->GetNextSibling()) {
    HandleMemoryPressureLayer(child);
  }
}

void ClientLayerManager::GetBackendName(nsAString& aName) {
  switch (mForwarder->GetCompositorBackendType()) {
    case LayersBackend::LAYERS_NONE:
      aName.AssignLiteral("None");
      return;
    case LayersBackend::LAYERS_BASIC:
      aName.AssignLiteral("Basic");
      return;
    case LayersBackend::LAYERS_OPENGL:
      aName.AssignLiteral("OpenGL");
      return;
    case LayersBackend::LAYERS_D3D11: {
#ifdef XP_WIN
      if (DeviceManagerDx::Get()->IsWARP()) {
        aName.AssignLiteral("Direct3D 11 WARP");
      } else {
        aName.AssignLiteral("Direct3D 11");
      }
#endif
      return;
    }
    default:
      MOZ_CRASH("Invalid backend");
  }
}

bool ClientLayerManager::AsyncPanZoomEnabled() const {
  return mWidget && mWidget->AsyncPanZoomEnabled();
}

void ClientLayerManager::SetLayersObserverEpoch(LayersObserverEpoch aEpoch) {
  mForwarder->SetLayersObserverEpoch(aEpoch);
}

void ClientLayerManager::AddDidCompositeObserver(
    DidCompositeObserver* aObserver) {
  if (!mDidCompositeObservers.Contains(aObserver)) {
    mDidCompositeObservers.AppendElement(aObserver);
  }
}

void ClientLayerManager::RemoveDidCompositeObserver(
    DidCompositeObserver* aObserver) {
  mDidCompositeObservers.RemoveElement(aObserver);
}

already_AddRefed<PersistentBufferProvider>
ClientLayerManager::CreatePersistentBufferProvider(const gfx::IntSize& aSize,
                                                   gfx::SurfaceFormat aFormat) {
  // Don't use a shared buffer provider if compositing is considered "not cheap"
  // because the canvas will most likely be flattened into a thebes layer
  // instead of being sent to the compositor, in which case rendering into
  // shared memory is wasteful.
  if (IsCompositingCheap()) {
    RefPtr<PersistentBufferProvider> provider =
        PersistentBufferProviderShared::Create(aSize, aFormat,
                                               AsShadowForwarder());
    if (provider) {
      return provider.forget();
    }
  }

  return LayerManager::CreatePersistentBufferProvider(aSize, aFormat);
}

ClientLayer::~ClientLayer() { MOZ_COUNT_DTOR(ClientLayer); }

}  // namespace layers
}  // namespace mozilla