Port::GetStunMessage: Write to scoped_ptr instead of raw pointer

webrtc/p2p/base/port.cc

 /*
  *  Copyright 2004 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 270 matching lines @@
   // If the user has enabled port packets, just hand this over.
   if (enable_port_packets_) {
     SignalReadPacket(this, data, size, addr);
     return;
   }
 
   // If this is an authenticated STUN request, then signal unknown address and
   // send back a proper binding response.
   rtc::scoped_ptr<IceMessage> msg;
   std::string remote_username;
-  if (!GetStunMessage(data, size, addr, msg.accept(), &remote_username)) {
+  if (!GetStunMessage(data, size, addr, &msg, &remote_username)) {
     LOG_J(LS_ERROR, this) << "Received non-STUN packet from unknown address ("
                           << addr.ToSensitiveString() << ")";
   } else if (!msg) {
     // STUN message handled already
   } else if (msg->type() == STUN_BINDING_REQUEST) {
     LOG(LS_INFO) << "Received STUN ping "
                  << " id=" << rtc::hex_encode(msg->transaction_id())
                  << " from unknown address " << addr.ToSensitiveString();
 
     // Check for role conflicts.
@@ skipping 21 matching lines @@
   for (; iter != connections_.end(); ++iter) {
     iter->second->OnReadyToSend();
   }
 }
 
 size_t Port::AddPrflxCandidate(const Candidate& local) {
   candidates_.push_back(local);
   return (candidates_.size() - 1);
 }
 
-bool Port::GetStunMessage(const char* data, size_t size,
+bool Port::GetStunMessage(const char* data,
+                          size_t size,
                           const rtc::SocketAddress& addr,
-                          IceMessage** out_msg, std::string* out_username) {
+                          rtc::scoped_ptr<IceMessage>* out_msg,
+                          std::string* out_username) {
   // NOTE: This could clearly be optimized to avoid allocating any memory.
   //       However, at the data rates we'll be looking at on the client side,
   //       this probably isn't worth worrying about.
   ASSERT(out_msg != NULL);
   ASSERT(out_username != NULL);
-  *out_msg = NULL;
+  out_msg->reset();

[tommi, 2016/03/15 09:30:16]

Prefer to have this be the caller's responsibility. You could have a dcheck here
if you want. 

[kwiberg-webrtc, 2016/03/15 10:16:01]

Sure. I just left it in because I wanted to make a minimal change.

Removed. No caller depended on this behavior.

   out_username->clear();
 
   // Don't bother parsing the packet if we can tell it's not STUN.
   // In ICE mode, all STUN packets will have a valid fingerprint.
   if (!StunMessage::ValidateFingerprint(data, size)) {
     return false;
   }
 
   // Parse the request message.  If the packet is not a complete and correct
   // STUN message, then ignore it.
@@ skipping 63 matching lines @@
     // No stun attributes will be verified, if it's stun indication message.
     // Returning from end of the this method.
   } else {
     LOG_J(LS_ERROR, this) << "Received STUN packet with invalid type ("
                           << stun_msg->type() << ") from "
                           << addr.ToSensitiveString();
     return true;
   }
 
   // Return the STUN message found.
-  *out_msg = stun_msg.release();
+  *out_msg = std::move(stun_msg);
   return true;
 }
 
 bool Port::IsCompatibleAddress(const rtc::SocketAddress& addr) {
   int family = ip().family();
   // We use single-stack sockets, so families must match.
   if (addr.family() != family) {
     return false;
   }
   // Link-local IPv6 ports can only connect to other link-local IPv6 ports.
@@ skipping 459 matching lines @@
                             << " err=" << err
                             << " id=" << rtc::hex_encode(req->id());
   }
 }
 
 void Connection::OnReadPacket(
   const char* data, size_t size, const rtc::PacketTime& packet_time) {
   rtc::scoped_ptr<IceMessage> msg;
   std::string remote_ufrag;
   const rtc::SocketAddress& addr(remote_candidate_.address());
-  if (!port_->GetStunMessage(data, size, addr, msg.accept(), &remote_ufrag)) {
+  if (!port_->GetStunMessage(data, size, addr, &msg, &remote_ufrag)) {
     // The packet did not parse as a valid STUN message
     // This is a data packet, pass it along.
     set_receiving(true);
     last_data_received_ = rtc::Time();
     recv_rate_tracker_.AddSamples(size);
     SignalReadPacket(this, data, size, packet_time);
 
     // If timed out sending writability checks, start up again
     if (!pruned_ && (write_state_ == STATE_WRITE_TIMEOUT)) {
       LOG(LS_WARNING) << "Received a data packet on a timed-out Connection. "
@@ skipping 527 matching lines @@
     ASSERT(sent < 0);
     error_ = port_->GetError();
     sent_packets_discarded_++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket