replace NULL->nullptr in src/remoting.

remoting/host/cast_extension_session.cc

 // Copyright 2014 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/host/cast_extension_session.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 78 matching lines @@
 // results of creating descriptions for this end of the PeerConnection.
 class CastCreateSessionDescriptionObserver
     : public webrtc::CreateSessionDescriptionObserver {
  public:
   static CastCreateSessionDescriptionObserver* Create(
       CastExtensionSession* session) {
     return new rtc::RefCountedObject<CastCreateSessionDescriptionObserver>(
         session);
   }
   void OnSuccess(webrtc::SessionDescriptionInterface* desc) override {
-    if (cast_extension_session_ == NULL) {
+    if (cast_extension_session_ == nullptr) {
       LOG(ERROR)
           << "No CastExtensionSession. Creating session description succeeded.";
       return;
     }
     cast_extension_session_->OnCreateSessionDescription(desc);
   }
   void OnFailure(const std::string& error) override {
-    if (cast_extension_session_ == NULL) {
+    if (cast_extension_session_ == nullptr) {
       LOG(ERROR)
           << "No CastExtensionSession. Creating session description failed.";
       return;
     }
     cast_extension_session_->OnCreateSessionDescriptionFailure(error);
   }
   void SetCastExtensionSession(CastExtensionSession* cast_extension_session) {
     cast_extension_session_ = cast_extension_session;
   }
 
@@ skipping 37 matching lines @@
 
 // TODO(aiguha): Fix PeerConnnection-related tear down crash caused by premature
 // destruction of cricket::CaptureManager (which occurs on releasing
 // |peer_conn_factory_|). See crbug.com/403840.
 CastExtensionSession::~CastExtensionSession() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Explicitly clear |create_session_desc_observer_|'s pointer to |this|,
   // since the CastExtensionSession is destructing. Otherwise,
   // |create_session_desc_observer_| would be left with a dangling pointer.
-  create_session_desc_observer_->SetCastExtensionSession(NULL);
+  create_session_desc_observer_->SetCastExtensionSession(nullptr);
 
   CleanupPeerConnection();
 }
 
 // static
 scoped_ptr<CastExtensionSession> CastExtensionSession::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<net::URLRequestContextGetter> url_request_context_getter,
     const protocol::NetworkSettings& network_settings,
     ClientSessionControl* client_session_control,
@@ skipping 56 matching lines @@
   if (has_grabbed_capturer_) {
     LOG(ERROR) << "The video pipeline was reset unexpectedly.";
     has_grabbed_capturer_ = false;
     peer_connection_->RemoveStream(stream_.release());
     return;
   }
 
   if (received_offer_) {
     has_grabbed_capturer_ = true;
     if (SetupVideoStream(capturer->Pass())) {
-      peer_connection_->CreateAnswer(create_session_desc_observer_, NULL);
+      peer_connection_->CreateAnswer(create_session_desc_observer_, nullptr);
     } else {
       has_grabbed_capturer_ = false;
       // Ignore the received offer, since we failed to setup a video stream.
       received_offer_ = false;
     }
     return;
   }
 }
 
 bool CastExtensionSession::ModifiesVideoPipeline() const {
@@ skipping 53 matching lines @@
     ClientSessionControl* client_session_control,
     protocol::ClientStub* client_stub)
     : caller_task_runner_(caller_task_runner),
       url_request_context_getter_(url_request_context_getter),
       network_settings_(network_settings),
       client_session_control_(client_session_control),
       client_stub_(client_stub),
       stats_observer_(CastStatsObserver::Create()),
       received_offer_(false),
       has_grabbed_capturer_(false),
-      signaling_thread_wrapper_(NULL),
-      worker_thread_wrapper_(NULL),
+      signaling_thread_wrapper_(nullptr),
+      worker_thread_wrapper_(nullptr),
       worker_thread_(kWorkerThreadName) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(url_request_context_getter_.get());
   DCHECK(client_session_control_);
   DCHECK(client_stub_);
 
   // The worker thread is created with base::MessageLoop::TYPE_IO because
   // the PeerConnection performs some port allocation operations on this thread
   // that require it. See crbug.com/404013.
   base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
   worker_thread_.StartWithOptions(options);
   worker_task_runner_ = worker_thread_.task_runner();
 }
 
 bool CastExtensionSession::ParseAndSetRemoteDescription(
     base::DictionaryValue* message) {
-  DCHECK(peer_connection_.get() != NULL);
+  DCHECK(peer_connection_.get() != nullptr);
 
   base::DictionaryValue* message_data;
   if (!message->GetDictionary(kTopLevelData, &message_data)) {
     LOG(ERROR) << "Invalid Cast Extension Message (missing data).";
     return false;
   }
 
   std::string webrtc_type;
   if (!message_data->GetString(kWebRtcSessionDescType, &webrtc_type)) {
     LOG(ERROR)
@@ skipping 17 matching lines @@
     return false;
   }
 
   peer_connection_->SetRemoteDescription(
       CastSetSessionDescriptionObserver::Create(), session_description);
   return true;
 }
 
 bool CastExtensionSession::ParseAndAddICECandidate(
     base::DictionaryValue* message) {
-  DCHECK(peer_connection_.get() != NULL);
+  DCHECK(peer_connection_.get() != nullptr);
 
   base::DictionaryValue* message_data;
   if (!message->GetDictionary(kTopLevelData, &message_data)) {
     LOG(ERROR) << "Invalid Cast Extension Message (missing data).";
     return false;
   }
 
   std::string candidate_str;
   std::string sdp_mid;
   int sdp_mlineindex = 0;
@@ skipping 19 matching lines @@
 
   VLOG(1) << "Received and Added ICE Candidate: " << candidate_str;
 
   return true;
 }
 
 bool CastExtensionSession::SendMessageToClient(const std::string& subject,
                                                const std::string& data) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  if (client_stub_ == NULL) {
+  if (client_stub_ == nullptr) {
     LOG(ERROR) << "No Client Stub. Cannot send message to client.";
     return false;
   }
 
   base::DictionaryValue message_dict;
   message_dict.SetString(kTopLevelSubject, subject);
   message_dict.SetString(kTopLevelData, data);
   std::string message_json;
 
   if (!base::JSONWriter::Write(&message_dict, &message_json)) {
     LOG(ERROR) << "Failed to serialize JSON message.";
     return false;
   }
 
   protocol::ExtensionMessage message;
   message.set_type(kExtensionMessageType);
   message.set_data(message_json);
   client_stub_->DeliverHostMessage(message);
   return true;
 }
 
 void CastExtensionSession::EnsureTaskAndSetSend(rtc::Thread** ptr,
                                                 base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *ptr = jingle_glue::JingleThreadWrapper::current();
 
-  if (event != NULL) {
+  if (event != nullptr) {
     event->Signal();
   }
 }
 
 bool CastExtensionSession::WrapTasksAndSave() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   EnsureTaskAndSetSend(&signaling_thread_wrapper_);
-  if (signaling_thread_wrapper_ == NULL)
+  if (signaling_thread_wrapper_ == nullptr)
     return false;
 
   base::WaitableEvent wrap_worker_thread_event(true, false);
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CastExtensionSession::EnsureTaskAndSetSend,
                  base::Unretained(this),
                  &worker_thread_wrapper_,
                  &wrap_worker_thread_event));
   wrap_worker_thread_event.Wait();
 
-  return (worker_thread_wrapper_ != NULL);
+  return (worker_thread_wrapper_ != nullptr);
 }
 
 bool CastExtensionSession::InitializePeerConnection() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!peer_conn_factory_);
   DCHECK(!peer_connection_);
-  DCHECK(worker_thread_wrapper_ != NULL);
-  DCHECK(signaling_thread_wrapper_ != NULL);
+  DCHECK(worker_thread_wrapper_ != nullptr);
+  DCHECK(signaling_thread_wrapper_ != nullptr);
 
   peer_conn_factory_ = webrtc::CreatePeerConnectionFactory(
-      worker_thread_wrapper_, signaling_thread_wrapper_, NULL, NULL, NULL);
+      worker_thread_wrapper_, signaling_thread_wrapper_, nullptr, nullptr,
+      nullptr);
 
   if (!peer_conn_factory_.get()) {
     CleanupPeerConnection();
     return false;
   }
 
   VLOG(1) << "Created PeerConnectionFactory successfully.";
 
   webrtc::PeerConnectionInterface::IceServers servers;
   webrtc::PeerConnectionInterface::IceServer server;
   server.uri = kDefaultStunURI;
   servers.push_back(server);
   webrtc::PeerConnectionInterface::RTCConfiguration rtc_config;
   rtc_config.servers = servers;
 
   // DTLS-SRTP is the preferred encryption method. If set to kValueFalse, the
   // peer connection uses SDES. Disabling SDES as well will cause the peer
   // connection to fail to connect.
   // Note: For protection and unprotection of SRTP packets, the libjingle
   // ENABLE_EXTERNAL_AUTH flag must not be set.
   webrtc::FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            webrtc::MediaConstraintsInterface::kValueTrue);
 
   rtc::scoped_refptr<webrtc::PortAllocatorFactoryInterface>
       port_allocator_factory = ChromiumPortAllocatorFactory::Create(
           network_settings_, url_request_context_getter_);
 
   peer_connection_ = peer_conn_factory_->CreatePeerConnection(
-      rtc_config, &constraints, port_allocator_factory, NULL, this);
+      rtc_config, &constraints, port_allocator_factory, nullptr, this);
 
   if (!peer_connection_.get()) {
     CleanupPeerConnection();
     return false;
   }
 
   VLOG(1) << "Created PeerConnection successfully.";
 
   create_session_desc_observer_ =
       CastCreateSessionDescriptionObserver::Create(this);
@@ skipping 52 matching lines @@
   rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> video_track =
       stream_->FindVideoTrack(kVideoLabel);
   peer_connection_->GetStats(
       stats_observer_,
       video_track.release(),
       webrtc::PeerConnectionInterface::kStatsOutputLevelStandard);
 }
 
 void CastExtensionSession::CleanupPeerConnection() {
   peer_connection_->Close();
-  peer_connection_ = NULL;
-  stream_ = NULL;
-  peer_conn_factory_ = NULL;
+  peer_connection_ = nullptr;
+  stream_ = nullptr;
+  peer_conn_factory_ = nullptr;
   worker_thread_.Stop();
 }
 
 bool CastExtensionSession::connection_active() const {
-  return peer_connection_.get() != NULL;
+  return peer_connection_.get() != nullptr;
 }
 
 // webrtc::PeerConnectionObserver implementation -------------------------------
 void CastExtensionSession::OnSignalingChange(
     webrtc::PeerConnectionInterface::SignalingState new_state) {
   VLOG(1) << "PeerConnectionObserver: SignalingState changed to:" << new_state;
 }
 
 void CastExtensionSession::OnStateChange(
     webrtc::PeerConnectionObserver::StateType state_changed) {
@@ skipping 58 matching lines @@
   json->SetString(kWebRtcCandidate, candidate_str);
   std::string json_str;
   if (!base::JSONWriter::Write(json.get(), &json_str)) {
     LOG(ERROR) << "Failed to serialize candidate message.";
     return;
   }
   SendMessageToClient(kSubjectNewCandidate, json_str);
 }
 
 }  // namespace remoting