Quelle  nsWindowGfx.cpp   Sprache: unbekannt

/* -*- Mode: C++; tab-width: 2; 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/. */

/*
 * nsWindowGfx - Painting and aceleration.
 */

/**************************************************************
 **************************************************************
 **
 ** BLOCK: Includes
 **
 ** Include headers.
 **
 **************************************************************
 **************************************************************/

#include "mozilla/dom/ContentParent.h"

#include "nsWindowGfx.h"
#include "nsAppRunner.h"
#include <windows.h>
#include <shellapi.h>
#include "gfxEnv.h"
#include "gfxImageSurface.h"
#include "gfxUtils.h"
#include "gfxConfig.h"
#include "gfxWindowsSurface.h"
#include "gfxWindowsPlatform.h"
#include "gfxDWriteFonts.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/DataSurfaceHelpers.h"
#include "mozilla/gfx/Tools.h"
#include "mozilla/RefPtr.h"
#include "mozilla/SVGImageContext.h"
#include "mozilla/UniquePtrExtensions.h"
#include "nsGfxCIID.h"
#include "gfxContext.h"
#include "WinUtils.h"
#include "WinWindowOcclusionTracker.h"
#include "nsIWidgetListener.h"
#include "mozilla/Unused.h"
#include "nsDebug.h"
#include "WindowRenderer.h"
#include "mozilla/layers/WebRenderLayerManager.h"
#include "ImageRegion.h"

#include "mozilla/gfx/GPUProcessManager.h"
#include "mozilla/layers/CompositorBridgeParent.h"
#include "mozilla/layers/CompositorBridgeChild.h"
#include "InProcessWinCompositorWidget.h"

#include "nsUXThemeData.h"
#include "nsUXThemeConstants.h"

using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::layers;
using namespace mozilla::widget;
using namespace mozilla::plugins;
extern mozilla::LazyLogModule gWindowsLog;

/**************************************************************
 **************************************************************
 **
 ** BLOCK: Variables
 **
 ** nsWindow Class static initializations and global variables.
 **
 **************************************************************
 **************************************************************/

/**************************************************************
 *
 * SECTION: nsWindow statics
 *
 **************************************************************/

struct IconMetrics {
  int32_t xMetric;
  int32_t yMetric;
  int32_t defaultSize;
};

// Corresponds 1:1 to the IconSizeType enum
static IconMetrics sIconMetrics[] = {
    {SM_CXSMICON, SM_CYSMICON, 16},  // small icon
    {SM_CXICON, SM_CYICON, 32}       // regular icon
};

/**************************************************************
 **************************************************************
 **
 ** BLOCK: nsWindow impl.
 **
 ** Paint related nsWindow methods.
 **
 **************************************************************
 **************************************************************/

// GetRegionToPaint returns the invalidated region that needs to be painted
LayoutDeviceIntRegion nsWindow::GetRegionToPaint(const PAINTSTRUCT& ps,
                                                 HDC aDC) const {
  LayoutDeviceIntRegion fullRegion(WinUtils::ToIntRect(ps.rcPaint));
  HRGN paintRgn = ::CreateRectRgn(0, 0, 0, 0);
  if (paintRgn) {
    if (GetRandomRgn(aDC, paintRgn, SYSRGN) == 1) {
      POINT pt = {0, 0};
      ::MapWindowPoints(nullptr, mWnd, &pt, 1);
      ::OffsetRgn(paintRgn, pt.x, pt.y);
      fullRegion.AndWith(WinUtils::ConvertHRGNToRegion(paintRgn));
    }
    ::DeleteObject(paintRgn);
  }
  return fullRegion;
}

nsIWidgetListener* nsWindow::GetPaintListener() {
  if (mDestroyCalled) return nullptr;
  return mAttachedWidgetListener ? mAttachedWidgetListener : mWidgetListener;
}

void nsWindow::ForcePresent() {
  if (mResizeState != RESIZING) {
    if (CompositorBridgeChild* remoteRenderer = GetRemoteRenderer()) {
      remoteRenderer->SendForcePresent(wr::RenderReasons::WIDGET);
    }
  }
}

bool nsWindow::OnPaint(uint32_t aNestingLevel) {
  gfx::DeviceResetReason resetReason = gfx::DeviceResetReason::OK;
  if (gfxWindowsPlatform::GetPlatform()->DidRenderingDeviceReset(
          &resetReason)) {
    gfxCriticalNote << "(nsWindow) Detected device reset: " << (int)resetReason;

    gfxWindowsPlatform::GetPlatform()->UpdateRenderMode();

    GPUProcessManager::GPUProcessManager::NotifyDeviceReset(
        resetReason, gfx::DeviceResetDetectPlace::WIDGET);

    gfxCriticalNote << "(nsWindow) Finished device reset.";
    return false;
  }

  PAINTSTRUCT ps;

  // Avoid starting the GPU process for the initial navigator:blank window.
  if (mIsEarlyBlankWindow) {
    // Call BeginPaint/EndPaint or Windows will keep sending us messages.
    ::BeginPaint(mWnd, &ps);
    ::EndPaint(mWnd, &ps);
    return true;
  }

  WindowRenderer* renderer = GetWindowRenderer();
  KnowsCompositor* knowsCompositor = renderer->AsKnowsCompositor();
  WebRenderLayerManager* layerManager = renderer->AsWebRender();

  const bool didResize = mBounds.Size() != mLastPaintBounds.Size();

  if (didResize && knowsCompositor && layerManager) {
    // Do an early async composite so that we at least have something on the
    // screen in the right place, even if the content is out of date.
    layerManager->ScheduleComposite(wr::RenderReasons::WIDGET);
  }
  mLastPaintBounds = mBounds;

  RefPtr<nsWindow> strongThis(this);
  if (nsIWidgetListener* listener = GetPaintListener()) {
    // WillPaintWindow will update our transparent area if needed, which we use
    // below. Note that this might kill the listener.
    listener->WillPaintWindow(this);
  }

  // For layered translucent popups all drawing should go to memory DC and no
  // WM_PAINT messages are normally generated. To support asynchronous painting
  // we force generation of WM_PAINT messages by invalidating window areas with
  // RedrawWindow, InvalidateRect or InvalidateRgn function calls.
  const bool usingMemoryDC =
      IsPopup() && renderer->GetBackendType() == LayersBackend::LAYERS_NONE &&
      mTransparencyMode == TransparencyMode::Transparent;
  const LayoutDeviceIntRect winRect = [&] {
    RECT r;
    ::GetWindowRect(mWnd, &r);
    ::MapWindowPoints(nullptr, mWnd, (LPPOINT)&r, 2);
    return WinUtils::ToIntRect(r);
  }();
  LayoutDeviceIntRegion region;
  LayoutDeviceIntRegion translucentRegion;
  // BeginPaint/EndPaint must be called to make Windows think that invalid
  // area is painted. Otherwise it will continue sending the same message
  // endlessly. Note that we need to call it after WillPaintWindow, which
  // informs us of our transparent region, but also before clearing the
  // nc-area, since ::BeginPaint might send WM_NCPAINT messages[1].
  // [1]:
  // https://learn.microsoft.com/en-us/windows/win32/gdi/the-wm-paint-message
  HDC hDC = ::BeginPaint(mWnd, &ps);
  if (usingMemoryDC) {
    ::EndPaint(mWnd, &ps);
    // We're guaranteed to have a widget proxy since we called
    // GetLayerManager().
    hDC = mBasicLayersSurface->GetTransparentDC();
    region = translucentRegion = LayoutDeviceIntRegion{winRect};
  } else {
    region = GetRegionToPaint(ps, hDC);
    if (mTransparencyMode == TransparencyMode::Transparent) {
      translucentRegion = LayoutDeviceIntRegion{winRect};
      translucentRegion.SubOut(mOpaqueRegion);
      region.OrWith(translucentRegion);
    }

    if (mNeedsNCAreaClear ||
        (didResize && mTransparencyMode == TransparencyMode::Transparent)) {
      // We need to clear the non-client-area region, and the transparent parts
      // of the window to black (once).
      auto black = reinterpret_cast<HBRUSH>(::GetStockObject(BLACK_BRUSH));
      nsAutoRegion regionToClear(ComputeNonClientHRGN());
      if (!translucentRegion.IsEmpty()) {
        nsAutoRegion translucent(WinUtils::RegionToHRGN(translucentRegion));
        ::CombineRgn(regionToClear, regionToClear, translucent, RGN_OR);
      }
      ::FillRgn(hDC, regionToClear, black);
    }
  }
  mNeedsNCAreaClear = false;

  bool didPaint = false;
  auto endPaint = MakeScopeExit([&] {
    if (!usingMemoryDC) {
      ::EndPaint(mWnd, &ps);
    }
    if (didPaint) {
      mLastPaintEndTime = TimeStamp::Now();
      if (nsIWidgetListener* listener = GetPaintListener()) {
        listener->DidPaintWindow();
      }
      if (aNestingLevel == 0 && ::GetUpdateRect(mWnd, nullptr, false)) {
        OnPaint(1);
      }
    }
  });

  if (region.IsEmpty() || !GetPaintListener()) {
    return false;
  }

  if (knowsCompositor && layerManager) {
    layerManager->SendInvalidRegion(region.ToUnknownRegion());
    layerManager->ScheduleComposite(wr::RenderReasons::WIDGET);
  }

  // Should probably pass in a real region here, using GetRandomRgn
  // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/clipping_4q0e.asp
#ifdef WIDGET_DEBUG_OUTPUT
  debug_DumpPaintEvent(stdout, this, region.ToUnknownRegion(), "noname",
                       (int32_t)mWnd);
#endif  // WIDGET_DEBUG_OUTPUT

  bool result = true;
  switch (renderer->GetBackendType()) {
    case LayersBackend::LAYERS_NONE: {
      RefPtr<gfxASurface> targetSurface;

      // don't support transparency for non-GDI rendering, for now
      if (usingMemoryDC) {
        // This mutex needs to be held when EnsureTransparentSurface is
        // called.
        MutexAutoLock lock(mBasicLayersSurface->GetTransparentSurfaceLock());
        targetSurface = mBasicLayersSurface->EnsureTransparentSurface();
      }

      RefPtr<gfxWindowsSurface> targetSurfaceWin;
      if (!targetSurface) {
        uint32_t flags = (mTransparencyMode == TransparencyMode::Opaque)
                             ? 0
                             : gfxWindowsSurface::FLAG_IS_TRANSPARENT;
        targetSurfaceWin = new gfxWindowsSurface(hDC, flags);
        targetSurface = targetSurfaceWin;
      }

      RECT paintRect;
      ::GetClientRect(mWnd, &paintRect);
      RefPtr<DrawTarget> dt = gfxPlatform::CreateDrawTargetForSurface(
          targetSurface, IntSize(paintRect.right - paintRect.left,
                                 paintRect.bottom - paintRect.top));
      if (!dt || !dt->IsValid()) {
        gfxWarning()
            << "nsWindow::OnPaint failed in CreateDrawTargetForSurface";
        return false;
      }

      // don't need to double buffer with anything but GDI
      BufferMode doubleBuffering = mozilla::layers::BufferMode::BUFFER_NONE;
      switch (mTransparencyMode) {
        case TransparencyMode::Transparent:
          // If we're rendering with translucency, we're going to be
          // rendering the whole window; make sure we clear it first
          dt->ClearRect(Rect(dt->GetRect()));
          break;
        default:
          // If we're not doing translucency, then double buffer
          doubleBuffering = mozilla::layers::BufferMode::BUFFERED;
          break;
      }

      gfxContext thebesContext(dt);

      {
        AutoLayerManagerSetup setupLayerManager(this, &thebesContext,
                                                doubleBuffering);
        if (nsIWidgetListener* listener = GetPaintListener()) {
          result = listener->PaintWindow(this, region);
        }
      }

      if (usingMemoryDC) {
        // Data from offscreen drawing surface was copied to memory bitmap of
        // transparent bitmap. Now it can be read from memory bitmap to apply
        // alpha channel and after that displayed on the screen.
        mBasicLayersSurface->RedrawTransparentWindow();
      }
    } break;
    case LayersBackend::LAYERS_WR: {
      if (nsIWidgetListener* listener = GetPaintListener()) {
        result = listener->PaintWindow(this, region);
      }
      if (!gfxEnv::MOZ_DISABLE_FORCE_PRESENT()) {
        nsCOMPtr<nsIRunnable> event = NewRunnableMethod(
            "nsWindow::ForcePresent", this, &nsWindow::ForcePresent);
        NS_DispatchToMainThread(event);
      }
    } break;
    default:
      NS_ERROR("Unknown layers backend used!");
      break;
  }

  didPaint = true;
  return result;
}

bool nsWindow::NeedsToTrackWindowOcclusionState() {
  if (!WinWindowOcclusionTracker::Get()) {
    return false;
  }

  if (mCompositorSession && mWindowType == WindowType::TopLevel) {
    return true;
  }

  return false;
}

void nsWindow::NotifyOcclusionState(mozilla::widget::OcclusionState aState) {
  MOZ_ASSERT(NeedsToTrackWindowOcclusionState());

  bool isFullyOccluded = aState == mozilla::widget::OcclusionState::OCCLUDED;
  // When window is minimized, it is not set as fully occluded.
  if (mFrameState->GetSizeMode() == nsSizeMode_Minimized) {
    isFullyOccluded = false;
  }

  // Don't dispatch if the new occlustion state is the same as the current
  // state.
  if (mIsFullyOccluded == isFullyOccluded) {
    return;
  }

  mIsFullyOccluded = isFullyOccluded;

  MOZ_LOG(gWindowsLog, LogLevel::Info,
          ("nsWindow::NotifyOcclusionState() mIsFullyOccluded %d "
           "mFrameState->GetSizeMode() %d",
           mIsFullyOccluded, mFrameState->GetSizeMode()));

  wr::DebugFlags flags{0};
  flags._0 = gfx::gfxVars::WebRenderDebugFlags();
  bool debugEnabled = bool(flags & wr::DebugFlags::WINDOW_VISIBILITY_DBG);
  if (debugEnabled && mCompositorWidgetDelegate) {
    mCompositorWidgetDelegate->NotifyVisibilityUpdated(mIsFullyOccluded);
  }

  if (mWidgetListener) {
    mWidgetListener->OcclusionStateChanged(mIsFullyOccluded);
  }
}

void nsWindow::MaybeEnableWindowOcclusion(bool aEnable) {
  // WindowOcclusion is enabled/disabled only when compositor session exists.
  // See nsWindow::NeedsToTrackWindowOcclusionState().
  if (!mCompositorSession) {
    return;
  }

  bool enabled = gfxConfig::IsEnabled(gfx::Feature::WINDOW_OCCLUSION);

  if (aEnable) {
    // Enable window occlusion.
    if (enabled && NeedsToTrackWindowOcclusionState()) {
      WinWindowOcclusionTracker::Get()->Enable(this, mWnd);

      wr::DebugFlags flags{0};
      flags._0 = gfx::gfxVars::WebRenderDebugFlags();
      bool debugEnabled = bool(flags & wr::DebugFlags::WINDOW_VISIBILITY_DBG);
      if (debugEnabled && mCompositorWidgetDelegate) {
        mCompositorWidgetDelegate->NotifyVisibilityUpdated(mIsFullyOccluded);
      }
    }
    return;
  }

  // Disable window occlusion.
  MOZ_ASSERT(!aEnable);

  if (!NeedsToTrackWindowOcclusionState()) {
    return;
  }

  WinWindowOcclusionTracker::Get()->Disable(this, mWnd);
  NotifyOcclusionState(OcclusionState::VISIBLE);

  wr::DebugFlags flags{0};
  flags._0 = gfx::gfxVars::WebRenderDebugFlags();
  bool debugEnabled = bool(flags & wr::DebugFlags::WINDOW_VISIBILITY_DBG);
  if (debugEnabled && mCompositorWidgetDelegate) {
    mCompositorWidgetDelegate->NotifyVisibilityUpdated(mIsFullyOccluded);
  }
}

// This override of CreateCompositor is to add support for sending the IPC
// call for RequesetFxrOutput as soon as the compositor for this widget is
// available.
void nsWindow::CreateCompositor() {
  nsBaseWidget::CreateCompositor();

  MaybeEnableWindowOcclusion(/* aEnable */ true);

  if (mRequestFxrOutputPending) {
    GetRemoteRenderer()->SendRequestFxrOutput();
  }
}

void nsWindow::DestroyCompositor() {
  MaybeEnableWindowOcclusion(/* aEnable */ false);

  nsBaseWidget::DestroyCompositor();
}

void nsWindow::RequestFxrOutput() {
  if (GetRemoteRenderer() != nullptr) {
    MOZ_CRASH("RequestFxrOutput should happen before Compositor is created.");
  } else {
    // The compositor isn't ready, so indicate to make the IPC call when
    // it is available.
    mRequestFxrOutputPending = true;
  }
}

LayoutDeviceIntSize nsWindowGfx::GetIconMetrics(IconSizeType aSizeType) {
  int32_t width = ::GetSystemMetrics(sIconMetrics[aSizeType].xMetric);
  int32_t height = ::GetSystemMetrics(sIconMetrics[aSizeType].yMetric);

  if (width == 0 || height == 0) {
    width = height = sIconMetrics[aSizeType].defaultSize;
  }

  return LayoutDeviceIntSize(width, height);
}

nsresult nsWindowGfx::CreateIcon(imgIContainer* aContainer,
                                 nsISVGPaintContext* aSVGPaintContext,
                                 bool aIsCursor, LayoutDeviceIntPoint aHotspot,
                                 LayoutDeviceIntSize aScaledSize,
                                 HICON* aIcon) {
  MOZ_ASSERT(aHotspot.x >= 0 && aHotspot.y >= 0);
  MOZ_ASSERT((aScaledSize.width > 0 && aScaledSize.height > 0) ||
             (aScaledSize.width == 0 && aScaledSize.height == 0));

  // Get the image data
  IntSize iconSize(aScaledSize.width, aScaledSize.height);

  RefPtr<DataSourceSurface> dataSurface;
  bool mappedOK;
  DataSourceSurface::MappedSurface map;

  if (aContainer->GetType() == imgIContainer::TYPE_VECTOR) {
    if (iconSize == IntSize(0, 0)) {  // use frame's intrinsic size
      int32_t width, height;
      nsresult rv = aContainer->GetWidth(&width);
      NS_ENSURE_SUCCESS(rv, rv);

      rv = aContainer->GetHeight(&height);
      NS_ENSURE_SUCCESS(rv, rv);

      NS_ENSURE_TRUE(width > 0 && height > 0, NS_ERROR_FAILURE);

      iconSize = IntSize(width, height);
    }

    RefPtr<DrawTarget> drawTarget =
        gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
            iconSize, SurfaceFormat::B8G8R8A8);
    if (!drawTarget || !drawTarget->IsValid()) {
      NS_ERROR("Failed to create valid DrawTarget");
      return NS_ERROR_FAILURE;
    }

    gfxContext context(drawTarget);

    SVGImageContext svgContext;
    svgContext.SetViewportSize(
        Some(CSSIntSize(iconSize.width, iconSize.height)));
    svgContext.SetColorScheme(Some(LookAndFeel::SystemColorScheme()));
    SVGImageContext::MaybeStoreContextPaint(svgContext, aSVGPaintContext,
                                            aContainer);

    mozilla::image::ImgDrawResult res = aContainer->Draw(
        &context, iconSize, image::ImageRegion::Create(iconSize),
        imgIContainer::FRAME_CURRENT, SamplingFilter::POINT, svgContext,
        imgIContainer::FLAG_SYNC_DECODE, 1.0);

    if (res != mozilla::image::ImgDrawResult::SUCCESS) {
      return NS_ERROR_FAILURE;
    }

    RefPtr<SourceSurface> surface = drawTarget->Snapshot();
    NS_ENSURE_TRUE(surface, NS_ERROR_NOT_AVAILABLE);

    dataSurface = surface->GetDataSurface();
    NS_ENSURE_TRUE(dataSurface, NS_ERROR_FAILURE);
    mappedOK = dataSurface->Map(DataSourceSurface::MapType::READ, &map);
  } else {
    RefPtr<SourceSurface> surface = aContainer->GetFrame(
        imgIContainer::FRAME_CURRENT,
        imgIContainer::FLAG_SYNC_DECODE | imgIContainer::FLAG_ASYNC_NOTIFY);
    NS_ENSURE_TRUE(surface, NS_ERROR_NOT_AVAILABLE);

    IntSize frameSize = surface->GetSize();
    if (frameSize.IsEmpty()) {
      return NS_ERROR_FAILURE;
    }

    if (iconSize == IntSize(0, 0)) {  // use frame's intrinsic size
      iconSize = frameSize;
    }

    if (iconSize != frameSize) {
      // Scale the surface
      dataSurface =
          Factory::CreateDataSourceSurface(iconSize, SurfaceFormat::B8G8R8A8);
      NS_ENSURE_TRUE(dataSurface, NS_ERROR_FAILURE);
      mappedOK = dataSurface->Map(DataSourceSurface::MapType::READ_WRITE, &map);
      NS_ENSURE_TRUE(mappedOK, NS_ERROR_FAILURE);

      RefPtr<DrawTarget> dt = Factory::CreateDrawTargetForData(
          BackendType::CAIRO, map.mData, dataSurface->GetSize(), map.mStride,
          SurfaceFormat::B8G8R8A8);
      if (!dt) {
        gfxWarning()
            << "nsWindowGfx::CreatesIcon failed in CreateDrawTargetForData";
        return NS_ERROR_OUT_OF_MEMORY;
      }
      dt->DrawSurface(surface, Rect(0, 0, iconSize.width, iconSize.height),
                      Rect(0, 0, frameSize.width, frameSize.height),
                      DrawSurfaceOptions(),
                      DrawOptions(1.0f, CompositionOp::OP_SOURCE));
    } else if (surface->GetFormat() != SurfaceFormat::B8G8R8A8) {
      // Convert format to SurfaceFormat::B8G8R8A8
      dataSurface = gfxUtils::CopySurfaceToDataSourceSurfaceWithFormat(
          surface, SurfaceFormat::B8G8R8A8);
      NS_ENSURE_TRUE(dataSurface, NS_ERROR_FAILURE);
      mappedOK = dataSurface->Map(DataSourceSurface::MapType::READ, &map);
    } else {
      dataSurface = surface->GetDataSurface();
      NS_ENSURE_TRUE(dataSurface, NS_ERROR_FAILURE);
      mappedOK = dataSurface->Map(DataSourceSurface::MapType::READ, &map);
    }
  }
  NS_ENSURE_TRUE(dataSurface && mappedOK, NS_ERROR_FAILURE);
  MOZ_ASSERT(dataSurface->GetFormat() == SurfaceFormat::B8G8R8A8);

  uint8_t* data = nullptr;
  UniquePtr<uint8_t[]> autoDeleteArray;
  if (map.mStride == BytesPerPixel(dataSurface->GetFormat()) * iconSize.width) {
    // Mapped data is already packed
    data = map.mData;
  } else {
    // We can't use map.mData since the pixels are not packed (as required by
    // CreateDIBitmap, which is called under the DataToBitmap call below).
    //
    // We must unmap before calling SurfaceToPackedBGRA because it needs access
    // to the pixel data.
    dataSurface->Unmap();
    map.mData = nullptr;

    autoDeleteArray = SurfaceToPackedBGRA(dataSurface);
    data = autoDeleteArray.get();
    NS_ENSURE_TRUE(data, NS_ERROR_FAILURE);
  }

  HBITMAP bmp = DataToBitmap(data, iconSize.width, -iconSize.height, 32);
  uint8_t* a1data = Data32BitTo1Bit(data, iconSize.width, iconSize.height);
  if (map.mData) {
    dataSurface->Unmap();
  }
  if (!a1data) {
    return NS_ERROR_FAILURE;
  }

  HBITMAP mbmp = DataToBitmap(a1data, iconSize.width, -iconSize.height, 1);
  free(a1data);

  ICONINFO info = {0};
  info.fIcon = !aIsCursor;
  info.xHotspot = aHotspot.x;
  info.yHotspot = aHotspot.y;
  info.hbmMask = mbmp;
  info.hbmColor = bmp;

  HCURSOR icon = ::CreateIconIndirect(&info);
  ::DeleteObject(mbmp);
  ::DeleteObject(bmp);
  if (!icon) return NS_ERROR_FAILURE;
  *aIcon = icon;
  return NS_OK;
}

// Adjust cursor image data
uint8_t* nsWindowGfx::Data32BitTo1Bit(uint8_t* aImageData, uint32_t aWidth,
                                      uint32_t aHeight) {
  // We need (aWidth + 7) / 8 bytes plus zero-padding up to a multiple of
  // 4 bytes for each row (HBITMAP requirement). Bug 353553.
  uint32_t outBpr = ((aWidth + 31) / 8) & ~3;

  // Allocate and clear mask buffer
  uint8_t* outData = (uint8_t*)calloc(outBpr, aHeight);
  if (!outData) return nullptr;

  int32_t* imageRow = (int32_t*)aImageData;
  for (uint32_t curRow = 0; curRow < aHeight; curRow++) {
    uint8_t* outRow = outData + curRow * outBpr;
    uint8_t mask = 0x80;
    for (uint32_t curCol = 0; curCol < aWidth; curCol++) {
      // Use sign bit to test for transparency, as alpha byte is highest byte
      if (*imageRow++ < 0) *outRow |= mask;

      mask >>= 1;
      if (!mask) {
        outRow++;
        mask = 0x80;
      }
    }
  }

  return outData;
}

/**
 * Convert the given image data to a HBITMAP. If the requested depth is
 * 32 bit, a bitmap with an alpha channel will be returned.
 *
 * @param aImageData The image data to convert. Must use the format accepted
 *                   by CreateDIBitmap.
 * @param aWidth     With of the bitmap, in pixels.
 * @param aHeight    Height of the image, in pixels.
 * @param aDepth     Image depth, in bits. Should be one of 1, 24 and 32.
 *
 * @return The HBITMAP representing the image. Caller should call
 *         DeleteObject when done with the bitmap.
 *         On failure, nullptr will be returned.
 */
HBITMAP nsWindowGfx::DataToBitmap(uint8_t* aImageData, uint32_t aWidth,
                                  uint32_t aHeight, uint32_t aDepth) {
  HDC dc = ::GetDC(nullptr);

  if (aDepth == 32) {
    // Alpha channel. We need the new header.
    BITMAPV4HEADER head = {0};
    head.bV4Size = sizeof(head);
    head.bV4Width = aWidth;
    head.bV4Height = aHeight;
    head.bV4Planes = 1;
    head.bV4BitCount = aDepth;
    head.bV4V4Compression = BI_BITFIELDS;
    head.bV4SizeImage = 0;  // Uncompressed
    head.bV4XPelsPerMeter = 0;
    head.bV4YPelsPerMeter = 0;
    head.bV4ClrUsed = 0;
    head.bV4ClrImportant = 0;

    head.bV4RedMask = 0x00FF0000;
    head.bV4GreenMask = 0x0000FF00;
    head.bV4BlueMask = 0x000000FF;
    head.bV4AlphaMask = 0xFF000000;

    HBITMAP bmp = ::CreateDIBitmap(
        dc, reinterpret_cast<CONST BITMAPINFOHEADER*>(&head), CBM_INIT,
        aImageData, reinterpret_cast<CONST BITMAPINFO*>(&head), DIB_RGB_COLORS);
    ::ReleaseDC(nullptr, dc);
    return bmp;
  }

  char reserved_space[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 2];
  BITMAPINFOHEADER& head = *(BITMAPINFOHEADER*)reserved_space;

  head.biSize = sizeof(BITMAPINFOHEADER);
  head.biWidth = aWidth;
  head.biHeight = aHeight;
  head.biPlanes = 1;
  head.biBitCount = (WORD)aDepth;
  head.biCompression = BI_RGB;
  head.biSizeImage = 0;  // Uncompressed
  head.biXPelsPerMeter = 0;
  head.biYPelsPerMeter = 0;
  head.biClrUsed = 0;
  head.biClrImportant = 0;

  BITMAPINFO& bi = *(BITMAPINFO*)reserved_space;

  if (aDepth == 1) {
    RGBQUAD black = {0, 0, 0, 0};
    RGBQUAD white = {255, 255, 255, 0};

    bi.bmiColors[0] = white;
    bi.bmiColors[1] = black;
  }

  HBITMAP bmp =
      ::CreateDIBitmap(dc, &head, CBM_INIT, aImageData, &bi, DIB_RGB_COLORS);
  ::ReleaseDC(nullptr, dc);
  return bmp;
}