Replace NULL with nullptr in all C++ files.

webrtc/examples/peerconnection/client/linux/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 42 matching lines @@
 
 void OnRowActivatedCallback(GtkTreeView* tree_view, GtkTreePath* path,
                             GtkTreeViewColumn* column, gpointer data) {
   reinterpret_cast<GtkMainWnd*>(data)->OnRowActivated(tree_view, path, column);
 }
 
 gboolean SimulateLastRowActivated(gpointer data) {
   GtkTreeView* tree_view = reinterpret_cast<GtkTreeView*>(data);
   GtkTreeModel* model = gtk_tree_view_get_model(tree_view);
 
-  // "if iter is NULL, then the number of toplevel nodes is returned."
-  int rows = gtk_tree_model_iter_n_children(model, NULL);
+  // "if iter is null, then the number of toplevel nodes is returned."
+  int rows = gtk_tree_model_iter_n_children(model, nullptr);
   GtkTreePath* lastpath = gtk_tree_path_new_from_indices(rows - 1, -1);
 
   // Select the last item in the list
   GtkTreeSelection* selection = gtk_tree_view_get_selection(tree_view);
   gtk_tree_selection_select_path(selection, lastpath);
 
   // Our TreeView only has one column, so it is column 0.
   GtkTreeViewColumn* column = gtk_tree_view_get_column(tree_view, 0);
 
   gtk_tree_view_row_activated(tree_view, lastpath, column);
 
   gtk_tree_path_free(lastpath);
   return false;
 }
 
 // Creates a tree view, that we use to display the list of peers.
 void InitializeList(GtkWidget* list) {
   GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
   GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
-      "List Items", renderer, "text", 0, NULL);
+      "List Items", renderer, "text", 0, nullptr);
   gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
   GtkListStore* store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
   gtk_tree_view_set_model(GTK_TREE_VIEW(list), GTK_TREE_MODEL(store));
   g_object_unref(store);
 }
 
 // Adds an entry to a tree view.
 void AddToList(GtkWidget* list, const gchar* str, int value) {
   GtkListStore* store = GTK_LIST_STORE(
       gtk_tree_view_get_model(GTK_TREE_VIEW(list)));
@@ skipping 29 matching lines @@
   wnd->Draw(widget, cr);
   return false;
 }
 
 }  // namespace
 
 //
 // GtkMainWnd implementation.
 //
 
-GtkMainWnd::GtkMainWnd(const char* server, int port, bool autoconnect,
+GtkMainWnd::GtkMainWnd(const char* server,
+                       int port,
+                       bool autoconnect,
                        bool autocall)
-    : window_(NULL), draw_area_(NULL), vbox_(NULL), server_edit_(NULL),
-      port_edit_(NULL), peer_list_(NULL), callback_(NULL),
-      server_(server), autoconnect_(autoconnect), autocall_(autocall) {
+    : window_(nullptr),
+      draw_area_(nullptr),
+      vbox_(nullptr),
+      server_edit_(nullptr),
+      port_edit_(nullptr),
+      peer_list_(nullptr),
+      callback_(nullptr),
+      server_(server),
+      autoconnect_(autoconnect),
+      autocall_(autocall) {
   char buffer[10];
   sprintfn(buffer, sizeof(buffer), "%i", port);
   port_ = buffer;
 }
 
 GtkMainWnd::~GtkMainWnd() {
   RTC_DCHECK(!IsWindow());
 }
 
 void GtkMainWnd::RegisterObserver(MainWndCallback* callback) {
   callback_ = callback;
 }
 
 bool GtkMainWnd::IsWindow() {
-  return window_ != NULL && GTK_IS_WINDOW(window_);
+  return window_ != nullptr && GTK_IS_WINDOW(window_);
 }
 
 void GtkMainWnd::MessageBox(const char* caption, const char* text,
                             bool is_error) {
   GtkWidget* dialog = gtk_message_dialog_new(GTK_WINDOW(window_),
       GTK_DIALOG_DESTROY_WITH_PARENT,
       is_error ? GTK_MESSAGE_ERROR : GTK_MESSAGE_INFO,
       GTK_BUTTONS_CLOSE, "%s", text);
   gtk_window_set_title(GTK_WINDOW(dialog), caption);
   gtk_dialog_run(GTK_DIALOG(dialog));
@@ skipping 27 matching lines @@
 void GtkMainWnd::StopRemoteRenderer() {
   remote_renderer_.reset();
 }
 
 void GtkMainWnd::QueueUIThreadCallback(int msg_id, void* data) {
   g_idle_add(HandleUIThreadCallback,
              new UIThreadCallbackData(callback_, msg_id, data));
 }
 
 bool GtkMainWnd::Create() {
-  RTC_DCHECK(window_ == NULL);
+  RTC_DCHECK(window_ == nullptr);
 
   window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   if (window_) {
     gtk_window_set_position(GTK_WINDOW(window_), GTK_WIN_POS_CENTER);
     gtk_window_set_default_size(GTK_WINDOW(window_), 640, 480);
     gtk_window_set_title(GTK_WINDOW(window_), "PeerConnection client");
     g_signal_connect(G_OBJECT(window_), "delete-event",
                      G_CALLBACK(&OnDestroyedCallback), this);
     g_signal_connect(window_, "key-press-event", G_CALLBACK(OnKeyPressCallback),
                      this);
 
     SwitchToConnectUI();
   }
 
-  return window_ != NULL;
+  return window_ != nullptr;
 }
 
 bool GtkMainWnd::Destroy() {
   if (!IsWindow())
     return false;
 
   gtk_widget_destroy(window_);
-  window_ = NULL;
+  window_ = nullptr;
 
   return true;
 }
 
 void GtkMainWnd::SwitchToConnectUI() {
   LOG(INFO) << __FUNCTION__;
 
   RTC_DCHECK(IsWindow());
-  RTC_DCHECK(vbox_ == NULL);
+  RTC_DCHECK(vbox_ == nullptr);
 
   gtk_container_set_border_width(GTK_CONTAINER(window_), 10);
 
   if (peer_list_) {
     gtk_widget_destroy(peer_list_);
-    peer_list_ = NULL;
+    peer_list_ = nullptr;
   }
 
 #if GTK_MAJOR_VERSION == 2
   vbox_ = gtk_vbox_new(FALSE, 5);
 #else
   vbox_ = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
 #endif
   GtkWidget* valign = gtk_alignment_new(0, 1, 0, 0);
   gtk_container_add(GTK_CONTAINER(vbox_), valign);
   gtk_container_add(GTK_CONTAINER(window_), vbox_);
@@ skipping 32 matching lines @@
     g_idle_add(SimulateButtonClick, button);
 }
 
 void GtkMainWnd::SwitchToPeerList(const Peers& peers) {
   LOG(INFO) << __FUNCTION__;
 
   if (!peer_list_) {
     gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
     if (vbox_) {
       gtk_widget_destroy(vbox_);
-      vbox_ = NULL;
-      server_edit_ = NULL;
-      port_edit_ = NULL;
+      vbox_ = nullptr;
+      server_edit_ = nullptr;
+      port_edit_ = nullptr;
     } else if (draw_area_) {
       gtk_widget_destroy(draw_area_);
-      draw_area_ = NULL;
+      draw_area_ = nullptr;
       draw_buffer_.reset();
     }
 
     peer_list_ = gtk_tree_view_new();
     g_signal_connect(peer_list_, "row-activated",
                      G_CALLBACK(OnRowActivatedCallback), this);
     gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(peer_list_), FALSE);
     InitializeList(peer_list_);
     gtk_container_add(GTK_CONTAINER(window_), peer_list_);
     gtk_widget_show_all(window_);
   } else {
     GtkListStore* store =
         GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(peer_list_)));
     gtk_list_store_clear(store);
   }
 
   AddToList(peer_list_, "List of currently connected peers:", -1);
   for (Peers::const_iterator i = peers.begin(); i != peers.end(); ++i)
     AddToList(peer_list_, i->second.c_str(), i->first);
 
   if (autocall_ && peers.begin() != peers.end())
     g_idle_add(SimulateLastRowActivated, peer_list_);
 }
 
 void GtkMainWnd::SwitchToStreamingUI() {
   LOG(INFO) << __FUNCTION__;
 
-  RTC_DCHECK(draw_area_ == NULL);
+  RTC_DCHECK(draw_area_ == nullptr);
 
   gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
   if (peer_list_) {
     gtk_widget_destroy(peer_list_);
-    peer_list_ = NULL;
+    peer_list_ = nullptr;
   }
 
   draw_area_ = gtk_drawing_area_new();
   gtk_container_add(GTK_CONTAINER(window_), draw_area_);
   g_signal_connect(G_OBJECT(draw_area_), "draw", G_CALLBACK(&::Draw), this);
 
   gtk_widget_show_all(window_);
 }
 
 void GtkMainWnd::OnDestroyed(GtkWidget* widget, GdkEvent* event) {
   callback_->Close();
-  window_ = NULL;
-  draw_area_ = NULL;
-  vbox_ = NULL;
-  server_edit_ = NULL;
-  port_edit_ = NULL;
-  peer_list_ = NULL;
+  window_ = nullptr;
+  draw_area_ = nullptr;
+  vbox_ = nullptr;
+  server_edit_ = nullptr;
+  port_edit_ = nullptr;
+  peer_list_ = nullptr;
 }
 
 void GtkMainWnd::OnClicked(GtkWidget* widget) {
   // Make the connect button insensitive, so that it cannot be clicked more than
   // once.  Now that the connection includes auto-retry, it should not be
   // necessary to click it more than once.
   gtk_widget_set_sensitive(widget, false);
   server_ = gtk_entry_get_text(GTK_ENTRY(server_edit_));
   port_ = gtk_entry_get_text(GTK_ENTRY(port_edit_));
   int port = port_.length() ? atoi(port_.c_str()) : 0;
@@ skipping 16 matching lines @@
         break;
 
 #if GTK_MAJOR_VERSION == 2
       case GDK_KP_Enter:
       case GDK_Return:
 #else
       case GDK_KEY_KP_Enter:
       case GDK_KEY_Return:
 #endif
         if (vbox_) {
-          OnClicked(NULL);
+          OnClicked(nullptr);
         } else if (peer_list_) {
           // OnRowActivated will be called automatically when the user
           // presses enter.
         }
         break;
 
       default:
         break;
     }
   }
 }
 
 void GtkMainWnd::OnRowActivated(GtkTreeView* tree_view, GtkTreePath* path,
                                 GtkTreeViewColumn* column) {
-  RTC_DCHECK(peer_list_ != NULL);
+  RTC_DCHECK(peer_list_ != nullptr);
   GtkTreeIter iter;
   GtkTreeModel* model;
   GtkTreeSelection* selection =
       gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
   if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
      char* text;
      int id = -1;
      gtk_tree_model_get(model, &iter, 0, &text, 1, &id,  -1);
      if (id != -1)
        callback_->ConnectToPeer(id);
      g_free(text);
   }
 }
 
 void GtkMainWnd::OnRedraw() {
   gdk_threads_enter();
 
   VideoRenderer* remote_renderer = remote_renderer_.get();
-  if (remote_renderer && remote_renderer->image() != NULL &&
-      draw_area_ != NULL) {
+  if (remote_renderer && remote_renderer->image() != nullptr &&
+      draw_area_ != nullptr) {
     width_ = remote_renderer->width();
     height_ = remote_renderer->height();
 
     if (!draw_buffer_.get()) {
       draw_buffer_size_ = (width_ * height_ * 4) * 4;
       draw_buffer_.reset(new uint8_t[draw_buffer_size_]);
       gtk_widget_set_size_request(draw_area_, width_ * 2, height_ * 2);
     }
 
     const uint32_t* image =
@@ skipping 109 matching lines @@
   libyuv::I420ToABGR(buffer->DataY(), buffer->StrideY(),
                      buffer->DataU(), buffer->StrideU(),
                      buffer->DataV(), buffer->StrideV(),
                      image_.get(), width_ * 4,
                      buffer->width(), buffer->height());
 
   gdk_threads_leave();
 
   g_idle_add(Redraw, main_wnd_);
 }