--- a/media/mtransport/test/ice_unittest.cpp
+++ b/media/mtransport/test/ice_unittest.cpp
@@ -1136,17 +1136,18 @@ class IceTestPeer : public sigslot::has_
     uint64_t priority = std::numeric_limits<uint64_t>::max();
 
     for (size_t p = 0; p < pairs.size(); ++p) {
       if (priority < pairs[p].priority) {
         std::cerr << "Priority increased in subsequent pairs:" << std::endl;
         DumpCandidatePair(pairs[p-1]);
         DumpCandidatePair(pairs[p]);
         return false;
-      } else if (priority == pairs[p].priority) {
+      }
+      if (priority == pairs[p].priority) {
         if (!IceCandidatePairCompare()(pairs[p], pairs[p-1]) &&
             !IceCandidatePairCompare()(pairs[p-1], pairs[p])) {
           std::cerr << "Ignoring identical pair from trigger check" << std::endl;
         } else {
           std::cerr << "Duplicate priority in subseqent pairs:" << std::endl;
           DumpCandidatePair(pairs[p-1]);
           DumpCandidatePair(pairs[p]);
           return false;

--- a/media/mtransport/test_nr_socket.cpp
+++ b/media/mtransport/test_nr_socket.cpp
@@ -138,19 +138,21 @@ static nr_socket_factory_vtbl test_nat_s
   test_nat_socket_factory_destroy
 };
 
 /* static */
 TestNat::NatBehavior
 TestNat::ToNatBehavior(const std::string& type) {
   if (!type.compare("ENDPOINT_INDEPENDENT")) {
     return TestNat::ENDPOINT_INDEPENDENT;
-  } else if (!type.compare("ADDRESS_DEPENDENT")) {
+  }
+  if (!type.compare("ADDRESS_DEPENDENT")) {
     return TestNat::ADDRESS_DEPENDENT;
-  } else if (!type.compare("PORT_DEPENDENT")) {
+  }
+  if (!type.compare("PORT_DEPENDENT")) {
     return TestNat::PORT_DEPENDENT;
   }
 
   MOZ_ASSERT(false, "Invalid NAT behavior");
   return TestNat::ENDPOINT_INDEPENDENT;
 }
 
 bool TestNat::has_port_mappings() const {
@@ -534,35 +536,33 @@ int TestNrSocket::write(const void *msg,
   }
 
   if (port_mappings_.empty()) {
     // The no-nat case, just pass call through.
     r_log(LOG_GENERIC, LOG_DEBUG, "TestNrSocket %s writing",
           my_addr().as_string);
 
     return internal_socket_->write(msg, len, written);
-  } else {
-    destroy_stale_port_mappings();
-    if (port_mappings_.empty()) {
-      r_log(LOG_GENERIC, LOG_DEBUG,
-            "TestNrSocket %s dropping outgoing TCP "
-            "because the port mapping was stale",
-            my_addr().as_string);
-      return R_INTERNAL;
-    }
-    // This is TCP only
-    MOZ_ASSERT(port_mappings_.size() == 1);
+  }
+  destroy_stale_port_mappings();
+  if (port_mappings_.empty()) {
     r_log(LOG_GENERIC, LOG_DEBUG,
-          "PortMapping %s -> %s writing",
-          port_mappings_.front()->external_socket_->my_addr().as_string,
-          port_mappings_.front()->remote_address_.as_string);
-
-    port_mappings_.front()->last_used_ = PR_IntervalNow();
-    return port_mappings_.front()->external_socket_->write(msg, len, written);
+          "TestNrSocket %s dropping outgoing TCP "
+          "because the port mapping was stale",
+          my_addr().as_string);
+    return R_INTERNAL;
   }
+  // This is TCP only
+  MOZ_ASSERT(port_mappings_.size() == 1);
+  r_log(LOG_GENERIC, LOG_DEBUG,
+        "PortMapping %s -> %s writing",
+        port_mappings_.front()->external_socket_->my_addr().as_string,
+        port_mappings_.front()->remote_address_.as_string);
+  port_mappings_.front()->last_used_ = PR_IntervalNow();
+  return port_mappings_.front()->external_socket_->write(msg, len, written);
 }
 
 int TestNrSocket::read(void *buf, size_t maxlen, size_t *len) {
   int r;
 
   if (port_mappings_.empty()) {
     r = internal_socket_->read(buf, maxlen, len);
   } else {
@@ -637,17 +637,18 @@ int TestNrSocket::async_wait(int how, NR
     MOZ_ASSERT(port_mappings_.size() == 1);
 
     return port_mappings_.front()->async_wait(
         how,
         port_mapping_tcp_passthrough_callback,
         this,
         function,
         line);
-  } else if (how == NR_ASYNC_WAIT_READ) {
+  }
+  if (how == NR_ASYNC_WAIT_READ) {
     // For UDP port mappings, we decouple the writeable callbacks
     for (PortMapping *port_mapping : port_mappings_) {
       // Be ready to receive traffic on our port mappings
       r = port_mapping->async_wait(how,
                                    socket_readable_callback,
                                    this,
                                    function,
                                    line);
@@ -898,17 +899,18 @@ int TestNrSocket::PortMapping::sendto(co
   int r = external_socket_->sendto(msg, len, 0,
       // TODO(bug 1170299): Remove const_cast when no longer necessary
       const_cast<nr_transport_addr*>(&to));
 
   if (r == R_WOULDBLOCK) {
     r_log(LOG_GENERIC, LOG_DEBUG, "Enqueueing UDP packet to %s", to.as_string);
     send_queue_.push_back(RefPtr<UdpPacket>(new UdpPacket(msg, len, to)));
     return 0;
-  } else if (r) {
+  }
+  if (r) {
     r_log(LOG_GENERIC,LOG_ERR, "Error: %d", r);
   }
 
   return r;
 }
 
 int TestNrSocket::PortMapping::async_wait(int how, NR_async_cb cb, void *cb_arg,
                                           char *function, int line) {

--- a/media/mtransport/transportlayerlog.cpp
+++ b/media/mtransport/transportlayerlog.cpp
@@ -26,19 +26,17 @@ void TransportLayerLogging::WasInserted(
 
 TransportResult
 TransportLayerLogging::SendPacket(const unsigned char *data, size_t len) {
   MOZ_MTLOG(ML_DEBUG, LAYER_INFO << "SendPacket(" << len << ")");
 
   if (downward_) {
     return downward_->SendPacket(data, len);
   }
-  else {
-    return static_cast<TransportResult>(len);
-  }
+  return static_cast<TransportResult>(len);
 }
 
 void TransportLayerLogging::StateChange(TransportLayer *layer, State state) {
   MOZ_MTLOG(ML_DEBUG, LAYER_INFO << "Received StateChange to " << state);
 
   TL_SET_STATE(state);
 }