Change StunMessage::AddAttribute return type from bool to void.

webrtc/p2p/base/turnserver.cc

 /*
  *  Copyright 2012 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 95 matching lines @@
   return true;
 }
 
 static bool InitErrorResponse(const StunMessage* req, int code,
                               const std::string& reason, StunMessage* resp) {
   int resp_type = (req) ? GetStunErrorResponseType(req->type()) : -1;
   if (resp_type == -1)
     return false;
   resp->SetType(resp_type);
   resp->SetTransactionID(req->transaction_id());
-  VERIFY(resp->AddAttribute(new cricket::StunErrorCodeAttribute(
-      STUN_ATTR_ERROR_CODE, code, reason)));
+  resp->AddAttribute(new cricket::StunErrorCodeAttribute(
+      STUN_ATTR_ERROR_CODE, code, reason));
   return true;
 }
 
 
 TurnServer::TurnServer(rtc::Thread* thread)
     : thread_(thread),
       nonce_key_(rtc::CreateRandomString(kNonceKeySize)),
       auth_hook_(NULL),
       redirect_hook_(NULL),
       enable_otu_nonce_(false) {
@@ skipping 221 matching lines @@
 
 void TurnServer::HandleBindingRequest(TurnServerConnection* conn,
                                       const StunMessage* req) {
   StunMessage response;
   InitResponse(req, &response);
 
   // Tell the user the address that we received their request from.
   StunAddressAttribute* mapped_addr_attr;
   mapped_addr_attr = new StunXorAddressAttribute(
       STUN_ATTR_XOR_MAPPED_ADDRESS, conn->src());
-  VERIFY(response.AddAttribute(mapped_addr_attr));
+  response.AddAttribute(mapped_addr_attr);
 
   SendStun(conn, &response);
 }
 
 void TurnServer::HandleAllocateRequest(TurnServerConnection* conn,
                                        const TurnMessage* msg,
                                        const std::string& key) {
   // Check the parameters in the request.
   const StunUInt32Attribute* transport_attr =
       msg->GetUInt32(STUN_ATTR_REQUESTED_TRANSPORT);
@@ skipping 93 matching lines @@
     TurnServerConnection* conn, const StunMessage* msg,
     int code, const std::string& reason) {
   TurnMessage resp;
   InitErrorResponse(msg, code, reason, &resp);
 
   int64_t timestamp = rtc::TimeMillis();
   if (ts_for_next_nonce_) {
     timestamp = ts_for_next_nonce_;
     ts_for_next_nonce_ = 0;
   }
-  VERIFY(resp.AddAttribute(
-      new StunByteStringAttribute(STUN_ATTR_NONCE, GenerateNonce(timestamp))));
-  VERIFY(resp.AddAttribute(new StunByteStringAttribute(
-      STUN_ATTR_REALM, realm_)));
+  resp.AddAttribute(
+      new StunByteStringAttribute(STUN_ATTR_NONCE, GenerateNonce(timestamp)));
+  resp.AddAttribute(new StunByteStringAttribute(
+      STUN_ATTR_REALM, realm_));
   SendStun(conn, &resp);
 }
 
 void TurnServer::SendErrorResponseWithAlternateServer(
     TurnServerConnection* conn, const StunMessage* msg,
     const rtc::SocketAddress& addr) {
   TurnMessage resp;
   InitErrorResponse(msg, STUN_ERROR_TRY_ALTERNATE,
                     STUN_ERROR_REASON_TRY_ALTERNATE_SERVER, &resp);
-  VERIFY(resp.AddAttribute(new StunAddressAttribute(
-      STUN_ATTR_ALTERNATE_SERVER, addr)));
+  resp.AddAttribute(new StunAddressAttribute(
+      STUN_ATTR_ALTERNATE_SERVER, addr));
   SendStun(conn, &resp);
 }
 
 void TurnServer::SendStun(TurnServerConnection* conn, StunMessage* msg) {
   rtc::ByteBufferWriter buf;
   // Add a SOFTWARE attribute if one is set.
   if (!software_.empty()) {
-    VERIFY(msg->AddAttribute(
-        new StunByteStringAttribute(STUN_ATTR_SOFTWARE, software_)));
+    msg->AddAttribute(
+        new StunByteStringAttribute(STUN_ATTR_SOFTWARE, software_));
   }
   msg->Write(&buf);
   Send(conn, buf);
 }
 
 void TurnServer::Send(TurnServerConnection* conn,
                       const rtc::ByteBufferWriter& buf) {
   rtc::PacketOptions options;
   conn->socket()->SendTo(buf.Data(), buf.Length(), conn->src(), options);
 }
@@ skipping 144 matching lines @@
   TurnMessage response;
   InitResponse(msg, &response);
 
   StunAddressAttribute* mapped_addr_attr =
       new StunXorAddressAttribute(STUN_ATTR_XOR_MAPPED_ADDRESS, conn_.src());
   StunAddressAttribute* relayed_addr_attr =
       new StunXorAddressAttribute(STUN_ATTR_XOR_RELAYED_ADDRESS,
           external_socket_->GetLocalAddress());
   StunUInt32Attribute* lifetime_attr =
       new StunUInt32Attribute(STUN_ATTR_LIFETIME, lifetime_secs);
-  VERIFY(response.AddAttribute(mapped_addr_attr));
-  VERIFY(response.AddAttribute(relayed_addr_attr));
-  VERIFY(response.AddAttribute(lifetime_attr));
+  response.AddAttribute(mapped_addr_attr);
+  response.AddAttribute(relayed_addr_attr);
+  response.AddAttribute(lifetime_attr);
 
   SendResponse(&response);
 }
 
 void TurnServerAllocation::HandleRefreshRequest(const TurnMessage* msg) {
   // Figure out the new lifetime.
   int lifetime_secs = ComputeLifetime(msg);
 
   // Reset the expiration timer.
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
   thread_->PostDelayed(RTC_FROM_HERE, lifetime_secs * 1000, this,
                        MSG_ALLOCATION_TIMEOUT);
 
   LOG_J(LS_INFO, this) << "Refreshed allocation, lifetime=" << lifetime_secs;
 
   // Send a success response with a LIFETIME attribute.
   TurnMessage response;
   InitResponse(msg, &response);
 
   StunUInt32Attribute* lifetime_attr =
       new StunUInt32Attribute(STUN_ATTR_LIFETIME, lifetime_secs);
-  VERIFY(response.AddAttribute(lifetime_attr));
+  response.AddAttribute(lifetime_attr);
 
   SendResponse(&response);
 }
 
 void TurnServerAllocation::HandleSendIndication(const TurnMessage* msg) {
   // Check mandatory attributes.
   const StunByteStringAttribute* data_attr = msg->GetByteString(STUN_ATTR_DATA);
   const StunAddressAttribute* peer_attr =
       msg->GetAddress(STUN_ATTR_XOR_PEER_ADDRESS);
   if (!data_attr || !peer_attr) {
@@ skipping 116 matching lines @@
     buf.WriteUInt16(static_cast<uint16_t>(size));
     buf.WriteBytes(data, size);
     server_->Send(&conn_, buf);
   } else if (!server_->enable_permission_checks_ ||
              HasPermission(addr.ipaddr())) {
     // No channel, but a permission exists. Send as a data indication.
     TurnMessage msg;
     msg.SetType(TURN_DATA_INDICATION);
     msg.SetTransactionID(
         rtc::CreateRandomString(kStunTransactionIdLength));
-    VERIFY(msg.AddAttribute(new StunXorAddressAttribute(
-        STUN_ATTR_XOR_PEER_ADDRESS, addr)));
-    VERIFY(msg.AddAttribute(new StunByteStringAttribute(
-        STUN_ATTR_DATA, data, size)));
+    msg.AddAttribute(new StunXorAddressAttribute(
+        STUN_ATTR_XOR_PEER_ADDRESS, addr));
+    msg.AddAttribute(new StunByteStringAttribute(
+        STUN_ATTR_DATA, data, size));
     server_->SendStun(&conn_, &msg);
   } else {
     LOG_J(LS_WARNING, this) << "Received external packet without permission, "
                             << "peer=" << addr;
   }
 }
 
 int TurnServerAllocation::ComputeLifetime(const TurnMessage* msg) {
   // Return the smaller of our default lifetime and the requested lifetime.
   int lifetime = kDefaultAllocationTimeout / 1000;  // convert to seconds
@@ skipping 128 matching lines @@
                        MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Channel::OnMessage(rtc::Message* msg) {
   RTC_DCHECK(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 }  // namespace cricket