Replace NULL with nullptr in all C++ files.

webrtc/examples/peerconnection/server/peer_channel.cc

 /*
  *  Copyright 2011 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 37 matching lines @@
 
 const size_t kMaxNameLength = 512;
 
 //
 // ChannelMember
 //
 
 int ChannelMember::s_member_id_ = 0;
 
 ChannelMember::ChannelMember(DataSocket* socket)
-  : waiting_socket_(NULL), id_(++s_member_id_),
-    connected_(true), timestamp_(time(NULL)) {
+    : waiting_socket_(nullptr),
+      id_(++s_member_id_),
+      connected_(true),
+      timestamp_(time(nullptr)) {
   assert(socket);
   assert(socket->method() == DataSocket::GET);
   assert(socket->PathEquals("/sign_in"));
   name_ = rtc::s_url_decode(socket->request_arguments());
   if (name_.empty())
     name_ = "peer_" + int2str(id_);
   else if (name_.length() > kMaxNameLength)
     name_.resize(kMaxNameLength);
 
   std::replace(name_.begin(), name_.end(), ',', '_');
 }
 
 ChannelMember::~ChannelMember() {
 }
 
 bool ChannelMember::is_wait_request(DataSocket* ds) const {
   return ds && ds->PathEquals(kRequestPaths[kWait]);
 }
 
 bool ChannelMember::TimedOut() {
-  return waiting_socket_ == NULL && (time(NULL) - timestamp_) > 30;
+  return waiting_socket_ == nullptr && (time(nullptr) - timestamp_) > 30;
 }
 
 std::string ChannelMember::GetPeerIdHeader() const {
   std::string ret(kPeerIdHeader + int2str(id_) + "\r\n");
   return ret;
 }
 
 bool ChannelMember::NotifyOfOtherMember(const ChannelMember& other) {
   assert(&other != this);
   QueueResponse("200 OK", "text/plain", GetPeerIdHeader(),
@@ skipping 25 matching lines @@
     printf("Client %s sending to %s\n",
         name_.c_str(), peer->name().c_str());
     peer->QueueResponse("200 OK", ds->content_type(), extra_headers,
                         ds->data());
     ds->Send("200 OK", true, "text/plain", "", "");
   }
 }
 
 void ChannelMember::OnClosing(DataSocket* ds) {
   if (ds == waiting_socket_) {
-    waiting_socket_ = NULL;
-    timestamp_ = time(NULL);
+    waiting_socket_ = nullptr;
+    timestamp_ = time(nullptr);
   }
 }
 
 void ChannelMember::QueueResponse(const std::string& status,
                                   const std::string& content_type,
                                   const std::string& extra_headers,
                                   const std::string& data) {
   if (waiting_socket_) {
     assert(queue_.size() == 0);
     assert(waiting_socket_->method() == DataSocket::GET);
     bool ok = waiting_socket_->Send(status, true, content_type, extra_headers,
                                     data);
     if (!ok) {
       printf("Failed to deliver data to waiting socket\n");
     }
-    waiting_socket_ = NULL;
-    timestamp_ = time(NULL);
+    waiting_socket_ = nullptr;
+    timestamp_ = time(nullptr);
   } else {
     QueuedResponse qr;
     qr.status = status;
     qr.content_type = content_type;
     qr.extra_headers = extra_headers;
     qr.data = data;
     queue_.push(qr);
   }
 }
 
 void ChannelMember::SetWaitingSocket(DataSocket* ds) {
   assert(ds->method() == DataSocket::GET);
   if (ds && !queue_.empty()) {
-    assert(waiting_socket_ == NULL);
+    assert(waiting_socket_ == nullptr);
     const QueuedResponse& response = queue_.front();
     ds->Send(response.status, true, response.content_type,
              response.extra_headers, response.data);
     queue_.pop();
   } else {
     waiting_socket_ = ds;
   }
 }
 
 //
 // PeerChannel
 //
 
 // static
 bool PeerChannel::IsPeerConnection(const DataSocket* ds) {
   assert(ds);
   return (ds->method() == DataSocket::POST && ds->content_length() > 0) ||
          (ds->method() == DataSocket::GET && ds->PathEquals("/sign_in"));
 }
 
 ChannelMember* PeerChannel::Lookup(DataSocket* ds) const {
   assert(ds);
 
   if (ds->method() != DataSocket::GET && ds->method() != DataSocket::POST)
-    return NULL;
+    return nullptr;
 
   size_t i = 0;
   for (; i < ARRAYSIZE(kRequestPaths); ++i) {
     if (ds->PathEquals(kRequestPaths[i]))
       break;
   }
 
   if (i == ARRAYSIZE(kRequestPaths))
-    return NULL;
+    return nullptr;
 
   std::string args(ds->request_arguments());
   static const char kPeerId[] = "peer_id=";
   size_t found = args.find(kPeerId);
   if (found == std::string::npos)
-    return NULL;
+    return nullptr;
 
   int id = atoi(&args[found + ARRAYSIZE(kPeerId) - 1]);
   Members::const_iterator iter = members_.begin();
   for (; iter != members_.end(); ++iter) {
     if (id == (*iter)->id()) {
       if (i == kWait)
         (*iter)->SetWaitingSocket(ds);
       if (i == kSignOut)
         (*iter)->set_disconnected();
       return *iter;
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 ChannelMember* PeerChannel::IsTargetedRequest(const DataSocket* ds) const {
   assert(ds);
   // Regardless of GET or POST, we look for the peer_id parameter
   // only in the request_path.
   const std::string& path = ds->request_path();
   size_t args = path.find('?');
   if (args == std::string::npos)
-    return NULL;
+    return nullptr;
   size_t found;
   const char kTargetPeerIdParam[] = "to=";
   do {
     found = path.find(kTargetPeerIdParam, args);
     if (found == std::string::npos)
-      return NULL;
+      return nullptr;
     if (found == (args + 1) || path[found - 1] == '&') {
       found += ARRAYSIZE(kTargetPeerIdParam) - 1;
       break;
     }
     args = found + ARRAYSIZE(kTargetPeerIdParam) - 1;
   } while (true);
   int id = atoi(&path[found]);
   Members::const_iterator i = members_.begin();
   for (; i != members_.end(); ++i) {
     if ((*i)->id() == id) {
       return *i;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 bool PeerChannel::AddMember(DataSocket* ds) {
   assert(IsPeerConnection(ds));
   ChannelMember* new_guy = new ChannelMember(ds);
   Members failures;
   BroadcastChangedState(*new_guy, &failures);
   HandleDeliveryFailures(&failures);
   members_.push_back(new_guy);
 
@@ skipping 102 matching lines @@
   std::string response(member.GetEntry());
   for (Members::iterator i = members_.begin(); i != members_.end(); ++i) {
     if (member.id() != (*i)->id()) {
       assert((*i)->connected());
       response += (*i)->GetEntry();
     }
   }
 
   return response;
 }