replace NULL->nullptr in src/remoting.

remoting/host/win/rdp_client_window.cc

 // Copyright (c) 2013 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/win/rdp_client_window.h"
 
 #include <wtsdefs.h>
 
 #include <list>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_local.h"
 #include "base/win/scoped_bstr.h"
 
 namespace remoting {
 
 namespace {
 
 // RDP connection disconnect reasons codes that should not be interpreted as
 // errors.
 const long kDisconnectReasonNoInfo = 0;
 const long kDisconnectReasonLocalNotError = 1;
 const long kDisconnectReasonRemoteByUser = 2;
 const long kDisconnectReasonByServer = 3;
 
-// Maximum length of a window class name including the terminating NULL.
+// Maximum length of a window class name including the terminating nullptr.
 const int kMaxWindowClassLength = 256;
 
 // Each member of the array returned by GetKeyboardState() contains status data
 // for a virtual key. If the high-order bit is 1, the key is down; otherwise, it
 // is up.
 const BYTE kKeyPressedFlag = 0x80;
 
 const int kKeyboardStateLength = 256;
 
 // The RDP control creates 'IHWindowClass' window to handle keyboard input.
@@ skipping 10 matching lines @@
   // Disable sound redirection; do not play sounds at the remote computer.
   kRdpAudioModeNone = 2
 };
 
 // Points to a per-thread instance of the window activation hook handle.
 base::LazyInstance<base::ThreadLocalPointer<RdpClientWindow::WindowHook> >
     g_window_hook = LAZY_INSTANCE_INITIALIZER;
 
 // Finds a child window with the class name matching |class_name|. Unlike
 // FindWindowEx() this function walks the tree of windows recursively. The walk
-// is done in breadth-first order. The function returns NULL if the child window
-// could not be found.
+// is done in breadth-first order. The function returns nullptr if the child
+// window could not be found.
 HWND FindWindowRecursively(HWND parent, const base::string16& class_name) {
   std::list<HWND> windows;
   windows.push_back(parent);
 
   while (!windows.empty()) {
-    HWND child = FindWindowEx(windows.front(), NULL, NULL, NULL);
-    while (child != NULL) {
+    HWND child = FindWindowEx(windows.front(), nullptr, nullptr, nullptr);
+    while (child != nullptr) {
       // See if the window class name matches |class_name|.
       WCHAR name[kMaxWindowClassLength];
       int length = GetClassName(child, name, arraysize(name));
       if (base::string16(name, length)  == class_name)
         return child;
 
       // Remember the window to look through its children.
       windows.push_back(child);
 
       // Go to the next child.
-      child = FindWindowEx(windows.front(), child, NULL, NULL);
+      child = FindWindowEx(windows.front(), child, nullptr, nullptr);
     }
 
     windows.pop_front();
   }
 
-  return NULL;
+  return nullptr;
 }
 
 }  // namespace
 
 // Used to close any windows activated on a particular thread. It installs
 // a WH_CBT window hook to track window activations and close all activated
 // windows. There should be only one instance of |WindowHook| per thread
 // at any given moment.
 class RdpClientWindow::WindowHook
     : public base::RefCounted<WindowHook> {
@@ skipping 28 matching lines @@
 
   DCHECK(!client_.get());
   DCHECK(!client_settings_.get());
 }
 
 bool RdpClientWindow::Connect(const webrtc::DesktopSize& screen_size) {
   DCHECK(!m_hWnd);
 
   screen_size_ = screen_size;
   RECT rect = { 0, 0, screen_size_.width(), screen_size_.height() };
-  bool result = Create(NULL, rect, NULL) != NULL;
+  bool result = Create(nullptr, rect, nullptr) != nullptr;
 
   // Hide the window since this class is about establishing a connection, not
   // about showing a UI to the user.
   if (result)
     ShowWindow(SW_HIDE);
 
   return result;
 }
 
 void RdpClientWindow::Disconnect() {
@@ skipping 93 matching lines @@
   base::win::ScopedComPtr<IUnknown> control;
   HRESULT result = E_FAIL;
   base::win::ScopedComPtr<mstsc::IMsTscSecuredSettings> secured_settings;
   base::win::ScopedComPtr<mstsc::IMsRdpClientSecuredSettings> secured_settings2;
   base::win::ScopedBstr server_name(
       base::UTF8ToUTF16(server_endpoint_.ToStringWithoutPort()).c_str());
   base::win::ScopedBstr terminal_id(base::UTF8ToUTF16(terminal_id_).c_str());
 
   // Create the child window that actually hosts the ActiveX control.
   RECT rect = { 0, 0, screen_size_.width(), screen_size_.height() };
-  activex_window.Create(m_hWnd, rect, NULL, WS_CHILD | WS_VISIBLE | WS_BORDER);
-  if (activex_window.m_hWnd == NULL) {
+  activex_window.Create(m_hWnd, rect, nullptr,
+                        WS_CHILD | WS_VISIBLE | WS_BORDER);
+  if (activex_window.m_hWnd == nullptr) {
     result = HRESULT_FROM_WIN32(GetLastError());
     goto done;
   }
 
   // Instantiate the RDP ActiveX control.
   result = activex_window.CreateControlEx(
       OLESTR("MsTscAx.MsTscAx"),
-      NULL,
-      NULL,
+      nullptr,
+      nullptr,
       control.Receive(),
       __uuidof(mstsc::IMsTscAxEvents),
       reinterpret_cast<IUnknown*>(static_cast<RdpEventsSink*>(this)));
   if (FAILED(result))
     goto done;
 
   result = control.QueryInterface(client_.Receive());
   if (FAILED(result))
     goto done;
 
@@ skipping 123 matching lines @@
   // Hook window activation to cancel any modal UI shown by the RDP control.
   // This does not affect creation of other instances of the RDP control on this
   // thread because the RDP control's window is hidden and is not activated.
   window_activate_hook_ = WindowHook::Create();
   return S_OK;
 }
 
 HRESULT RdpClientWindow::OnAuthenticationWarningDismissed() {
   LOG(WARNING) << "RDP: authentication warning has been dismissed.";
 
-  window_activate_hook_ = NULL;
+  window_activate_hook_ = nullptr;
   return S_OK;
 }
 
 HRESULT RdpClientWindow::OnConnected() {
   VLOG(1) << "RDP: successfully connected to " << server_endpoint_.ToString();
 
   NotifyConnected();
   return S_OK;
 }
 
@@ skipping 49 matching lines @@
 }
 
 void RdpClientWindow::NotifyConnected() {
   if (event_handler_)
     event_handler_->OnConnected();
 }
 
 void RdpClientWindow::NotifyDisconnected() {
   if (event_handler_) {
     EventHandler* event_handler = event_handler_;
-    event_handler_ = NULL;
+    event_handler_ = nullptr;
     event_handler->OnDisconnected();
   }
 }
 
 scoped_refptr<RdpClientWindow::WindowHook>
 RdpClientWindow::WindowHook::Create() {
   scoped_refptr<WindowHook> window_hook = g_window_hook.Pointer()->Get();
 
   if (!window_hook.get())
     window_hook = new WindowHook();
 
   return window_hook;
 }
 
-RdpClientWindow::WindowHook::WindowHook() : hook_(NULL) {
+RdpClientWindow::WindowHook::WindowHook() : hook_(nullptr) {
   DCHECK(!g_window_hook.Pointer()->Get());
 
   // Install a window hook to be called on window activation.
   hook_ = SetWindowsHookEx(WH_CBT,
                            &WindowHook::CloseWindowOnActivation,
-                           NULL,
+                           nullptr,
                            GetCurrentThreadId());
   // Without the hook installed, RdpClientWindow will not be able to cancel
   // modal UI windows. This will block the UI message loop so it is better to
   // terminate the process now.
   CHECK(hook_);
 
   // Let CloseWindowOnActivation() to access the hook handle.
   g_window_hook.Pointer()->Set(this);
 }
 
 RdpClientWindow::WindowHook::~WindowHook() {
   DCHECK(g_window_hook.Pointer()->Get() == this);
 
-  g_window_hook.Pointer()->Set(NULL);
+  g_window_hook.Pointer()->Set(nullptr);
 
   BOOL result = UnhookWindowsHookEx(hook_);
   DCHECK(result);
 }
 
 // static
 LRESULT CALLBACK RdpClientWindow::WindowHook::CloseWindowOnActivation(
     int code, WPARAM wparam, LPARAM lparam) {
   // Get the hook handle.
   HHOOK hook = g_window_hook.Pointer()->Get()->hook_;
 
   if (code != HCBT_ACTIVATE)
     return CallNextHookEx(hook, code, wparam, lparam);
 
   // Close the window once all pending window messages are processed.
   HWND window = reinterpret_cast<HWND>(wparam);
   LOG(WARNING) << "RDP: closing a window: " << std::hex << window << std::dec;
   ::PostMessage(window, WM_CLOSE, 0, 0);
   return 0;
 }
 
 }  // namespace remoting