The Tor Browser: widget/windows/TaskbarPreview.cpp@b8a032363ba2 (annotated)

widget/windows/TaskbarPreview.cpp@b8a032363ba2 (annotated)

widget/windows/TaskbarPreview.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* vim: se cin sw=2 ts=2 et : */
 /* -*- 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/. */
 #include "TaskbarPreview.h"
 #include <nsITaskbarPreviewController.h>
 #include <windows.h>
 #include <nsError.h>
 #include <nsCOMPtr.h>
 #include <nsIWidget.h>
 #include <nsIBaseWindow.h>
 #include <nsIObserverService.h>
 #include <nsServiceManagerUtils.h>
 #include "nsUXThemeData.h"
 #include "nsWindow.h"
 #include "nsAppShell.h"
 #include "TaskbarPreviewButton.h"
 #include "WinUtils.h"
 #include "gfxWindowsPlatform.h"
 #include <nsIBaseWindow.h>
 #include <nsICanvasRenderingContextInternal.h>
 #include "mozilla/dom/CanvasRenderingContext2D.h"
 #include <imgIContainer.h>
 #include <nsIDocShell.h>
 #include "mozilla/Telemetry.h"
 // Defined in dwmapi in a header that needs a higher numbered _WINNT #define
 #define DWM_SIT_DISPLAYFRAME 0x1
 namespace mozilla {
 namespace widget {
 namespace {
 // Shared by all TaskbarPreviews to avoid the expensive creation process.
 // Manually refcounted (see gInstCount) by the ctor and dtor of TaskbarPreview.
 // This is done because static constructors aren't allowed for perf reasons.
 dom::CanvasRenderingContext2D* gCtx = nullptr;
 // Used in tracking the number of previews. Used in freeing
 // the static 2d rendering context on shutdown.
 uint32_t gInstCount = 0;
 /* Helper method to lazily create a canvas rendering context and associate a given
  * surface with it.
  *
  * @param shell The docShell used by the canvas context for text settings and other
  *              misc things.
  * @param surface The gfxSurface backing the context
  * @param width The width of the given surface
  * @param height The height of the given surface
  */
 nsresult
 GetRenderingContext(nsIDocShell *shell, gfxASurface *surface,
                     uint32_t width, uint32_t height) {
   if (!gCtx) {
     // create the canvas rendering context
     Telemetry::Accumulate(Telemetry::CANVAS_2D_USED, 1);
     gCtx = new mozilla::dom::CanvasRenderingContext2D();
     NS_ADDREF(gCtx);
   }
   // Set the surface we'll use to render.
   return gCtx->InitializeWithSurface(shell, surface, width, height);
 }
 /* Helper method for freeing surface resources associated with the rendering context.
  */
 void
 ResetRenderingContext() {
   if (!gCtx)
     return;
   if (NS_FAILED(gCtx->Reset())) {
     NS_RELEASE(gCtx);
     gCtx = nullptr;
   }
 }
 }
 TaskbarPreview::TaskbarPreview(ITaskbarList4 *aTaskbar, nsITaskbarPreviewController *aController, HWND aHWND, nsIDocShell *aShell)
   : mTaskbar(aTaskbar),
     mController(aController),
     mWnd(aHWND),
     mVisible(false),
     mDocShell(do_GetWeakReference(aShell))
 {
   // TaskbarPreview may outlive the WinTaskbar that created it
   ::CoInitialize(nullptr);
   gInstCount++;
   WindowHook &hook = GetWindowHook();
   hook.AddMonitor(WM_DESTROY, MainWindowHook, this);
 }
 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;
   if (--gInstCount == 0)
     NS_IF_RELEASE(gCtx);
   ::CoUninitialize();
 }
 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 (!mWnd)
     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_ERROR_FAILURE;
   // DWM Composition is required for previews
   if (!nsUXThemeData::CheckForCompositor())
     return NS_OK;
   HWND previewWindow = PreviewWindow();
   return FAILED(WinUtils::dwmInvalidateIconicBitmapsPtr(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 {
     WindowHook &hook = GetWindowHook();
     hook.AddMonitor(nsAppShell::GetTaskbarButtonCreatedMessage(), MainWindowHook, this);
   }
   return rv;
 }
 nsresult
 TaskbarPreview::Disable() {
   WindowHook &hook = GetWindowHook();
   (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() {
   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 = nsIWidget::DefaultScaleOverride();
         if (scale <= 0.0)
           scale = gfxWindowsPlatform::GetPlatform()->GetDPIScale();
         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->HasTaskbarIconBeenCreated();
   }
   return false;
 }
 WindowHook&
 TaskbarPreview::GetWindowHook() {
   nsWindow *window = WinUtils::GetNSWindowPtr(mWnd);
   NS_ASSERTION(window, "Cannot use taskbar previews in an embedded context!");
   return window->GetWindowHook();
 }
 void
 TaskbarPreview::EnableCustomDrawing(HWND aHWND, bool aEnable) {
   BOOL enabled = aEnable;
   WinUtils::dwmSetWindowAttributePtr(
       aHWND,
       DWMWA_FORCE_ICONIC_REPRESENTATION,
       &enabled,
       sizeof(enabled));
   WinUtils::dwmSetWindowAttributePtr(
       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;
   nsRefPtr<gfxWindowsSurface> surface = new gfxWindowsSurface(gfxIntSize(width, height), gfxImageFormat::ARGB32);
   nsCOMPtr<nsIDocShell> shell = do_QueryReferent(mDocShell);
   if (!shell)
     return;
   rv = GetRenderingContext(shell, surface, width, height);
   if (NS_FAILED(rv))
     return;
   bool drawFrame = false;
   if (isPreview)
     rv = mController->DrawPreview(gCtx, &drawFrame);
   else
     rv = mController->DrawThumbnail(gCtx, width, height, &drawFrame);
   if (NS_FAILED(rv))
     return;
   HDC hDC = surface->GetDC();
   HBITMAP hBitmap = (HBITMAP)GetCurrentObject(hDC, OBJ_BITMAP);
   DWORD flags = drawFrame ? DWM_SIT_DISPLAYFRAME : 0;
   POINT pptClient = { 0, 0 };
   if (isPreview)
     WinUtils::dwmSetIconicLivePreviewBitmapPtr(PreviewWindow(), hBitmap, &pptClient, flags);
   else
     WinUtils::dwmSetIconicThumbnailPtr(PreviewWindow(), hBitmap, flags);
   ResetRenderingContext();
 }
 /* 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<TaskbarPreview*>(aContext);
   if (nMsg == WM_DESTROY) {
     // nsWindow is being destroyed
     // We can't really do anything at this point including removing hooks
     preview->mWnd = nullptr;
   } 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

The Tor Browser / annotate

widget/windows/TaskbarPreview.cpp@b8a032363ba2 (annotated)

widget/windows/TaskbarPreview.cpp