Give DisconnectWindow some TLC.

remoting/host/disconnect_window_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/disconnect_window.h"
 
 #include <windows.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 23 matching lines @@
 
 } // namespace anonymous
 
 namespace remoting {
 
 class DisconnectWindowWin : public DisconnectWindow {
  public:
   DisconnectWindowWin();
   virtual ~DisconnectWindowWin();
 
+  // DisconnectWindow interface.
   virtual bool Show(const UiStrings& ui_strings,
-                    const DisconnectCallback& disconnect_callback,
+                    const base::Closure& disconnect_callback,
                     const std::string& username) OVERRIDE;
   virtual void Hide() OVERRIDE;
 
 private:
   static BOOL CALLBACK DialogProc(HWND hwnd, UINT message, WPARAM wparam,
                                   LPARAM lparam);
 
   BOOL OnDialogMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
   // Creates the dialog window and registers the disconnect hot key.
   bool BeginDialog(const UiStrings& ui_strings,
                    const std::string& username);
 
-  // Unregisters the disconnect hot key and closed the dialog.
+  // Closes the dialog, unregisters the hot key and invokes the disconnect
+  // callback, if set.
   void EndDialog();
 
-  // Invokes the disconnect callback passed to Show().
-  void InvokeDiconnectCallback();
-
   // Trys to position the dialog window above the taskbar.
   void SetDialogPosition();
 
   // Applies localization string and resizes the dialog.
   bool SetStrings(const UiStrings& strings, const string16& username);
 
-  DisconnectCallback disconnect_callback_;
+  base::Closure disconnect_callback_;
   HWND hwnd_;
   bool has_hotkey_;
   base::win::ScopedGDIObject<HPEN> border_pen_;
 
   DISALLOW_COPY_AND_ASSIGN(DisconnectWindowWin);
 };
 
 static int GetControlTextWidth(HWND control) {
   RECT rect = {0, 0, 0, 0};
   WCHAR text[256];
   int result = GetWindowText(control, text, arraysize(text));
   if (result) {
     base::win::ScopedGetDC dc(control);
     base::win::ScopedSelectObject font(
         dc, (HFONT)SendMessage(control, WM_GETFONT, 0, 0));
     DrawText(dc, text, -1, &rect, DT_CALCRECT | DT_SINGLELINE);
   }
   return rect.right;
 }
 
 DisconnectWindowWin::DisconnectWindowWin()
     : hwnd_(NULL),
       has_hotkey_(false),
       border_pen_(CreatePen(PS_SOLID, 5,
                             RGB(0.13 * 255, 0.69 * 255, 0.11 * 255))) {
 }
 
 DisconnectWindowWin::~DisconnectWindowWin() {
-  EndDialog();
+  Hide();
 }
 
 bool DisconnectWindowWin::Show(const UiStrings& ui_strings,
-                               const DisconnectCallback& disconnect_callback,
+                               const base::Closure& disconnect_callback,
                                const std::string& username) {
   DCHECK(disconnect_callback_.is_null());
   DCHECK(!disconnect_callback.is_null());
 
   disconnect_callback_ = disconnect_callback;
 
   if (BeginDialog(ui_strings, username)) {
     return true;
   } else {
-    EndDialog();
+    Hide();
     return false;
   }
 }
 
 void DisconnectWindowWin::Hide() {
+  // Clear the |disconnect_callback_| so it won't be invoked by EndDialog().
+  disconnect_callback_.Reset();
   EndDialog();
 }
 
 BOOL CALLBACK DisconnectWindowWin::DialogProc(HWND hwnd, UINT message,
                                               WPARAM wparam, LPARAM lparam) {
   LONG_PTR self = NULL;
   if (message == WM_INITDIALOG) {
     self = lparam;
 
     // Store |this| to the window's user data.
@@ skipping 17 matching lines @@
   switch (message) {
     // Ignore close messages.
     case WM_CLOSE:
       return TRUE;
 
     // Handle the Disconnect button.
     case WM_COMMAND:
       switch (LOWORD(wparam)) {
         case IDC_DISCONNECT:
           EndDialog();
-          InvokeDiconnectCallback();
           return TRUE;
       }
       return FALSE;
 
     // Ensure we don't try to use the HWND anymore.
     case WM_DESTROY:
       hwnd_ = NULL;
+
+      // Ensure that the disconnect callback is invoked even if somehow our
+      // window gets destroyed.
+      EndDialog();
+
       return TRUE;
 
     // Ensure the dialog stays visible if the work area dimensions change.
     case WM_SETTINGCHANGE:
       if (wparam == SPI_SETWORKAREA)
         SetDialogPosition();
       return TRUE;
 
     // Ensure the dialog stays visible if the display dimensions change.
     case WM_DISPLAYCHANGE:
       SetDialogPosition();
       return TRUE;
 
     // Handle the disconnect hot-key.
     case WM_HOTKEY:
       EndDialog();
-      InvokeDiconnectCallback();
       return TRUE;
 
     // Let the window be draggable by its client area by responding
     // that the entire window is the title bar.
     case WM_NCHITTEST:
       SetWindowLong(hwnd, DWL_MSGRESULT, HTCAPTION);
       return TRUE;
 
     case WM_PAINT: {
       PAINTSTRUCT ps;
@@ skipping 67 matching lines @@
 }
 
 void DisconnectWindowWin::EndDialog() {
   if (has_hotkey_) {
     UnregisterHotKey(hwnd_, DISCONNECT_HOTKEY_ID);
     has_hotkey_ = false;
   }
 
   if (hwnd_) {
     ::DestroyWindow(hwnd_);
-    hwnd_ = NULL;
+    DCHECK(hwnd_ == NULL);
   }
 
-  disconnect_callback_.Reset();
-}
-
-void DisconnectWindowWin::InvokeDiconnectCallback() {
-  disconnect_callback_.Run();
+  if (!disconnect_callback_.is_null()) {
+    disconnect_callback_.Run();
+    disconnect_callback_.Reset();
+  }
 }
 
 void DisconnectWindowWin::SetDialogPosition() {
   // Try to center the window above the task-bar. If that fails, use the
   // primary monitor. If that fails (very unlikely), use the default position.
   HWND taskbar = FindWindow(kShellTrayWindowName, NULL);
   HMONITOR monitor = MonitorFromWindow(taskbar, MONITOR_DEFAULTTOPRIMARY);
   MONITORINFO monitor_info = {sizeof(monitor_info)};
   RECT window_rect;
   if (GetMonitorInfo(monitor, &monitor_info) &&
@@ skipping 94 matching lines @@
     return false;
 
   return true;
 }
 
 scoped_ptr<DisconnectWindow> DisconnectWindow::Create() {
   return scoped_ptr<DisconnectWindow>(new DisconnectWindowWin());
 }
 
 }  // namespace remoting