replace NULL->nullptr in src/remoting.

remoting/protocol/jingle_messages.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 "remoting/protocol/jingle_messages.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/content_description.h"
@@ skipping 108 matching lines @@
     const std::string& name,
     const cricket::Candidate& candidate)
     : name(name),
       candidate(candidate) {
 }
 
 // static
 bool JingleMessage::IsJingleMessage(const buzz::XmlElement* stanza) {
   return stanza->Name() == QName(kJabberNamespace, "iq") &&
          stanza->Attr(QName(std::string(), "type")) == "set" &&
-         stanza->FirstNamed(QName(kJingleNamespace, "jingle")) != NULL;
+         stanza->FirstNamed(QName(kJingleNamespace, "jingle")) != nullptr;
 }
 
 // static
 std::string JingleMessage::GetActionName(ActionType action) {
   return ValueToName(kActionTypes, action);
 }
 
 JingleMessage::JingleMessage()
     : action(UNKNOWN_ACTION),
       reason(UNKNOWN_REASON) {
@@ skipping 47 matching lines @@
   }
 
   if (action == SESSION_INFO) {
     // session-info messages may contain arbitrary information not
     // defined by the Jingle protocol. We don't need to parse it.
     const XmlElement* child = jingle_tag->FirstElement();
     if (child) {
       // session-info is allowed to be empty.
       info.reset(new XmlElement(*child));
     } else {
-      info.reset(NULL);
+      info.reset(nullptr);
     }
     return true;
   }
 
   const XmlElement* reason_tag =
       jingle_tag->FirstNamed(QName(kJingleNamespace, "reason"));
   if (reason_tag && reason_tag->FirstElement()) {
     if (!NameToValue(kReasons, reason_tag->FirstElement()->Name().LocalPart(),
                      &reason)) {
       reason = UNKNOWN_REASON;
     }
   }
 
   if (action == SESSION_TERMINATE)
     return true;
 
   const XmlElement* content_tag =
       jingle_tag->FirstNamed(QName(kJingleNamespace, "content"));
   if (!content_tag) {
     *error = "content tag is missing";
     return false;
   }
 
   std::string content_name = content_tag->Attr(QName(kEmptyNamespace, "name"));
   if (content_name != ContentDescription::kChromotingContentName) {
     *error = "Unexpected content name: " + content_name;
     return false;
   }
 
-  description.reset(NULL);
+  description.reset(nullptr);
   if (action == SESSION_INITIATE || action == SESSION_ACCEPT) {
     const XmlElement* description_tag = content_tag->FirstNamed(
         QName(kChromotingXmlNamespace, "description"));
     if (!description_tag) {
       *error = "Missing chromoting content description";
       return false;
     }
 
     description = ContentDescription::ParseXml(description_tag);
     if (!description.get()) {
       *error = "Failed to parse content description";
       return false;
     }
   }
 
   candidates.clear();
   const XmlElement* transport_tag = content_tag->FirstNamed(
       QName(kP2PTransportNamespace, "transport"));
   if (transport_tag) {
     QName qn_candidate(kP2PTransportNamespace, "candidate");
     for (const XmlElement* candidate_tag =
              transport_tag->FirstNamed(qn_candidate);
-         candidate_tag != NULL;
+         candidate_tag != nullptr;
          candidate_tag = candidate_tag->NextNamed(qn_candidate)) {
       NamedCandidate candidate;
       if (!ParseCandidate(candidate_tag, &candidate)) {
         *error = "Failed to parse candidates";
         return false;
       }
       candidates.push_back(candidate);
     }
   }
 
@@ skipping 95 matching lines @@
   if (type == REPLY_RESULT) {
     iq->SetAttr(QName(kEmptyNamespace, "type"), "result");
     return iq.Pass();
   }
 
   DCHECK_EQ(type, REPLY_ERROR);
 
   iq->SetAttr(QName(kEmptyNamespace, "type"), "error");
 
   for (const buzz::XmlElement* child = request_stanza->FirstElement();
-       child != NULL; child = child->NextElement()) {
+       child != nullptr; child = child->NextElement()) {
     iq->AddElement(new buzz::XmlElement(*child));
   }
 
   buzz::XmlElement* error =
       new buzz::XmlElement(QName(kJabberNamespace, "error"));
   iq->AddElement(error);
 
   std::string type;
   std::string error_text;
   QName name;
@@ skipping 44 matching lines @@
     text_elem->SetAttr(QName(kXmlNamespace, "lang"), "en");
     text_elem->SetBodyText(error_text);
     error->AddElement(text_elem);
   }
 
   return iq.Pass();
 }
 
 }  // namespace protocol
 }  // namespace remoting