# Global Metrics

path: .metrics.halstead.n2
old: 11.0
new: 197.0
path: .metrics.halstead.level
old: 0.06547619047619048
new: 0.024920936116382037
path: .metrics.halstead.purity_ratio
old: 1.1749753306328137
new: 1.1921554058576729
path: .metrics.halstead.time
old: 264.8339908818833
new: 24129.90450941454
path: .metrics.halstead.length
old: 69.0
new: 1383.0
path: .metrics.halstead.effort
old: 4767.0118358739
new: 434338.2811694617
path: .metrics.halstead.volume
old: 312.1257749679339
new: 10824.116557923337
path: .metrics.halstead.bugs
old: 0.09441541333882938
new: 1.9117487615431792
path: .metrics.halstead.estimated_program_length
old: 81.07329781366414
new: 1648.7509263011616
path: .metrics.halstead.N2
old: 28.0
new: 527.0
path: .metrics.halstead.vocabulary
old: 23.0
new: 227.0
path: .metrics.halstead.n1
old: 12.0
new: 30.0
path: .metrics.halstead.N1
old: 41.0
new: 856.0
path: .metrics.halstead.difficulty
old: 15.272727272727272
new: 40.12690355329949
path: .metrics.nargs.average
old: 3.0
new: 1.12
path: .metrics.nargs.sum
old: 3.0
new: 28.0
path: .metrics.nexits.sum
old: 0.0
new: 40.0
path: .metrics.nexits.average
old: 0.0
new: 1.6
path: .metrics.cognitive.average
old: 1.0
new: 2.48
path: .metrics.cognitive.sum
old: 1.0
new: 62.0
path: .metrics.cyclomatic.average
old: 1.5
new: 2.9642857142857144
path: .metrics.cyclomatic.sum
old: 3.0
new: 83.0
path: .metrics.loc.blank
old: 2.0
new: 63.0
path: .metrics.loc.ploc
old: 16.0
new: 304.0
path: .metrics.loc.cloc
old: 17.0
new: 42.0
path: .metrics.loc.lloc
old: 6.0
new: 138.0
path: .metrics.loc.sloc
old: 35.0
new: 409.0
path: .metrics.nom.functions
old: 1.0
new: 25.0
path: .metrics.nom.total
old: 1.0
new: 25.0
path: .metrics.mi.mi_original
old: 82.84764900020828
new: 6.182248393138906
path: .metrics.mi.mi_sei
old: 88.21890556722568
new: -34.51569617347431
path: .metrics.mi.mi_visual_studio
old: 48.448917543981445
new: 3.615349937508132

# Spaces Data

## Minimal test - lines (34, 409)

path: .spaces[0].metrics.cognitive.average
old: 1.0
new: 2.48
path: .spaces[0].metrics.cognitive.sum
old: 1.0
new: 62.0
path: .spaces[0].metrics.loc.lloc
old: 6.0
new: 138.0
path: .spaces[0].metrics.loc.ploc
old: 15.0
new: 284.0
path: .spaces[0].metrics.loc.cloc
old: 3.0
new: 34.0
path: .spaces[0].metrics.loc.sloc
old: 16.0
new: 376.0
path: .spaces[0].metrics.loc.blank
old: 0.0
new: 58.0
path: .spaces[0].metrics.cyclomatic.sum
old: 2.0
new: 82.0
path: .spaces[0].metrics.cyclomatic.average
old: 2.0
new: 3.037037037037037
path: .spaces[0].metrics.nexits.average
old: 0.0
new: 1.6
path: .spaces[0].metrics.nexits.sum
old: 0.0
new: 40.0
path: .spaces[0].metrics.mi.mi_original
old: 95.90851177845404
new: 7.872031471039762
path: .spaces[0].metrics.mi.mi_visual_studio
old: 56.08684899324798
new: 4.603527176046644
path: .spaces[0].metrics.mi.mi_sei
old: 93.9509630482375
new: -33.535321045429555
path: .spaces[0].metrics.halstead.length
old: 68.0
new: 1370.0
path: .spaces[0].metrics.halstead.estimated_program_length
old: 76.2388309575275
new: 1549.4902567343493
path: .spaces[0].metrics.halstead.bugs
old: 0.09632692631295608
new: 1.9294657802737696
path: .spaces[0].metrics.halstead.difficulty
old: 16.2
new: 41.45161290322581
path: .spaces[0].metrics.halstead.time
old: 272.9172150606026
new: 24466.11416341161
path: .spaces[0].metrics.halstead.level
old: 0.0617283950617284
new: 0.02412451361867704
path: .spaces[0].metrics.halstead.n2
old: 10.0
new: 186.0
path: .spaces[0].metrics.halstead.volume
old: 303.2413500673362
new: 10624.195877963952
path: .spaces[0].metrics.halstead.effort
old: 4912.509871090847
new: 440390.054941409
path: .spaces[0].metrics.halstead.purity_ratio
old: 1.1211592787871691
new: 1.1310147859374813
path: .spaces[0].metrics.halstead.n1
old: 12.0
new: 30.0
path: .spaces[0].metrics.halstead.vocabulary
old: 22.0
new: 216.0
path: .spaces[0].metrics.halstead.N1
old: 41.0
new: 856.0
path: .spaces[0].metrics.halstead.N2
old: 27.0
new: 514.0
path: .spaces[0].metrics.nargs.average
old: 3.0
new: 1.12
path: .spaces[0].metrics.nargs.sum
old: 3.0
new: 28.0
path: .spaces[0].metrics.nom.total
old: 1.0
new: 25.0
path: .spaces[0].metrics.nom.functions
old: 1.0
new: 25.0

### Code

    namespace mozilla {
    namespace widget {

    ///////////////////////////////////////////////////////////////////////////////
    // TaskbarPreview

    TaskbarPreview::TaskbarPreview(ITaskbarList4* aTaskbar,
                                   nsITaskbarPreviewController* aController,
                                   HWND aHWND, nsIDocShell* aShell)
        : mTaskbar(aTaskbar),
          mController(aController),
          mWnd(aHWND),
          mVisible(false),
          mDocShell(do_GetWeakReference(aShell)) {}

    TaskbarPreview::~TaskbarPreview() {
      // Avoid dangling pointer
      if (sActivePreview == this) sActivePreview = nullptr;

      // Our subclass should have invoked DetachFromNSWindow already.
      NS_ASSERTION(
          !mWnd,
          "TaskbarPreview::DetachFromNSWindow was not called before destruction");

      // Make sure to release before potentially uninitializing COM
      mTaskbar = nullptr;

      ::CoUninitialize();
    }

    nsresult TaskbarPreview::Init() {
      // TaskbarPreview may outlive the WinTaskbar that created it
      if (FAILED(::CoInitialize(nullptr))) {
        return NS_ERROR_NOT_INITIALIZED;
      }

      WindowHook* hook = GetWindowHook();
      if (!hook) {
        return NS_ERROR_NOT_AVAILABLE;
      }
      return hook->AddMonitor(WM_DESTROY, MainWindowHook, this);
    }

    NS_IMETHODIMP
    TaskbarPreview::SetController(nsITaskbarPreviewController* aController) {
      NS_ENSURE_ARG(aController);

      mController = aController;
      return NS_OK;
    }

    NS_IMETHODIMP
    TaskbarPreview::GetController(nsITaskbarPreviewController** aController) {
      NS_ADDREF(*aController = mController);
      return NS_OK;
    }

    NS_IMETHODIMP
    TaskbarPreview::GetTooltip(nsAString& aTooltip) {
      aTooltip = mTooltip;
      return NS_OK;
    }

    NS_IMETHODIMP
    TaskbarPreview::SetTooltip(const nsAString& aTooltip) {
      mTooltip = aTooltip;
      return CanMakeTaskbarCalls() ? UpdateTooltip() : NS_OK;
    }

    NS_IMETHODIMP
    TaskbarPreview::SetVisible(bool visible) {
      if (mVisible == visible) return NS_OK;
      mVisible = visible;

      // If the nsWindow has already been destroyed but the caller is still trying
      // to use it then just pretend that everything succeeded.  The caller doesn't
      // actually have a way to detect this since it's the same case as when we
      // CanMakeTaskbarCalls returns false.
      if (!IsWindowAvailable()) return NS_OK;

      return visible ? Enable() : Disable();
    }

    NS_IMETHODIMP
    TaskbarPreview::GetVisible(bool* visible) {
      *visible = mVisible;
      return NS_OK;
    }

    NS_IMETHODIMP
    TaskbarPreview::SetActive(bool active) {
      if (active)
        sActivePreview = this;
      else if (sActivePreview == this)
        sActivePreview = nullptr;

      return CanMakeTaskbarCalls() ? ShowActive(active) : NS_OK;
    }

    NS_IMETHODIMP
    TaskbarPreview::GetActive(bool* active) {
      *active = sActivePreview == this;
      return NS_OK;
    }

    NS_IMETHODIMP
    TaskbarPreview::Invalidate() {
      if (!mVisible) return NS_OK;

      // DWM Composition is required for previews
      if (!gfxWindowsPlatform::GetPlatform()->DwmCompositionEnabled()) return NS_OK;

      HWND previewWindow = PreviewWindow();
      return FAILED(DwmInvalidateIconicBitmaps(previewWindow)) ? NS_ERROR_FAILURE
                                                               : NS_OK;
    }

    nsresult TaskbarPreview::UpdateTaskbarProperties() {
      nsresult rv = UpdateTooltip();

      // If we are the active preview and our window is the active window, restore
      // our active state - otherwise some other non-preview window is now active
      // and should be displayed as so.
      if (sActivePreview == this) {
        if (mWnd == ::GetActiveWindow()) {
          nsresult rvActive = ShowActive(true);
          if (NS_FAILED(rvActive)) rv = rvActive;
        } else {
          sActivePreview = nullptr;
        }
      }
      return rv;
    }

    nsresult TaskbarPreview::Enable() {
      nsresult rv = NS_OK;
      if (CanMakeTaskbarCalls()) {
        rv = UpdateTaskbarProperties();
      } else if (IsWindowAvailable()) {
        WindowHook* hook = GetWindowHook();
        MOZ_ASSERT(hook,
                   "IsWindowAvailable() should have eliminated the null case.");
        hook->AddMonitor(nsAppShell::GetTaskbarButtonCreatedMessage(),
                         MainWindowHook, this);
      }
      return rv;
    }

    nsresult TaskbarPreview::Disable() {
      if (!IsWindowAvailable()) {
        // Window is already destroyed
        return NS_OK;
      }

      WindowHook* hook = GetWindowHook();
      MOZ_ASSERT(hook, "IsWindowAvailable() should have eliminated the null case.");
      (void)hook->RemoveMonitor(nsAppShell::GetTaskbarButtonCreatedMessage(),
                                MainWindowHook, this);

      return NS_OK;
    }

    bool TaskbarPreview::IsWindowAvailable() const {
      if (mWnd) {
        nsWindow* win = WinUtils::GetNSWindowPtr(mWnd);
        if (win && !win->Destroyed()) {
          return true;
        }
      }
      return false;
    }

    void TaskbarPreview::DetachFromNSWindow() {
      if (WindowHook* hook = GetWindowHook()) {
        hook->RemoveMonitor(WM_DESTROY, MainWindowHook, this);
      }
      mWnd = nullptr;
    }

    LRESULT
    TaskbarPreview::WndProc(UINT nMsg, WPARAM wParam, LPARAM lParam) {
      switch (nMsg) {
        case WM_DWMSENDICONICTHUMBNAIL: {
          uint32_t width = HIWORD(lParam);
          uint32_t height = LOWORD(lParam);
          float aspectRatio = width / float(height);

          nsresult rv;
          float preferredAspectRatio;
          rv = mController->GetThumbnailAspectRatio(&preferredAspectRatio);
          if (NS_FAILED(rv)) break;

          uint32_t thumbnailWidth = width;
          uint32_t thumbnailHeight = height;

          if (aspectRatio > preferredAspectRatio) {
            thumbnailWidth = uint32_t(thumbnailHeight * preferredAspectRatio);
          } else {
            thumbnailHeight = uint32_t(thumbnailWidth / preferredAspectRatio);
          }

          DrawBitmap(thumbnailWidth, thumbnailHeight, false);
        } break;
        case WM_DWMSENDICONICLIVEPREVIEWBITMAP: {
          uint32_t width, height;
          nsresult rv;
          rv = mController->GetWidth(&width);
          if (NS_FAILED(rv)) break;
          rv = mController->GetHeight(&height);
          if (NS_FAILED(rv)) break;

          double scale = StaticPrefs::layout_css_devPixelsPerPx();
          if (scale <= 0.0) {
            scale = WinUtils::LogToPhysFactor(PreviewWindow());
          }
          DrawBitmap(NSToIntRound(scale * width), NSToIntRound(scale * height),
                     true);
        } break;
      }
      return ::DefWindowProcW(PreviewWindow(), nMsg, wParam, lParam);
    }

    bool TaskbarPreview::CanMakeTaskbarCalls() {
      // If the nsWindow has already been destroyed and we know it but our caller
      // clearly doesn't so we can't make any calls.
      if (!mWnd) return false;
      // Certain functions like SetTabOrder seem to require a visible window. During
      // window close, the window seems to be hidden before being destroyed.
      if (!::IsWindowVisible(mWnd)) return false;
      if (mVisible) {
        nsWindow* window = WinUtils::GetNSWindowPtr(mWnd);
        NS_ASSERTION(window, "Could not get nsWindow from HWND");
        return window ? window->HasTaskbarIconBeenCreated() : false;
      }
      return false;
    }

    WindowHook* TaskbarPreview::GetWindowHook() {
      nsWindow* window = WinUtils::GetNSWindowPtr(mWnd);
      NS_ASSERTION(window, "Cannot use taskbar previews in an embedded context!");

      return window ? &window->GetWindowHook() : nullptr;
    }

    void TaskbarPreview::EnableCustomDrawing(HWND aHWND, bool aEnable) {
      BOOL enabled = aEnable;
      DwmSetWindowAttribute(aHWND, DWMWA_FORCE_ICONIC_REPRESENTATION, &enabled,
                            sizeof(enabled));

      DwmSetWindowAttribute(aHWND, DWMWA_HAS_ICONIC_BITMAP, &enabled,
                            sizeof(enabled));
    }

    nsresult TaskbarPreview::UpdateTooltip() {
      NS_ASSERTION(CanMakeTaskbarCalls() && mVisible,
                   "UpdateTooltip called on invisible tab preview");

      if (FAILED(mTaskbar->SetThumbnailTooltip(PreviewWindow(), mTooltip.get())))
        return NS_ERROR_FAILURE;
      return NS_OK;
    }

    void TaskbarPreview::DrawBitmap(uint32_t width, uint32_t height,
                                    bool isPreview) {
      nsresult rv;
      nsCOMPtr callback =
          do_CreateInstance("@mozilla.org/widget/taskbar-preview-callback;1", &rv);
      if (NS_FAILED(rv)) {
        return;
      }

      ((TaskbarPreviewCallback*)callback.get())->SetPreview(this);

      if (isPreview) {
        ((TaskbarPreviewCallback*)callback.get())->SetIsPreview();
        mController->RequestPreview(callback);
      } else {
        mController->RequestThumbnail(callback, width, height);
      }
    }

    ///////////////////////////////////////////////////////////////////////////////
    // TaskbarPreviewCallback

    NS_IMPL_ISUPPORTS(TaskbarPreviewCallback, nsITaskbarPreviewCallback)

    /* void done (in nsISupports aCanvas, in boolean aDrawBorder); */
    NS_IMETHODIMP
    TaskbarPreviewCallback::Done(nsISupports* aCanvas, bool aDrawBorder) {
      // We create and destroy TaskbarTabPreviews from front end code in response
      // to TabOpen and TabClose events. Each TaskbarTabPreview creates and owns a
      // proxy HWND which it hands to Windows as a tab identifier. When a tab
      // closes, TaskbarTabPreview Disable() method is called by front end, which
      // destroys the proxy window and clears mProxyWindow which is the HWND
      // returned from PreviewWindow(). So, since this is async, we should check to
      // be sure the tab is still alive before doing all this gfx work and making
      // dwm calls. To accomplish this we check the result of PreviewWindow().
      if (!aCanvas || !mPreview || !mPreview->PreviewWindow() ||
          !mPreview->IsWindowAvailable()) {
        return NS_ERROR_FAILURE;
      }

      nsCOMPtr content(do_QueryInterface(aCanvas));
      auto canvas = dom::HTMLCanvasElement::FromNodeOrNull(content);
      if (!canvas) {
        return NS_ERROR_FAILURE;
      }

      RefPtr source = canvas->GetSurfaceSnapshot();
      if (!source) {
        return NS_ERROR_FAILURE;
      }
      RefPtr target = new gfxWindowsSurface(
          source->GetSize(), gfx::SurfaceFormat::A8R8G8B8_UINT32);
      if (!target) {
        return NS_ERROR_FAILURE;
      }

      RefPtr srcSurface = source->GetDataSurface();
      RefPtr imageSurface = target->GetAsImageSurface();
      if (!srcSurface || !imageSurface) {
        return NS_ERROR_FAILURE;
      }

      gfx::DataSourceSurface::MappedSurface sourceMap;
      srcSurface->Map(gfx::DataSourceSurface::READ, &sourceMap);
      mozilla::gfx::CopySurfaceDataToPackedArray(
          sourceMap.mData, imageSurface->Data(), srcSurface->GetSize(),
          sourceMap.mStride, BytesPerPixel(srcSurface->GetFormat()));
      srcSurface->Unmap();

      HDC hDC = target->GetDC();
      HBITMAP hBitmap = (HBITMAP)GetCurrentObject(hDC, OBJ_BITMAP);

      DWORD flags = aDrawBorder ? DWM_SIT_DISPLAYFRAME : 0;
      POINT pptClient = {0, 0};
      HRESULT hr;
      if (!mIsThumbnail) {
        hr = DwmSetIconicLivePreviewBitmap(mPreview->PreviewWindow(), hBitmap,
                                           &pptClient, flags);
      } else {
        hr = DwmSetIconicThumbnail(mPreview->PreviewWindow(), hBitmap, flags);
      }
      MOZ_ASSERT(SUCCEEDED(hr));
      return NS_OK;
    }

    /* static */
    bool TaskbarPreview::MainWindowHook(void* aContext, HWND hWnd, UINT nMsg,
                                        WPARAM wParam, LPARAM lParam,
                                        LRESULT* aResult) {
      NS_ASSERTION(nMsg == nsAppShell::GetTaskbarButtonCreatedMessage() ||
                       nMsg == WM_DESTROY,
                   "Window hook proc called with wrong message");
      NS_ASSERTION(aContext, "Null context in MainWindowHook");
      if (!aContext) return false;
      TaskbarPreview* preview = reinterpret_cast(aContext);
      if (nMsg == WM_DESTROY) {
        // nsWindow is being destroyed
        // We can't really do anything at this point including removing hooks
        return false;
      } else {
        nsWindow* window = WinUtils::GetNSWindowPtr(preview->mWnd);
        if (window) {
          window->SetHasTaskbarIconBeenCreated();

          if (preview->mVisible) preview->UpdateTaskbarProperties();
        }
      }
      return false;
    }

    TaskbarPreview* TaskbarPreview::sActivePreview = nullptr;

    }  // namespace widget
    }  // namespace mozilla