Cast: Refactor framer to Clang format

media/cast/framer/frame_id_map.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/frame_id_map.h"
 
 #include "base/logging.h"
 #include "media/cast/rtp_receiver/rtp_receiver_defines.h"
 
 namespace media {
@@ skipping 20 matching lines @@
     return kDuplicatePacket;
   }
   // Update the last received packet id.
   if (IsNewerPacketId(packet_id, max_received_packet_id_)) {
     max_received_packet_id_ = packet_id;
   }
   missing_packets_.erase(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 {
   if (newest_frame) {
     // Missing packets capped by max_received_packet_id_.
     PacketIdSet::const_iterator it_after_last_received =
         missing_packets_.lower_bound(max_received_packet_id_);
     missing_packets->insert(missing_packets_.begin(), it_after_last_received);
   } else {
     missing_packets->insert(missing_packets_.begin(), missing_packets_.end());
   }
 }
 
-
 FrameIdMap::FrameIdMap()
     : waiting_for_key_(true),
       last_released_frame_(kStartFrameId),
-      newest_frame_id_(kStartFrameId) {
-}
+      newest_frame_id_(kStartFrameId) {}
 
 FrameIdMap::~FrameIdMap() {}
 
 PacketType FrameIdMap::InsertPacket(const RtpCastHeader& rtp_header) {
   uint32 frame_id = rtp_header.frame_id;
   uint32 reference_frame_id;
   if (rtp_header.is_reference) {
     reference_frame_id = rtp_header.reference_frame_id;
   } else {
     reference_frame_id = static_cast<uint32>(frame_id - 1);
@@ skipping 51 matching lines @@
   last_released_frame_ = frame_id;
 }
 
 void FrameIdMap::Clear() {
   frame_map_.clear();
   waiting_for_key_ = true;
   last_released_frame_ = kStartFrameId;
   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;
 
   for (it = frame_map_.begin(); it != frame_map_.end(); ++it) {
     if (it->second->Complete() && ContinuousFrame(it->second.get())) {
       *frame_id = it->first;
       return true;
     }
   }
   return false;
 }
 
 uint32 FrameIdMap::LastContinuousFrame() const {
   uint32 last_continuous_frame_id = last_released_frame_;
   uint32 next_expected_frame = last_released_frame_;
 
   FrameMap::const_iterator it;
 
   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;
   } while (next_expected_frame != newest_frame_id_);
   return last_continuous_frame_id;
 }
 
 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();
   FrameMap::const_iterator it;
 
   // Find first complete frame.
   for (it = frame_map_.begin(); it != frame_map_.end(); ++it) {
     if (it->second->Complete()) {
       it_best_match = it;
       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) {
     if (it->second->Complete() &&
         IsOlderFrameId(it->first, it_best_match->first)) {
       it_best_match = it;
     }
   }
   *frame_id = it_best_match->first;
   return true;
 }
 
 bool FrameIdMap::NextVideoFrameAllowingSkippingFrames(uint32* frame_id) const {
   // Find the oldest decodable frame.
   FrameMap::const_iterator it_best_match = frame_map_.end();
   FrameMap::const_iterator it;
   for (it = frame_map_.begin(); it != frame_map_.end(); ++it) {
     if (it->second->Complete() && DecodableVideoFrame(it->second.get())) {
       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;
   FrameMap::const_iterator it;
   for (it = frame_map_.begin(); it != frame_map_.end(); ++it) {
     if (it->second->Complete()) {
       ++count;
     }
   }
   return count;
 }
 
 bool FrameIdMap::FrameExists(uint32 frame_id) const {
   return frame_map_.end() != frame_map_.find(frame_id);
 }
 
 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?
   if (IsOlderFrameId(frame->referenced_frame_id(), last_released_frame_)) {
     return true;
   }
   return frame->referenced_frame_id() == last_released_frame_;
 }
 
 }  //  namespace cast
 }  //  namespace media