replace NULL->nullptr in src/remoting.

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 <windows.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/process/memory.h"
 #include "base/strings/string_util.h"
@@ skipping 88 matching lines @@
   base::win::ScopedSelectObject font(
       dc, (HFONT)SendMessage(control, WM_GETFONT, 0, 0));
   if (!DrawText(dc, text.c_str(), -1, &rect, DT_CALCRECT | DT_SINGLELINE))
     return false;
 
   *width = rect.right;
   return true;
 }
 
 DisconnectWindowWin::DisconnectWindowWin()
-    : hwnd_(NULL),
+    : hwnd_(nullptr),
       has_hotkey_(false),
       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(!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();
 }
 
 INT_PTR CALLBACK DisconnectWindowWin::DialogProc(HWND hwnd,
                                                  UINT message,
                                                  WPARAM wparam,
                                                  LPARAM lparam) {
-  LONG_PTR self = NULL;
+  LONG_PTR self = 0;
   if (message == WM_INITDIALOG) {
     self = lparam;
 
     // Store |this| to the window's user data.
     SetLastError(ERROR_SUCCESS);
     LONG_PTR result = SetWindowLongPtr(hwnd, DWLP_USER, self);
     if (result == 0 && GetLastError() != ERROR_SUCCESS)
       reinterpret_cast<DisconnectWindowWin*>(self)->EndDialog();
   } else {
     self = GetWindowLongPtr(hwnd, DWLP_USER);
@@ skipping 21 matching lines @@
     case WM_COMMAND:
       switch (LOWORD(wparam)) {
         case IDC_DISCONNECT:
           EndDialog();
           return TRUE;
       }
       return FALSE;
 
     // Ensure we don't try to use the HWND anymore.
     case WM_DESTROY:
-      hwnd_ = NULL;
+      hwnd_ = nullptr;
 
       // 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)
@@ skipping 32 matching lines @@
     }
   }
   return FALSE;
 }
 
 bool DisconnectWindowWin::BeginDialog() {
   DCHECK(CalledOnValidThread());
   DCHECK(!hwnd_);
 
   HMODULE module = base::GetModuleFromAddress(&DialogProc);
-  hwnd_ = CreateDialogParam(module, MAKEINTRESOURCE(IDD_DISCONNECT), NULL,
+  hwnd_ = CreateDialogParam(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());
 
   if (has_hotkey_) {
     UnregisterHotKey(hwnd_, DISCONNECT_HOTKEY_ID);
     has_hotkey_ = false;
   }
 
   if (hwnd_) {
     DestroyWindow(hwnd_);
-    hwnd_ = NULL;
+    hwnd_ = nullptr;
   }
 
   if (client_session_control_)
     client_session_control_->DisconnectSession();
 }
 
 // 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());
 
   // 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);
+  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_, NULL, left, top, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
+    SetWindowPos(hwnd_, nullptr, left, top, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
   }
 }
 
 bool DisconnectWindowWin::SetStrings() {
   DCHECK(CalledOnValidThread());
 
   // 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;
   if (!GetControlText(hwnd_button, &button_text) ||
       !GetControlText(hwnd_message, &message_text)) {
     return false;
   }
 
   // Format and truncate "Your desktop is shared with ..." message.
   message_text = ReplaceStringPlaceholders(message_text,
                                            base::UTF8ToUTF16(username_),
-                                           NULL);
+                                           nullptr);
   if (message_text.length() > kMaxSharingWithTextLength)
     message_text.erase(kMaxSharingWithTextLength);
 
   if (!SetWindowText(hwnd_message, message_text.c_str()))
     return false;
 
   // Calculate the margin between controls in pixels.
   RECT rect = {0};
   rect.right = kWindowTextMargin;
   if (!MapDialogRect(hwnd_, &rect))
     return false;
   int margin = rect.right;
 
   // Resize |hwnd_message| so that the text is not clipped.
   RECT message_rect;
   if (!GetControlRect(hwnd_message, &message_rect))
     return false;
 
   LONG control_width;
   if (!GetControlTextWidth(hwnd_message, message_text, &control_width))
     return false;
   message_rect.right = message_rect.left + control_width + margin;
 
-  if (!SetWindowPos(hwnd_message, NULL,
+  if (!SetWindowPos(hwnd_message, nullptr,
                     message_rect.left, message_rect.top,
                     message_rect.right - message_rect.left,
                     message_rect.bottom - message_rect.top,
                     SWP_NOZORDER)) {
     return false;
   }
 
   // Reposition and resize |hwnd_button| as well.
   RECT button_rect;
   if (!GetControlRect(hwnd_button, &button_rect))
     return false;
 
   if (!GetControlTextWidth(hwnd_button, button_text, &control_width))
     return false;
 
   button_rect.left = message_rect.right;
   button_rect.right = button_rect.left + control_width + margin * 2;
-  if (!SetWindowPos(hwnd_button, NULL,
+  if (!SetWindowPos(hwnd_button, nullptr,
                     button_rect.left, button_rect.top,
                     button_rect.right - button_rect.left,
                     button_rect.bottom - button_rect.top,
                     SWP_NOZORDER)) {
     return false;
   }
 
   // Resize the whole window to fit the resized controls.
   RECT window_rect;
   if (!GetWindowRect(hwnd_, &window_rect))
     return false;
   int width = button_rect.right + margin;
   int height = window_rect.bottom - window_rect.top;
-  if (!SetWindowPos(hwnd_, NULL, 0, 0, width, height,
+  if (!SetWindowPos(hwnd_, nullptr, 0, 0, width, height,
                     SWP_NOMOVE | SWP_NOZORDER)) {
     return false;
   }
 
   // Make the corners of the disconnect window rounded.
   HRGN rgn = CreateRoundRectRgn(0, 0, width, height, kWindowBorderRadius,
                                 kWindowBorderRadius);
   if (!rgn)
     return false;
   if (!SetWindowRgn(hwnd_, rgn, TRUE))
     return false;
 
   return true;
 }
 
 } // namespace
 
 // static
 scoped_ptr<HostWindow> HostWindow::CreateDisconnectWindow() {
   return make_scoped_ptr(new DisconnectWindowWin());
 }
 
 }  // namespace remoting