Cast: Refactor framer to Clang format

media/cast/framer/cast_message_builder.cc

 // Copyright 2013 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 "media/cast/framer/cast_message_builder.h"
 
 #include "media/cast/cast_defines.h"
 
 namespace media {
 namespace cast {
@@ skipping 34 matching lines @@
       return;
     }
     waiting_for_key_frame_ = false;
     cast_msg_.missing_frames_and_packets_.clear();
     cast_msg_.ack_frame_id_ = frame_id;
     last_update_time_ = clock_->NowTicks();
     // We might have other complete frames waiting after we receive the last
     // packet in the key-frame.
     UpdateAckMessage();
   } else {
-    if (!UpdateAckMessage()) return;
+    if (!UpdateAckMessage())
+      return;
 
     BuildPacketList();
   }
   // Send cast message.
   VLOG(1) << "Send cast message Ack:" << static_cast<int>(frame_id);
   cast_feedback_->CastFeedback(cast_msg_);
 }
 
 bool CastMessageBuilder::UpdateAckMessage() {
   if (!decoder_faster_than_max_frame_rate_) {
@@ skipping 13 matching lines @@
     } else {
       acked_last_frame_ = true;
       last_acked_frame_id_++;
       // Note: frame skipping and slowdown ACK is not supported at the same
       // time; and it's not needed since we can skip frames to catch up.
     }
   } else {
     uint32 frame_id = frame_id_map_->LastContinuousFrame();
 
     // Is it a new frame?
-    if (last_acked_frame_id_ == frame_id) return false;
+    if (last_acked_frame_id_ == frame_id)
+      return false;
 
     last_acked_frame_id_ = frame_id;
     acked_last_frame_ = true;
   }
   cast_msg_.ack_frame_id_ = last_acked_frame_id_;
   cast_msg_.missing_frames_and_packets_.clear();
   last_update_time_ = clock_->NowTicks();
   return true;
 }
 
 bool CastMessageBuilder::TimeToSendNextCastMessage(
     base::TimeTicks* time_to_send) {
   // We haven't received any packets.
-  if (last_update_time_.is_null() && frame_id_map_->Empty()) return false;
+  if (last_update_time_.is_null() && frame_id_map_->Empty())
+    return false;
 
-  *time_to_send = last_update_time_ +
-      base::TimeDelta::FromMilliseconds(kCastMessageUpdateIntervalMs);
+  *time_to_send = last_update_time_ + base::TimeDelta::FromMilliseconds(
+                                          kCastMessageUpdateIntervalMs);
   return true;
 }
 
 void CastMessageBuilder::UpdateCastMessage() {
   RtcpCastMessage message(media_ssrc_);
-  if (!UpdateCastMessageInternal(&message)) return;
+  if (!UpdateCastMessageInternal(&message))
+    return;
 
   // Send cast message.
   cast_feedback_->CastFeedback(message);
 }
 
 void CastMessageBuilder::Reset() {
   waiting_for_key_frame_ = true;
   cast_msg_.ack_frame_id_ = kStartFrameId;
   cast_msg_.missing_frames_and_packets_.clear();
   time_last_nacked_map_.clear();
@@ skipping 21 matching lines @@
   return true;
 }
 
 void CastMessageBuilder::BuildPacketList() {
   base::TimeTicks now = clock_->NowTicks();
 
   // Clear message NACK list.
   cast_msg_.missing_frames_and_packets_.clear();
 
   // Are we missing packets?
-  if (frame_id_map_->Empty()) return;
+  if (frame_id_map_->Empty())
+    return;
 
   uint32 newest_frame_id = frame_id_map_->NewestFrameId();
   uint32 next_expected_frame_id = cast_msg_.ack_frame_id_ + 1;
 
   // Iterate over all frames.
   for (; !IsNewerFrameId(next_expected_frame_id, newest_frame_id);
        ++next_expected_frame_id) {
     TimeLastNackMap::iterator it =
         time_last_nacked_map_.find(next_expected_frame_id);
     if (it != time_last_nacked_map_.end()) {
       // We have sent a NACK in this frame before, make sure enough time have
       // passed.
       if (now - it->second <
           base::TimeDelta::FromMilliseconds(kNackRepeatIntervalMs)) {
         continue;
       }
     }
 
     PacketIdSet missing;
     if (frame_id_map_->FrameExists(next_expected_frame_id)) {
       bool last_frame = (newest_frame_id == next_expected_frame_id);
-      frame_id_map_->GetMissingPackets(next_expected_frame_id, last_frame,
-                                       &missing);
+      frame_id_map_->GetMissingPackets(
+          next_expected_frame_id, last_frame, &missing);
       if (!missing.empty()) {
         time_last_nacked_map_[next_expected_frame_id] = now;
         cast_msg_.missing_frames_and_packets_.insert(
             std::make_pair(next_expected_frame_id, missing));
       }
     } else {
       time_last_nacked_map_[next_expected_frame_id] = now;
       missing.insert(kRtcpCastAllPacketsLost);
       cast_msg_.missing_frames_and_packets_[next_expected_frame_id] = missing;
     }
   }
 }
 
 }  //  namespace cast
 }  //  namespace media