Replace NULL with nullptr in all C++ files.

webrtc/pc/webrtcsdp_unittest.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 751 matching lines @@
 static const char kDummyMid[] = "dummy_mid";
 static const int kDummyIndex = 123;
 
 // Misc
 static const char kDummyString[] = "dummy";
 
 // Helper functions
 
 static bool SdpDeserialize(const std::string& message,
                            JsepSessionDescription* jdesc) {
-  return webrtc::SdpDeserialize(message, jdesc, NULL);
+  return webrtc::SdpDeserialize(message, jdesc, nullptr);
 }
 
 static bool SdpDeserializeCandidate(const std::string& message,
                                     JsepIceCandidate* candidate) {
-  return webrtc::SdpDeserializeCandidate(message, candidate, NULL);
+  return webrtc::SdpDeserializeCandidate(message, candidate, nullptr);
 }
 
 // Add some extra |newlines| to the |message| after |line|.
 static void InjectAfter(const std::string& line,
                         const std::string& newlines,
                         std::string* message) {
   const std::string tmp = line + newlines;
   rtc::replace_substrs(line.c_str(), line.length(),
                              tmp.c_str(), tmp.length(), message);
 }
@@ skipping 590 matching lines @@
           const_cast<Candidate&>(cc->at(j)->candidate()).set_password(
               pwd);
         }
       }
     }
     return true;
   }
 
   void AddIceOptions(const std::string& content_name,
                      const std::vector<std::string>& transport_options) {
-    ASSERT_TRUE(desc_.GetTransportInfoByName(content_name) != NULL);
+    ASSERT_TRUE(desc_.GetTransportInfoByName(content_name) != nullptr);
     cricket::TransportInfo transport_info =
         *(desc_.GetTransportInfoByName(content_name));
     desc_.RemoveTransportInfoByName(content_name);
     transport_info.description.transport_options = transport_options;
     desc_.AddTransportInfo(transport_info);
   }
 
   void SetIceUfragPwd(const std::string& content_name,
                       const std::string& ice_ufrag,
                       const std::string& ice_pwd) {
-    ASSERT_TRUE(desc_.GetTransportInfoByName(content_name) != NULL);
+    ASSERT_TRUE(desc_.GetTransportInfoByName(content_name) != nullptr);
     cricket::TransportInfo transport_info =
         *(desc_.GetTransportInfoByName(content_name));
     desc_.RemoveTransportInfoByName(content_name);
     transport_info.description.ice_ufrag = ice_ufrag;
     transport_info.description.ice_pwd = ice_pwd;
     desc_.AddTransportInfo(transport_info);
   }
 
   void AddFingerprint() {
     desc_.RemoveTransportInfoByName(kAudioContentName);
@@ skipping 230 matching lines @@
        << "a=rtpmap:99 VP8/90000\r\n"
        << "a=rtpmap:95 RTX/90000\r\n"
        << "a=fmtp:95 apt=99;\r\n";
     sdp += os.str();
 
     // Deserialize
     SdpParseError error;
     EXPECT_TRUE(webrtc::SdpDeserialize(sdp, jdesc_output, &error));
 
     const ContentInfo* ac = GetFirstAudioContent(jdesc_output->description());
-    ASSERT_TRUE(ac != NULL);
+    ASSERT_TRUE(ac != nullptr);
     const AudioContentDescription* acd =
         static_cast<const AudioContentDescription*>(ac->description);
     ASSERT_FALSE(acd->codecs().empty());
     cricket::AudioCodec opus = acd->codecs()[0];
     EXPECT_EQ("opus", opus.name);
     EXPECT_EQ(111, opus.id);
     VerifyCodecParameter(opus.params, "minptime", params.min_ptime);
     VerifyCodecParameter(opus.params, "stereo", params.stereo);
     VerifyCodecParameter(opus.params, "sprop-stereo", params.sprop_stereo);
     VerifyCodecParameter(opus.params, "useinbandfec", params.useinband);
     VerifyCodecParameter(opus.params, "maxaveragebitrate",
                          params.maxaveragebitrate);
     for (size_t i = 0; i < acd->codecs().size(); ++i) {
       cricket::AudioCodec codec = acd->codecs()[i];
       VerifyCodecParameter(codec.params, "ptime", params.ptime);
       VerifyCodecParameter(codec.params, "maxptime", params.max_ptime);
     }
 
     const ContentInfo* vc = GetFirstVideoContent(jdesc_output->description());
-    ASSERT_TRUE(vc != NULL);
+    ASSERT_TRUE(vc != nullptr);
     const VideoContentDescription* vcd =
         static_cast<const VideoContentDescription*>(vc->description);
     ASSERT_FALSE(vcd->codecs().empty());
     cricket::VideoCodec vp8 = vcd->codecs()[0];
     EXPECT_EQ("VP8", vp8.name);
     EXPECT_EQ(99, vp8.id);
     cricket::VideoCodec rtx = vcd->codecs()[1];
     EXPECT_EQ("RTX", rtx.name);
     EXPECT_EQ(95, rtx.id);
     VerifyCodecParameter(rtx.params, "apt", vp8.id);
@@ skipping 21 matching lines @@
     std::ostringstream os;
     os << sdp_session_and_audio;
     os << "a=rtcp-fb:" << (use_wildcard ? "*" : "111") <<  " nack\r\n";
     os << sdp_video;
     os << "a=rtcp-fb:" << (use_wildcard ? "*" : "101") <<  " ccm fir\r\n";
     std::string sdp = os.str();
     // Deserialize
     SdpParseError error;
     EXPECT_TRUE(webrtc::SdpDeserialize(sdp, jdesc_output, &error));
     const ContentInfo* ac = GetFirstAudioContent(jdesc_output->description());
-    ASSERT_TRUE(ac != NULL);
+    ASSERT_TRUE(ac != nullptr);
     const AudioContentDescription* acd =
         static_cast<const AudioContentDescription*>(ac->description);
     ASSERT_FALSE(acd->codecs().empty());
     cricket::AudioCodec opus = acd->codecs()[0];
     EXPECT_EQ(111, opus.id);
     EXPECT_TRUE(opus.HasFeedbackParam(
         cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                                cricket::kParamValueEmpty)));
 
     const ContentInfo* vc = GetFirstVideoContent(jdesc_output->description());
-    ASSERT_TRUE(vc != NULL);
+    ASSERT_TRUE(vc != nullptr);
     const VideoContentDescription* vcd =
         static_cast<const VideoContentDescription*>(vc->description);
     ASSERT_FALSE(vcd->codecs().empty());
     cricket::VideoCodec vp8 = vcd->codecs()[0];
     EXPECT_STREQ(webrtc::JsepSessionDescription::kDefaultVideoCodecName,
                  vp8.name.c_str());
     EXPECT_EQ(101, vp8.id);
     EXPECT_TRUE(vp8.HasFeedbackParam(
         cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                                cricket::kParamValueEmpty)));
@@ skipping 959 matching lines @@
   DataContentDescription* dcdesc = static_cast<DataContentDescription*>(
       mutant->GetContentDescriptionByName(kDataContentName));
   std::vector<cricket::DataCodec> codecs(dcdesc->codecs());
   EXPECT_EQ(1U, codecs.size());
   EXPECT_EQ(cricket::kGoogleSctpDataCodecPlType, codecs[0].id);
   codecs[0].SetParam(cricket::kCodecParamPort, kUnusualSctpPort);
   dcdesc->set_codecs(codecs);
 
   // note: mutant's owned by jdesc now.
   ASSERT_TRUE(jdesc.Initialize(mutant, kSessionId, kSessionVersion));
-  mutant = NULL;
+  mutant = nullptr;
 
   // Then get the deserialized JsepSessionDescription.
   std::string sdp_with_data = kSdpString;
   sdp_with_data.append(kSdpSctpDataChannelString);
   rtc::replace_substrs(default_portstr, strlen(default_portstr),
                              unusual_portstr, strlen(unusual_portstr),
                              &sdp_with_data);
   JsepSessionDescription jdesc_output(kDummyString);
 
   EXPECT_TRUE(SdpDeserialize(sdp_with_data, &jdesc_output));
@@ skipping 212 matching lines @@
       "m=audio 9 RTP/SAVPF 104 103\r\n"  // Pl type 104 preferred.
       "a=rtpmap:111 opus/48000/2\r\n"  // Pltype 111 listed before 103 and 104
                                        // in the map.
       "a=rtpmap:103 ISAC/16000\r\n"  // Pltype 103 listed before 104 in the map.
       "a=rtpmap:104 ISAC/32000\r\n";
 
   // Deserialize
   EXPECT_TRUE(SdpDeserialize(kSdpWithReorderedPlTypesString, &jdesc_output));
 
   const ContentInfo* ac = GetFirstAudioContent(jdesc_output.description());
-  ASSERT_TRUE(ac != NULL);
+  ASSERT_TRUE(ac != nullptr);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   ASSERT_FALSE(acd->codecs().empty());
   EXPECT_EQ("ISAC", acd->codecs()[0].name);
   EXPECT_EQ(32000, acd->codecs()[0].clockrate);
   EXPECT_EQ(104, acd->codecs()[0].id);
 }
 
 TEST_F(WebRtcSdpTest, DeserializeSerializeCodecParams) {
   JsepSessionDescription jdesc_output(kDummyString);
@@ skipping 34 matching lines @@
       "m=video 3457 RTP/SAVPF 120\r\n"
       "a=rtpmap:120 VP8/90000\r\n"
       "a=fmtp:120 x-google-min-bitrate=10;x-google-max-quantization=40\r\n";
 
   // Deserialize
   SdpParseError error;
   EXPECT_TRUE(
       webrtc::SdpDeserialize(kSdpWithFmtpString, &jdesc_output, &error));
 
   const ContentInfo* vc = GetFirstVideoContent(jdesc_output.description());
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(vc != nullptr);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   ASSERT_FALSE(vcd->codecs().empty());
   cricket::VideoCodec vp8 = vcd->codecs()[0];
   EXPECT_EQ("VP8", vp8.name);
   EXPECT_EQ(120, vp8.id);
   cricket::CodecParameterMap::iterator found =
       vp8.params.find("x-google-min-bitrate");
   ASSERT_TRUE(found != vp8.params.end());
   EXPECT_EQ(found->second, "10");
@@ skipping 14 matching lines @@
       "a=rtpmap:98 H264/90000\r\n"
       "a=fmtp:98 profile-level-id=42A01E; "
       "sprop-parameter-sets=Z0IACpZTBYmI,aMljiA==\r\n";
 
   // Deserialize.
   SdpParseError error;
   EXPECT_TRUE(
       webrtc::SdpDeserialize(kSdpWithFmtpString, &jdesc_output, &error));
 
   const ContentInfo* vc = GetFirstVideoContent(jdesc_output.description());
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(vc != nullptr);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
-  ASSERT_TRUE(vcd != NULL);
+  ASSERT_TRUE(vcd != nullptr);
   ASSERT_FALSE(vcd->codecs().empty());
   cricket::VideoCodec h264 = vcd->codecs()[0];
   EXPECT_EQ("H264", h264.name);
   EXPECT_EQ(98, h264.id);
   cricket::CodecParameterMap::const_iterator found =
       h264.params.find("profile-level-id");
   ASSERT_TRUE(found != h264.params.end());
   EXPECT_EQ(found->second, "42A01E");
   found = h264.params.find("sprop-parameter-sets");
   ASSERT_TRUE(found != h264.params.end());
@@ skipping 11 matching lines @@
       "m=video 3457 RTP/SAVPF 120\r\n"
       "a=rtpmap:120 VP8/90000\r\n"
       "a=fmtp:120   x-google-min-bitrate=10;  x-google-max-quantization=40\r\n";
 
   // Deserialize
   SdpParseError error;
   EXPECT_TRUE(webrtc::SdpDeserialize(kSdpWithFmtpString, &jdesc_output,
                                      &error));
 
   const ContentInfo* vc = GetFirstVideoContent(jdesc_output.description());
-  ASSERT_TRUE(vc != NULL);
+  ASSERT_TRUE(vc != nullptr);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   ASSERT_FALSE(vcd->codecs().empty());
   cricket::VideoCodec vp8 = vcd->codecs()[0];
   EXPECT_EQ("VP8", vp8.name);
   EXPECT_EQ(120, vp8.id);
   cricket::CodecParameterMap::iterator found =
       vp8.params.find("x-google-min-bitrate");
   ASSERT_TRUE(found != vp8.params.end());
   EXPECT_EQ(found->second, "10");
@@ skipping 400 matching lines @@
       "s=-\r\n"
       "t=0 0\r\n"
       "m=audio 9 RTP/SAVPF 111\r\n"
       "c=IN IP4 0.0.0.0\r\n"
       "a=rtpmap:111 opus/48000/2\r\n"
       "a=msid: track_id\r\n";
 
   JsepSessionDescription jdesc_output(kDummyString);
   EXPECT_FALSE(SdpDeserialize(kSdpWithMissingStreamId, &jdesc_output));
 }