The Tor Browser: dom/plugins/ipc/hangui/PluginHangUIChild.cpp@b8a032363ba2 (annotated)

dom/plugins/ipc/hangui/PluginHangUIChild.cpp@b8a032363ba2 (annotated)

dom/plugins/ipc/hangui/PluginHangUIChild.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

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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 "PluginHangUI.h"
 #include "PluginHangUIChild.h"
 #include "HangUIDlg.h"
 #include <assert.h>
 #include <commctrl.h>
 #include <windowsx.h>
 #include <algorithm>
 #include <sstream>
 #include <vector>
 namespace mozilla {
 namespace plugins {
 struct WinInfo
 {
   WinInfo(HWND aHwnd, POINT& aPos, SIZE& aSize)
     :hwnd(aHwnd)
   {
     pos.x = aPos.x;
     pos.y = aPos.y;
     size.cx = aSize.cx;
     size.cy = aSize.cy;
   }
   HWND  hwnd;
   POINT pos;
   SIZE  size;
 };
 typedef std::vector<WinInfo> WinInfoVec;
 PluginHangUIChild* PluginHangUIChild::sSelf = nullptr;
 const int PluginHangUIChild::kExpectedMinimumArgc = 10;
 PluginHangUIChild::PluginHangUIChild()
   : mResponseBits(0),
     mParentWindow(nullptr),
     mDlgHandle(nullptr),
     mMainThread(nullptr),
     mParentProcess(nullptr),
     mRegWaitProcess(nullptr),
     mIPCTimeoutMs(0)
 {
 }
 PluginHangUIChild::~PluginHangUIChild()
 {
   if (mMainThread) {
     CloseHandle(mMainThread);
   }
   if (mRegWaitProcess) {
     UnregisterWaitEx(mRegWaitProcess, INVALID_HANDLE_VALUE);
   }
   if (mParentProcess) {
     CloseHandle(mParentProcess);
   }
   sSelf = nullptr;
 }
 bool
 PluginHangUIChild::Init(int aArgc, wchar_t* aArgv[])
 {
   if (aArgc < kExpectedMinimumArgc) {
     return false;
   }
   unsigned int i = 1;
   mMessageText = aArgv[i];
   mWindowTitle = aArgv[++i];
   mWaitBtnText = aArgv[++i];
   mKillBtnText = aArgv[++i];
   mNoFutureText = aArgv[++i];
   std::wistringstream issHwnd(aArgv[++i]);
   issHwnd >> reinterpret_cast<HANDLE&>(mParentWindow);
   if (!issHwnd) {
     return false;
   }
   std::wistringstream issProc(aArgv[++i]);
   issProc >> mParentProcess;
   if (!issProc) {
     return false;
   }
   // Only set the App User Model ID if it's present in the args
   if (wcscmp(aArgv[++i], L"-")) {
     HMODULE shell32 = LoadLibrary(L"shell32.dll");
     if (shell32) {
       SETAPPUSERMODELID fSetAppUserModelID = (SETAPPUSERMODELID)
         GetProcAddress(shell32, "SetCurrentProcessExplicitAppUserModelID");
       if (fSetAppUserModelID) {
         fSetAppUserModelID(aArgv[i]);
       }
       FreeLibrary(shell32);
     }
   }
   std::wistringstream issTimeout(aArgv[++i]);
   issTimeout >> mIPCTimeoutMs;
   if (!issTimeout) {
     return false;
   }
   nsresult rv = mMiniShm.Init(this,
                               std::wstring(aArgv[++i]),
                               IsDebuggerPresent() ? INFINITE : mIPCTimeoutMs);
   if (NS_FAILED(rv)) {
     return false;
   }
   sSelf = this;
   return true;
 }
 void
 PluginHangUIChild::OnMiniShmEvent(MiniShmBase* aMiniShmObj)
 {
   const PluginHangUICommand* cmd = nullptr;
   nsresult rv = aMiniShmObj->GetReadPtr(cmd);
   assert(NS_SUCCEEDED(rv));
   bool returnStatus = false;
   if (NS_SUCCEEDED(rv)) {
     switch (cmd->mCode) {
       case PluginHangUICommand::HANGUI_CMD_SHOW:
         returnStatus = RecvShow();
         break;
       case PluginHangUICommand::HANGUI_CMD_CANCEL:
         returnStatus = RecvCancel();
         break;
       default:
         break;
     }
   }
 }
 // static
 INT_PTR CALLBACK
 PluginHangUIChild::SHangUIDlgProc(HWND aDlgHandle, UINT aMsgCode,
                                   WPARAM aWParam, LPARAM aLParam)
 {
   PluginHangUIChild *self = PluginHangUIChild::sSelf;
   if (self) {
     return self->HangUIDlgProc(aDlgHandle, aMsgCode, aWParam, aLParam);
   }
   return FALSE;
 }
 void
 PluginHangUIChild::ResizeButtons()
 {
   // Control IDs are specified right-to-left as they appear in the dialog
   UINT ids[] = { IDC_STOP, IDC_CONTINUE };
   UINT numIds = sizeof(ids)/sizeof(ids[0]);
   // Pass 1: Compute the ideal size
   bool needResizing = false;
   SIZE idealSize = {0};
   WinInfoVec winInfo;
   for (UINT i = 0; i < numIds; ++i) {
     HWND wnd = GetDlgItem(mDlgHandle, ids[i]);
     if (!wnd) {
       return;
     }
     // Get the button's dimensions in screen coordinates
     RECT curRect;
     if (!GetWindowRect(wnd, &curRect)) {
       return;
     }
     // Get (x,y) position of the button in client coordinates
     POINT pt;
     pt.x = curRect.left;
     pt.y = curRect.top;
     if (!ScreenToClient(mDlgHandle, &pt)) {
       return;
     }
     // Request the button's text margins
     RECT margins;
     if (!Button_GetTextMargin(wnd, &margins)) {
       return;
     }
     // Compute the button's width and height
     SIZE curSize;
     curSize.cx = curRect.right - curRect.left;
     curSize.cy = curRect.bottom - curRect.top;
     // Request the button's ideal width and height and add in the margins
     SIZE size = {0};
     if (!Button_GetIdealSize(wnd, &size)) {
       return;
     }
     size.cx += margins.left + margins.right;
     size.cy += margins.top + margins.bottom;
     // Size all buttons to be the same width as the longest button encountered
     idealSize.cx = std::max(idealSize.cx, size.cx);
     idealSize.cy = std::max(idealSize.cy, size.cy);
     // We won't bother resizing unless we need extra space
     if (idealSize.cx > curSize.cx) {
       needResizing = true;
     }
     // Save the relevant info for the resize, if any. We do this even if
     // needResizing is false because another button may trigger a resize later.
     winInfo.push_back(WinInfo(wnd, pt, curSize));
   }
   if (!needResizing) {
     return;
   }
   // Pass 2: Resize the windows
   int deltaX = 0;
   HDWP hwp = BeginDeferWindowPos((int) winInfo.size());
   if (!hwp) {
     return;
   }
   for (WinInfoVec::const_iterator itr = winInfo.begin();
        itr != winInfo.end(); ++itr) {
     // deltaX accumulates the size changes so that each button's x coordinate
     // can compensate for the width increases
     deltaX += idealSize.cx - itr->size.cx;
     hwp = DeferWindowPos(hwp, itr->hwnd, nullptr,
                          itr->pos.x - deltaX, itr->pos.y,
                          idealSize.cx, itr->size.cy,
                          SWP_NOZORDER | SWP_NOACTIVATE);
     if (!hwp) {
       return;
     }
   }
   EndDeferWindowPos(hwp);
 }
 INT_PTR
 PluginHangUIChild::HangUIDlgProc(HWND aDlgHandle, UINT aMsgCode, WPARAM aWParam,
                                  LPARAM aLParam)
 {
   mDlgHandle = aDlgHandle;
   switch (aMsgCode) {
     case WM_INITDIALOG: {
       // Register a wait on the Firefox process so that we will be informed
       // if it dies while the dialog is showing
       RegisterWaitForSingleObject(&mRegWaitProcess,
                                   mParentProcess,
                                   &SOnParentProcessExit,
                                   this,
                                   INFINITE,
                                   WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE);
       SetWindowText(aDlgHandle, mWindowTitle);
       SetDlgItemText(aDlgHandle, IDC_MSG, mMessageText);
       SetDlgItemText(aDlgHandle, IDC_NOFUTURE, mNoFutureText);
       SetDlgItemText(aDlgHandle, IDC_CONTINUE, mWaitBtnText);
       SetDlgItemText(aDlgHandle, IDC_STOP, mKillBtnText);
       ResizeButtons();
       HANDLE icon = LoadImage(nullptr, IDI_QUESTION, IMAGE_ICON, 0, 0,
                               LR_DEFAULTSIZE | LR_SHARED);
       if (icon) {
         SendDlgItemMessage(aDlgHandle, IDC_DLGICON, STM_SETICON, (WPARAM)icon, 0);
       }
       EnableWindow(mParentWindow, FALSE);
       return TRUE;
     }
     case WM_CLOSE: {
       mResponseBits |= HANGUI_USER_RESPONSE_CANCEL;
       EndDialog(aDlgHandle, 0);
       SetWindowLongPtr(aDlgHandle, DWLP_MSGRESULT, 0);
       return TRUE;
     }
     case WM_COMMAND: {
       switch (LOWORD(aWParam)) {
         case IDC_CONTINUE:
           if (HIWORD(aWParam) == BN_CLICKED) {
             mResponseBits |= HANGUI_USER_RESPONSE_CONTINUE;
             EndDialog(aDlgHandle, 1);
             SetWindowLongPtr(aDlgHandle, DWLP_MSGRESULT, 0);
             return TRUE;
           }
           break;
         case IDC_STOP:
           if (HIWORD(aWParam) == BN_CLICKED) {
             mResponseBits |= HANGUI_USER_RESPONSE_STOP;
             EndDialog(aDlgHandle, 1);
             SetWindowLongPtr(aDlgHandle, DWLP_MSGRESULT, 0);
             return TRUE;
           }
           break;
         case IDC_NOFUTURE:
           if (HIWORD(aWParam) == BN_CLICKED) {
             if (Button_GetCheck(GetDlgItem(aDlgHandle,
                                            IDC_NOFUTURE)) == BST_CHECKED) {
               mResponseBits |= HANGUI_USER_RESPONSE_DONT_SHOW_AGAIN;
             } else {
               mResponseBits &=
                 ~static_cast<DWORD>(HANGUI_USER_RESPONSE_DONT_SHOW_AGAIN);
             }
             SetWindowLongPtr(aDlgHandle, DWLP_MSGRESULT, 0);
             return TRUE;
           }
           break;
         default:
           break;
       }
       break;
     }
     case WM_DESTROY: {
       EnableWindow(mParentWindow, TRUE);
       SetForegroundWindow(mParentWindow);
       break;
     }
     default:
       break;
   }
   return FALSE;
 }
 // static
 VOID CALLBACK
 PluginHangUIChild::SOnParentProcessExit(PVOID aObject, BOOLEAN aIsTimer)
 {
   // Simulate a cancel if the parent process died
   PluginHangUIChild* object = static_cast<PluginHangUIChild*>(aObject);
   object->RecvCancel();
 }
 bool
 PluginHangUIChild::RecvShow()
 {
   return (QueueUserAPC(&ShowAPC,
                        mMainThread,
                        reinterpret_cast<ULONG_PTR>(this)));
 }
 bool
 PluginHangUIChild::Show()
 {
   INT_PTR dlgResult = DialogBox(GetModuleHandle(nullptr),
                                 MAKEINTRESOURCE(IDD_HANGUIDLG),
                                 nullptr,
                                 &SHangUIDlgProc);
   mDlgHandle = nullptr;
   assert(dlgResult != -1);
   bool result = false;
   if (dlgResult != -1) {
     PluginHangUIResponse* response = nullptr;
     nsresult rv = mMiniShm.GetWritePtr(response);
     if (NS_SUCCEEDED(rv)) {
       response->mResponseBits = mResponseBits;
       result = NS_SUCCEEDED(mMiniShm.Send());
     }
   }
   return result;
 }
 // static
 VOID CALLBACK
 PluginHangUIChild::ShowAPC(ULONG_PTR aContext)
 {
   PluginHangUIChild* object = reinterpret_cast<PluginHangUIChild*>(aContext);
   object->Show();
 }
 bool
 PluginHangUIChild::RecvCancel()
 {
   if (mDlgHandle) {
     PostMessage(mDlgHandle, WM_CLOSE, 0, 0);
   }
   return true;
 }
 bool
 PluginHangUIChild::WaitForDismissal()
 {
   if (!SetMainThread()) {
     return false;
   }
   DWORD waitResult = WaitForSingleObjectEx(mParentProcess,
                                            mIPCTimeoutMs,
                                            TRUE);
   return waitResult == WAIT_OBJECT_0 ||
          waitResult == WAIT_IO_COMPLETION;
 }
 bool
 PluginHangUIChild::SetMainThread()
 {
   if (mMainThread) {
     CloseHandle(mMainThread);
     mMainThread = nullptr;
   }
   mMainThread = OpenThread(THREAD_SET_CONTEXT,
                            FALSE,
                            GetCurrentThreadId());
   return !(!mMainThread);
 }
 } // namespace plugins
 } // namespace mozilla
 #ifdef __MINGW32__
 extern "C"
 #endif
 int
 wmain(int argc, wchar_t *argv[])
 {
   INITCOMMONCONTROLSEX icc = { sizeof(INITCOMMONCONTROLSEX),
                                ICC_STANDARD_CLASSES };
   if (!InitCommonControlsEx(&icc)) {
     return 1;
   }
   mozilla::plugins::PluginHangUIChild hangui;
   if (!hangui.Init(argc, argv)) {
     return 1;
   }
   if (!hangui.WaitForDismissal()) {
     return 1;
   }
   return 0;
 }

The Tor Browser / annotate

dom/plugins/ipc/hangui/PluginHangUIChild.cpp@b8a032363ba2 (annotated)

dom/plugins/ipc/hangui/PluginHangUIChild.cpp