Cast: Refactor Framer to Clang format

This cl is pure style-targeted refactoring. 
No functional changes were made. 

BUG=339176

Review URL: https://codereview.chromium.org/148663003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@247865 0039d316-1c4b-4281-b951-d872f2087c98

media/cast/framer/cast_message_builder.cc

@@ -52,7 +52,8 @@ void CastMessageBuilder::CompleteFrameReceived(uint32 frame_id,
     // packet in the key-frame.
     UpdateAckMessage();
   } else {
-    if (!UpdateAckMessage()) return;
+    if (!UpdateAckMessage())
+      return;
 
     BuildPacketList();
   }
@@ -86,7 +87,8 @@ bool CastMessageBuilder::UpdateAckMessage() {
     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;
@@ -100,16 +102,18 @@ bool CastMessageBuilder::UpdateAckMessage() {
 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);
@@ -151,7 +155,8 @@ void CastMessageBuilder::BuildPacketList() {
   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;
@@ -173,8 +178,8 @@ void CastMessageBuilder::BuildPacketList() {
     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(

media/cast/framer/cast_message_builder_unittest.cc

@@ -12,21 +12,18 @@
 namespace media {
 namespace cast {
 
+namespace {
 static const uint32 kSsrc = 0x1234;
 static const uint32 kShortTimeIncrementMs = 10;
 static const uint32 kLongTimeIncrementMs = 40;
 static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
 
-namespace {
 typedef std::map<uint32, size_t> MissingPacketsMap;
 
 class NackFeedbackVerification : public RtpPayloadFeedback {
  public:
   NackFeedbackVerification()
-      : triggered_(false),
-        missing_packets_(),
-        last_frame_acked_(0) {}
-
+      : triggered_(false), missing_packets_(), last_frame_acked_(0) {}
 
   virtual void CastFeedback(const RtcpCastMessage& cast_feedback) OVERRIDE {
     EXPECT_EQ(kSsrc, cast_feedback.media_ssrc_);
@@ -43,10 +40,10 @@ class NackFeedbackVerification : public RtpPayloadFeedback {
       if ((frame_it->second.size() == 1) &&
           (*frame_it->second.begin() == kRtcpCastAllPacketsLost)) {
         missing_packets_.insert(
-          std::make_pair(frame_it->first, kRtcpCastAllPacketsLost));
+            std::make_pair(frame_it->first, kRtcpCastAllPacketsLost));
       } else {
-      missing_packets_.insert(
-          std::make_pair(frame_it->first, frame_it->second.size()));
+        missing_packets_.insert(
+            std::make_pair(frame_it->first, frame_it->second.size()));
       }
       ++frame_it;
     }
@@ -56,14 +53,15 @@ class NackFeedbackVerification : public RtpPayloadFeedback {
   size_t num_missing_packets(uint32 frame_id) {
     MissingPacketsMap::iterator it;
     it = missing_packets_.find(frame_id);
-    if (it == missing_packets_.end()) return 0;
+    if (it == missing_packets_.end())
+      return 0;
 
     return it->second;
   }
 
   // Holds value for one call.
   bool triggered() {
-    bool ret_val =  triggered_;
+    bool ret_val = triggered_;
     triggered_ = false;
     return ret_val;
   }
@@ -74,6 +72,8 @@ class NackFeedbackVerification : public RtpPayloadFeedback {
   bool triggered_;
   MissingPacketsMap missing_packets_;  // Missing packets per frame.
   uint32 last_frame_acked_;
+
+  DISALLOW_COPY_AND_ASSIGN(NackFeedbackVerification);
 };
 }  // namespace
 
@@ -94,21 +94,15 @@ class CastMessageBuilderTest : public ::testing::Test {
 
   virtual ~CastMessageBuilderTest() {}
 
-  void SetFrameId(uint32 frame_id) {
-    rtp_header_.frame_id = frame_id;
-  }
+  void SetFrameId(uint32 frame_id) { rtp_header_.frame_id = frame_id; }
 
-  void SetPacketId(uint16 packet_id) {
-    rtp_header_.packet_id = packet_id;
-  }
+  void SetPacketId(uint16 packet_id) { rtp_header_.packet_id = packet_id; }
 
   void SetMaxPacketId(uint16 max_packet_id) {
     rtp_header_.max_packet_id = max_packet_id;
   }
 
-  void SetKeyFrame(bool is_key) {
-    rtp_header_.is_key_frame = is_key;
-  }
+  void SetKeyFrame(bool is_key) { rtp_header_.is_key_frame = is_key; }
 
   void SetReferenceFrameId(uint32 reference_frame_id) {
     rtp_header_.is_reference = true;
@@ -138,6 +132,8 @@ class CastMessageBuilderTest : public ::testing::Test {
   RtpCastHeader rtp_header_;
   FrameIdMap frame_id_map_;
   base::SimpleTestTickClock testing_clock_;
+
+  DISALLOW_COPY_AND_ASSIGN(CastMessageBuilderTest);
 };
 
 TEST_F(CastMessageBuilderTest, StartWithAKeyFrame) {
@@ -481,18 +477,19 @@ TEST_F(CastMessageBuilderTest, SlowDownAck) {
     SetFrameId(frame_id);
     InsertPacket();
     testing_clock_.Advance(
-      base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
+        base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
   }
   // We should now have entered the slowdown ACK state.
   uint32 expected_frame_id = 1;
   for (; frame_id < 10; ++frame_id) {
-    if (frame_id % 2)  ++expected_frame_id;
+    if (frame_id % 2)
+      ++expected_frame_id;
     EXPECT_TRUE(feedback_.triggered());
     EXPECT_EQ(expected_frame_id, feedback_.last_frame_acked());
     SetFrameId(frame_id);
     InsertPacket();
     testing_clock_.Advance(
-      base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
+        base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
   }
   EXPECT_TRUE(feedback_.triggered());
   EXPECT_EQ(expected_frame_id, feedback_.last_frame_acked());

media/cast/framer/frame_buffer.cc

@@ -37,7 +37,8 @@ void FrameBuffer::InsertPacket(const uint8* payload_data,
     rtp_timestamp_ = rtp_header.webrtc.header.timestamp;
   }
   // Is this the correct frame?
-  if (rtp_header.frame_id != frame_id_) return;
+  if (rtp_header.frame_id != frame_id_)
+    return;
 
   // Insert every packet only once.
   if (packets_.find(rtp_header.packet_id) != packets_.end()) {
@@ -50,8 +51,8 @@ void FrameBuffer::InsertPacket(const uint8* payload_data,
 
   // Insert the packet.
   retval.first->second.resize(payload_size);
-  std::copy(payload_data, payload_data + payload_size,
-            retval.first->second.begin());
+  std::copy(
+      payload_data, payload_data + payload_size, retval.first->second.begin());
 
   ++num_packets_received_;
   total_data_size_ += payload_size;
@@ -64,7 +65,8 @@ bool FrameBuffer::Complete() const {
 bool FrameBuffer::GetEncodedAudioFrame(
     transport::EncodedAudioFrame* audio_frame,
     uint32* rtp_timestamp) const {
-  if (!Complete()) return false;
+  if (!Complete())
+    return false;
 
   *rtp_timestamp = rtp_timestamp_;
 
@@ -76,8 +78,8 @@ bool FrameBuffer::GetEncodedAudioFrame(
   audio_frame->data.reserve(total_data_size_);
   PacketMap::const_iterator it;
   for (it = packets_.begin(); it != packets_.end(); ++it) {
-    audio_frame->data.insert(audio_frame->data.end(),
-                             it->second.begin(), it->second.end());
+    audio_frame->data.insert(
+        audio_frame->data.end(), it->second.begin(), it->second.end());
   }
   return true;
 }
@@ -85,7 +87,8 @@ bool FrameBuffer::GetEncodedAudioFrame(
 bool FrameBuffer::GetEncodedVideoFrame(
     transport::EncodedVideoFrame* video_frame,
     uint32* rtp_timestamp) const {
-  if (!Complete()) return false;
+  if (!Complete())
+    return false;
 
   *rtp_timestamp = rtp_timestamp_;
 
@@ -99,8 +102,8 @@ bool FrameBuffer::GetEncodedVideoFrame(
   video_frame->data.reserve(total_data_size_);
   PacketMap::const_iterator it;
   for (it = packets_.begin(); it != packets_.end(); ++it) {
-    video_frame->data.insert(video_frame->data.end(),
-                             it->second.begin(), it->second.end());
+    video_frame->data.insert(
+        video_frame->data.end(), it->second.begin(), it->second.end());
   }
   return true;
 }

media/cast/framer/frame_buffer_unittest.cc

@@ -10,13 +10,8 @@ namespace cast {
 
 class FrameBufferTest : public ::testing::Test {
  protected:
-  FrameBufferTest() {}
-
-  virtual ~FrameBufferTest() {}
-
-  virtual void SetUp() {
+  FrameBufferTest() {
     payload_.assign(kMaxIpPacketSize, 0);
-
     // Build a default one packet frame - populate webrtc header.
     rtp_header_.is_key_frame = false;
     rtp_header_.frame_id = 0;
@@ -26,9 +21,13 @@ class FrameBufferTest : public ::testing::Test {
     rtp_header_.reference_frame_id = 0;
   }
 
+  virtual ~FrameBufferTest() {}
+
   FrameBuffer buffer_;
   std::vector<uint8> payload_;
   RtpCastHeader rtp_header_;
+
+  DISALLOW_COPY_AND_ASSIGN(FrameBufferTest);
 };
 
 TEST_F(FrameBufferTest, EmptyBuffer) {

media/cast/framer/frame_id_map.cc

@@ -38,9 +38,7 @@ PacketType FrameInfo::InsertPacket(uint16 packet_id) {
   return missing_packets_.empty() ? kNewPacketCompletingFrame : kNewPacket;
 }
 
-bool FrameInfo::Complete() const {
-  return missing_packets_.empty();
-}
+bool FrameInfo::Complete() const { return missing_packets_.empty(); }
 
 void FrameInfo::GetMissingPackets(bool newest_frame,
                                   PacketIdSet* missing_packets) const {
@@ -54,12 +52,10 @@ void FrameInfo::GetMissingPackets(bool newest_frame,
   }
 }
 
-
 FrameIdMap::FrameIdMap()
     : waiting_for_key_(true),
       last_released_frame_(kStartFrameId),
-      newest_frame_id_(kStartFrameId) {
-}
+      newest_frame_id_(kStartFrameId) {}
 
 FrameIdMap::~FrameIdMap() {}
 
@@ -131,9 +127,7 @@ void FrameIdMap::Clear() {
   newest_frame_id_ = kStartFrameId;
 }
 
-uint32 FrameIdMap::NewestFrameId() const {
-  return newest_frame_id_;
-}
+uint32 FrameIdMap::NewestFrameId() const { return newest_frame_id_; }
 
 bool FrameIdMap::NextContinuousFrame(uint32* frame_id) const {
   FrameMap::const_iterator it;
@@ -156,8 +150,10 @@ uint32 FrameIdMap::LastContinuousFrame() const {
   do {
     next_expected_frame++;
     it = frame_map_.find(next_expected_frame);
-    if (it == frame_map_.end()) break;
-    if (!it->second->Complete()) break;
+    if (it == frame_map_.end())
+      break;
+    if (!it->second->Complete())
+      break;
 
     // We found the next continuous frame.
     last_continuous_frame_id = it->first;
@@ -167,7 +163,8 @@ uint32 FrameIdMap::LastContinuousFrame() const {
 
 bool FrameIdMap::NextAudioFrameAllowingMissingFrames(uint32* frame_id) const {
   // First check if we have continuous frames.
-  if (NextContinuousFrame(frame_id)) return true;
+  if (NextContinuousFrame(frame_id))
+    return true;
 
   // Find the oldest frame.
   FrameMap::const_iterator it_best_match = frame_map_.end();
@@ -180,7 +177,8 @@ bool FrameIdMap::NextAudioFrameAllowingMissingFrames(uint32* frame_id) const {
       break;
     }
   }
-  if (it_best_match == frame_map_.end()) return false;  // No complete frame.
+  if (it_best_match == frame_map_.end())
+    return false;  // No complete frame.
 
   ++it;
   for (; it != frame_map_.end(); ++it) {
@@ -202,15 +200,14 @@ bool FrameIdMap::NextVideoFrameAllowingSkippingFrames(uint32* frame_id) const {
       it_best_match = it;
     }
   }
-  if (it_best_match == frame_map_.end()) return false;
+  if (it_best_match == frame_map_.end())
+    return false;
 
   *frame_id = it_best_match->first;
   return true;
 }
 
-bool FrameIdMap::Empty() const {
-  return frame_map_.empty();
-}
+bool FrameIdMap::Empty() const { return frame_map_.empty(); }
 
 int FrameIdMap::NumberOfCompleteFrames() const {
   int count = 0;
@@ -231,20 +228,24 @@ void FrameIdMap::GetMissingPackets(uint32 frame_id,
                                    bool last_frame,
                                    PacketIdSet* missing_packets) const {
   FrameMap::const_iterator it = frame_map_.find(frame_id);
-  if (it == frame_map_.end()) return;
+  if (it == frame_map_.end())
+    return;
 
   it->second->GetMissingPackets(last_frame, missing_packets);
 }
 
 bool FrameIdMap::ContinuousFrame(FrameInfo* frame) const {
   DCHECK(frame);
-  if (waiting_for_key_ && !frame->is_key_frame()) return false;
+  if (waiting_for_key_ && !frame->is_key_frame())
+    return false;
   return static_cast<uint32>(last_released_frame_ + 1) == frame->frame_id();
 }
 
 bool FrameIdMap::DecodableVideoFrame(FrameInfo* frame) const {
-  if (frame->is_key_frame()) return true;
-  if (waiting_for_key_ && !frame->is_key_frame()) return false;
+  if (frame->is_key_frame())
+    return true;
+  if (waiting_for_key_ && !frame->is_key_frame())
+    return false;
 
   // Current frame is not necessarily referencing the last frame.
   // Do we have the reference frame?

media/cast/framer/frame_id_map.h

@@ -27,8 +27,7 @@ class FrameInfo {
 
   PacketType InsertPacket(uint16 packet_id);
   bool Complete() const;
-  void GetMissingPackets(bool newest_frame,
-                         PacketIdSet* missing_packets) const;
+  void GetMissingPackets(bool newest_frame, PacketIdSet* missing_packets) const;
 
   bool is_key_frame() const { return is_key_frame_; }
   uint32 frame_id() const { return frame_id_; }

media/cast/framer/framer.cc

@@ -17,9 +17,13 @@ Framer::Framer(base::TickClock* clock,
                bool decoder_faster_than_max_frame_rate,
                int max_unacked_frames)
     : decoder_faster_than_max_frame_rate_(decoder_faster_than_max_frame_rate),
-      cast_msg_builder_(new CastMessageBuilder(clock, incoming_payload_feedback,
-          &frame_id_map_, ssrc, decoder_faster_than_max_frame_rate,
-          max_unacked_frames)) {
+      cast_msg_builder_(
+          new CastMessageBuilder(clock,
+                                 incoming_payload_feedback,
+                                 &frame_id_map_,
+                                 ssrc,
+                                 decoder_faster_than_max_frame_rate,
+                                 max_unacked_frames)) {
   DCHECK(incoming_payload_feedback) << "Invalid argument";
 }
 
@@ -82,7 +86,8 @@ bool Framer::GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame,
 
   ConstFrameIterator it = frames_.find(frame_id);
   DCHECK(it != frames_.end());
-  if (it == frames_.end()) return false;
+  if (it == frames_.end())
+    return false;
 
   return it->second->GetEncodedAudioFrame(audio_frame, rtp_timestamp);
 }
@@ -98,7 +103,8 @@ bool Framer::GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
     *next_frame = true;
   } else {
     // Check if we can skip frames when our decoder is too slow.
-    if (!decoder_faster_than_max_frame_rate_) return false;
+    if (!decoder_faster_than_max_frame_rate_)
+      return false;
 
     if (!frame_id_map_.NextVideoFrameAllowingSkippingFrames(&frame_id)) {
       return false;
@@ -108,7 +114,8 @@ bool Framer::GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
 
   ConstFrameIterator it = frames_.find(frame_id);
   DCHECK(it != frames_.end());
-  if (it == frames_.end())  return false;
+  if (it == frames_.end())
+    return false;
 
   return it->second->GetEncodedVideoFrame(video_frame, rtp_timestamp);
 }
@@ -126,7 +133,7 @@ void Framer::ReleaseFrame(uint32 frame_id) {
   // We have a frame - remove all frames with lower frame id.
   bool skipped_old_frame = false;
   FrameList::iterator it;
-  for (it = frames_.begin(); it != frames_.end(); ) {
+  for (it = frames_.begin(); it != frames_.end();) {
     if (IsOlderFrameId(it->first, frame_id)) {
       frames_.erase(it++);
       skipped_old_frame = true;
@@ -143,9 +150,7 @@ bool Framer::TimeToSendNextCastMessage(base::TimeTicks* time_to_send) {
   return cast_msg_builder_->TimeToSendNextCastMessage(time_to_send);
 }
 
-void Framer::SendCastMessage() {
-  cast_msg_builder_->UpdateCastMessage();
-}
+void Framer::SendCastMessage() { cast_msg_builder_->UpdateCastMessage(); }
 
 }  // namespace cast
 }  // namespace media