Deprecate NonThreadSafe in remoting in favor of SequenceChecker.

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 <stddef.h>
 #include <windows.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 103 matching lines @@
       border_pen_(CreatePen(PS_SOLID, 5,
                             RGB(0.13 * 255, 0.69 * 255, 0.11 * 255))) {
 }
 
 DisconnectWindowWin::~DisconnectWindowWin() {
   EndDialog();
 }
 
 void DisconnectWindowWin::Start(
     const base::WeakPtr<ClientSessionControl>& client_session_control) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!client_session_control_);
   DCHECK(client_session_control);
 
   client_session_control_ = client_session_control;
 
   std::string client_jid = client_session_control_->client_jid();
   username_ = client_jid.substr(0, client_jid.find('/'));
   if (!BeginDialog())
     EndDialog();
 }
@@ skipping 19 matching lines @@
     return reinterpret_cast<DisconnectWindowWin*>(self)->OnDialogMessage(
         hwnd, message, wparam, lparam);
   }
   return FALSE;
 }
 
 BOOL DisconnectWindowWin::OnDialogMessage(HWND hwnd,
                                           UINT message,
                                           WPARAM wparam,
                                           LPARAM lparam) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   switch (message) {
     // Ignore close messages.
     case WM_CLOSE:
       return TRUE;
 
     // Handle the Disconnect button.
     case WM_COMMAND:
       switch (LOWORD(wparam)) {
         case IDC_DISCONNECT:
@@ skipping 46 matching lines @@
                   kWindowBorderRadius, kWindowBorderRadius);
       }
       EndPaint(hwnd_, &ps);
       return TRUE;
     }
   }
   return FALSE;
 }
 
 bool DisconnectWindowWin::BeginDialog() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!hwnd_);
 
   hwnd_ =
       CreateDialogParam(CURRENT_MODULE(), MAKEINTRESOURCE(IDD_DISCONNECT),
                         nullptr, DialogProc, reinterpret_cast<LPARAM>(this));
   if (!hwnd_)
     return false;
 
   // Set up handler for Ctrl-Alt-Esc shortcut.
   if (!has_hotkey_ && RegisterHotKey(hwnd_, DISCONNECT_HOTKEY_ID,
                                      MOD_ALT | MOD_CONTROL, VK_ESCAPE)) {
     has_hotkey_ = true;
   }
 
   if (!SetStrings())
     return false;
 
   SetDialogPosition();
   ShowWindow(hwnd_, SW_SHOW);
   return IsWindowVisible(hwnd_) != FALSE;
 }
 
 void DisconnectWindowWin::EndDialog() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (has_hotkey_) {
     UnregisterHotKey(hwnd_, DISCONNECT_HOTKEY_ID);
     has_hotkey_ = false;
   }
 
   if (hwnd_) {
     DestroyWindow(hwnd_);
     hwnd_ = nullptr;
   }
 
   if (client_session_control_)
     client_session_control_->DisconnectSession(protocol::OK);
 }
 
 // Returns |control| rectangle in the dialog coordinates.
 bool DisconnectWindowWin::GetControlRect(HWND control, RECT* rect) {
   if (!GetWindowRect(control, rect))
     return false;
   SetLastError(ERROR_SUCCESS);
   int result = MapWindowPoints(HWND_DESKTOP, hwnd_,
                                reinterpret_cast<LPPOINT>(rect), 2);
   if (!result && GetLastError() != ERROR_SUCCESS)
     return false;
 
   return true;
 }
 
 void DisconnectWindowWin::SetDialogPosition() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // 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, nullptr);
   HMONITOR monitor = MonitorFromWindow(taskbar, MONITOR_DEFAULTTOPRIMARY);
   MONITORINFO monitor_info = {sizeof(monitor_info)};
   RECT window_rect;
   if (GetMonitorInfo(monitor, &monitor_info) &&
       GetWindowRect(hwnd_, &window_rect)) {
     int window_width = window_rect.right - window_rect.left;
     int window_height = window_rect.bottom - window_rect.top;
     int top = monitor_info.rcWork.bottom - window_height;
     int left = (monitor_info.rcWork.right + monitor_info.rcWork.left -
         window_width) / 2;
     SetWindowPos(hwnd_, nullptr, left, top, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
   }
 }
 
 bool DisconnectWindowWin::SetStrings() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Localize the disconnect button text and measure length of the old and new
   // labels.
   HWND hwnd_button = GetDlgItem(hwnd_, IDC_DISCONNECT);
   HWND hwnd_message = GetDlgItem(hwnd_, IDC_DISCONNECT_SHARINGWITH);
   if (!hwnd_button || !hwnd_message)
     return false;
 
   base::string16 button_text;
   base::string16 message_text;
@@ skipping 78 matching lines @@
 }
 
 } // namespace
 
 // static
 std::unique_ptr<HostWindow> HostWindow::CreateDisconnectWindow() {
   return base::MakeUnique<DisconnectWindowWin>();
 }
 
 }  // namespace remoting