Replace NULL with nullptr in all C++ files.

webrtc/examples/peerconnection/client/main_wnd.cc

 /*
  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 49 matching lines @@
 }
 
 void AddListBoxItem(HWND listbox, const std::string& str, LPARAM item_data) {
   LRESULT index = ::SendMessageA(listbox, LB_ADDSTRING, 0,
       reinterpret_cast<LPARAM>(str.c_str()));
   ::SendMessageA(listbox, LB_SETITEMDATA, index, item_data);
 }
 
 }  // namespace
 
-MainWnd::MainWnd(const char* server, int port, bool auto_connect,
+MainWnd::MainWnd(const char* server,
+                 int port,
+                 bool auto_connect,
                  bool auto_call)
-  : ui_(CONNECT_TO_SERVER), wnd_(NULL), edit1_(NULL), edit2_(NULL),
-    label1_(NULL), label2_(NULL), button_(NULL), listbox_(NULL),
-    destroyed_(false), callback_(NULL), nested_msg_(NULL),
-    server_(server), auto_connect_(auto_connect), auto_call_(auto_call) {
+    : ui_(CONNECT_TO_SERVER),
+      wnd_(nullptr),
+      edit1_(nullptr),
+      edit2_(nullptr),
+      label1_(nullptr),
+      label2_(nullptr),
+      button_(nullptr),
+      listbox_(nullptr),
+      destroyed_(false),
+      callback_(nullptr),
+      nested_msg_(nullptr),
+      server_(server),
+      auto_connect_(auto_connect),
+      auto_call_(auto_call) {
   char buffer[10] = {0};
   sprintfn(buffer, sizeof(buffer), "%i", port);
   port_ = buffer;
 }
 
 MainWnd::~MainWnd() {
   RTC_DCHECK(!IsWindow());
 }
 
 bool MainWnd::Create() {
-  RTC_DCHECK(wnd_ == NULL);
+  RTC_DCHECK(wnd_ == nullptr);
   if (!RegisterWindowClass())
     return false;
 
   ui_thread_id_ = ::GetCurrentThreadId();
   wnd_ = ::CreateWindowExW(WS_EX_OVERLAPPEDWINDOW, kClassName, L"WebRTC",
-      WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN,
-      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
-      NULL, NULL, GetModuleHandle(NULL), this);
+                           WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN,
+                           CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+                           CW_USEDEFAULT, nullptr, nullptr,
+                           GetModuleHandle(nullptr), this);
 
   ::SendMessage(wnd_, WM_SETFONT, reinterpret_cast<WPARAM>(GetDefaultFont()),
                 TRUE);
 
   CreateChildWindows();
   SwitchToConnectUI();
 
-  return wnd_ != NULL;
+  return wnd_ != nullptr;
 }
 
 bool MainWnd::Destroy() {
   BOOL ret = FALSE;
   if (IsWindow()) {
     ret = ::DestroyWindow(wnd_);
   }
 
   return ret != FALSE;
 }
@@ skipping 17 matching lines @@
       ret = true;
     } else if (msg->wParam == VK_ESCAPE) {
       if (callback_) {
         if (ui_ == STREAMING) {
           callback_->DisconnectFromCurrentPeer();
         } else {
           callback_->DisconnectFromServer();
         }
       }
     }
-  } else if (msg->hwnd == NULL && msg->message == UI_THREAD_CALLBACK) {
+  } else if (msg->hwnd == nullptr && msg->message == UI_THREAD_CALLBACK) {
     callback_->UIThreadCallback(static_cast<int>(msg->wParam),
                                 reinterpret_cast<void*>(msg->lParam));
     ret = true;
   }
   return ret;
 }
 
 void MainWnd::SwitchToConnectUI() {
   RTC_DCHECK(IsWindow());
   LayoutPeerListUI(false);
@@ skipping 80 matching lines @@
   VideoRenderer* remote_renderer = remote_renderer_.get();
   if (ui_ == STREAMING && remote_renderer && local_renderer) {
     AutoLock<VideoRenderer> local_lock(local_renderer);
     AutoLock<VideoRenderer> remote_lock(remote_renderer);
 
     const BITMAPINFO& bmi = remote_renderer->bmi();
     int height = abs(bmi.bmiHeader.biHeight);
     int width = bmi.bmiHeader.biWidth;
 
     const uint8_t* image = remote_renderer->image();
-    if (image != NULL) {
+    if (image != nullptr) {
       HDC dc_mem = ::CreateCompatibleDC(ps.hdc);
       ::SetStretchBltMode(dc_mem, HALFTONE);
 
       // Set the map mode so that the ratio will be maintained for us.
       HDC all_dc[] = { ps.hdc, dc_mem };
       for (int i = 0; i < arraysize(all_dc); ++i) {
         SetMapMode(all_dc[i], MM_ISOTROPIC);
-        SetWindowExtEx(all_dc[i], width, height, NULL);
-        SetViewportExtEx(all_dc[i], rc.right, rc.bottom, NULL);
+        SetWindowExtEx(all_dc[i], width, height, nullptr);
+        SetViewportExtEx(all_dc[i], rc.right, rc.bottom, nullptr);
       }
 
       HBITMAP bmp_mem = ::CreateCompatibleBitmap(ps.hdc, rc.right, rc.bottom);
       HGDIOBJ bmp_old = ::SelectObject(dc_mem, bmp_mem);
 
       POINT logical_area = { rc.right, rc.bottom };
       DPtoLP(ps.hdc, &logical_area, 1);
 
       HBRUSH brush = ::CreateSolidBrush(RGB(0, 0, 0));
       RECT logical_rect = {0, 0, logical_area.x, logical_area.y };
@@ skipping 145 matching lines @@
     void* prev_nested_msg = me->nested_msg_;
     me->nested_msg_ = &msg;
 
     bool handled = me->OnMessage(msg, wp, lp, &result);
     if (WM_NCDESTROY == msg) {
       me->destroyed_ = true;
     } else if (!handled) {
       result = ::DefWindowProc(hwnd, msg, wp, lp);
     }
 
-    if (me->destroyed_ && prev_nested_msg == NULL) {
+    if (me->destroyed_ && prev_nested_msg == nullptr) {
       me->OnDestroyed();
-      me->wnd_ = NULL;
+      me->wnd_ = nullptr;
       me->destroyed_ = false;
     }
 
     me->nested_msg_ = prev_nested_msg;
   } else {
     result = ::DefWindowProc(hwnd, msg, wp, lp);
   }
 
   return result;
 }
 
 // static
 bool MainWnd::RegisterWindowClass() {
   if (wnd_class_)
     return true;
 
   WNDCLASSEX wcex = { sizeof(WNDCLASSEX) };
   wcex.style = CS_DBLCLKS;
-  wcex.hInstance = GetModuleHandle(NULL);
+  wcex.hInstance = GetModuleHandle(nullptr);
   wcex.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);
-  wcex.hCursor = ::LoadCursor(NULL, IDC_ARROW);
+  wcex.hCursor = ::LoadCursor(nullptr, IDC_ARROW);
   wcex.lpfnWndProc = &WndProc;
   wcex.lpszClassName = kClassName;
   wnd_class_ = ::RegisterClassEx(&wcex);
   RTC_DCHECK(wnd_class_ != 0);
   return wnd_class_ != 0;
 }
 
 void MainWnd::CreateChildWindow(HWND* wnd, MainWnd::ChildWindowID id,
                                 const wchar_t* class_name, DWORD control_style,
                                 DWORD ex_style) {
   if (::IsWindow(*wnd))
     return;
 
   // Child windows are invisible at first, and shown after being resized.
   DWORD style = WS_CHILD | control_style;
-  *wnd = ::CreateWindowEx(ex_style, class_name, L"", style,
-                          100, 100, 100, 100, wnd_,
-                          reinterpret_cast<HMENU>(id),
-                          GetModuleHandle(NULL), NULL);
+  *wnd = ::CreateWindowEx(ex_style, class_name, L"", style, 100, 100, 100, 100,
+                          wnd_, reinterpret_cast<HMENU>(id),
+                          GetModuleHandle(nullptr), nullptr);
   RTC_DCHECK(::IsWindow(*wnd) != FALSE);
   ::SendMessage(*wnd, WM_SETFONT, reinterpret_cast<WPARAM>(GetDefaultFont()),
                 TRUE);
 }
 
 void MainWnd::CreateChildWindows() {
   // Create the child windows in tab order.
   CreateChildWindow(&label1_, LABEL1_ID, L"Static", ES_CENTER | ES_READONLY, 0);
   CreateChildWindow(&edit1_, EDIT_ID, L"Edit",
                     ES_LEFT | ES_NOHIDESEL | WS_TABSTOP, WS_EX_CLIENTEDGE);
@@ skipping 56 matching lines @@
 }
 
 void MainWnd::LayoutPeerListUI(bool show) {
   if (show) {
     RECT rc;
     ::GetClientRect(wnd_, &rc);
     ::MoveWindow(listbox_, 0, 0, rc.right, rc.bottom, TRUE);
     ::ShowWindow(listbox_, SW_SHOWNA);
   } else {
     ::ShowWindow(listbox_, SW_HIDE);
-    InvalidateRect(wnd_, NULL, TRUE);
+    InvalidateRect(wnd_, nullptr, TRUE);
   }
 }
 
 void MainWnd::HandleTabbing() {
   bool shift = ((::GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0);
   UINT next_cmd = shift ? GW_HWNDPREV : GW_HWNDNEXT;
   UINT loop_around_cmd = shift ? GW_HWNDLAST : GW_HWNDFIRST;
   HWND focus = GetFocus(), next;
   do {
     next = ::GetWindow(focus, next_cmd);
@@ skipping 61 matching lines @@
     AutoLock<VideoRenderer> lock(this);
 
     rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer(
         video_frame.video_frame_buffer());
     if (video_frame.rotation() != webrtc::kVideoRotation_0) {
       buffer = webrtc::I420Buffer::Rotate(*buffer, video_frame.rotation());
     }
 
     SetSize(buffer->width(), buffer->height());
 
-    RTC_DCHECK(image_.get() != NULL);
+    RTC_DCHECK(image_.get() != nullptr);
     libyuv::I420ToARGB(buffer->DataY(), buffer->StrideY(),
                        buffer->DataU(), buffer->StrideU(),
                        buffer->DataV(), buffer->StrideV(),
                        image_.get(),
                        bmi_.bmiHeader.biWidth *
                            bmi_.bmiHeader.biBitCount / 8,
                        buffer->width(), buffer->height());
   }
-  InvalidateRect(wnd_, NULL, TRUE);
+  InvalidateRect(wnd_, nullptr, TRUE);
 }