[rtp_rtcp] lint whitespace warning removed from most source/ files

webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.cc

 /*
  *  Copyright (c) 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 19 matching lines @@
       min_parent_size_(std::numeric_limits<int>::max()),
       packet_start_(false) {
   // If |this_size_| > INT_MAX, Cost() and CreateChildren() won't work properly.
   assert(this_size_ <= static_cast<size_t>(std::numeric_limits<int>::max()));
   children_[kLeftChild] = NULL;
   children_[kRightChild] = NULL;
 }
 
 PartitionTreeNode* PartitionTreeNode::CreateRootNode(const size_t* size_vector,
                                                      size_t num_partitions) {
-  PartitionTreeNode* root_node =
-      new PartitionTreeNode(NULL, &size_vector[1], num_partitions - 1,
-                            size_vector[0]);
+  PartitionTreeNode* root_node = new PartitionTreeNode(
+      NULL, &size_vector[1], num_partitions - 1, size_vector[0]);
   root_node->set_packet_start(true);
   return root_node;
 }
 
 PartitionTreeNode::~PartitionTreeNode() {
   delete children_[kLeftChild];
   delete children_[kRightChild];
 }
 
 int PartitionTreeNode::Cost(size_t penalty) {
   int cost = 0;
   if (num_partitions_ == 0) {
     // This is a solution node.
     cost = std::max(max_parent_size_, this_size_int()) -
-        std::min(min_parent_size_, this_size_int());
+           std::min(min_parent_size_, this_size_int());
   } else {
     cost = std::max(max_parent_size_, this_size_int()) - min_parent_size_;
   }
   return cost + NumPackets() * penalty;
 }
 
 bool PartitionTreeNode::CreateChildren(size_t max_size) {
   assert(max_size > 0);
   bool children_created = false;
   if (num_partitions_ > 0) {
     if (this_size_ + size_vector_[0] <= max_size) {
       assert(!children_[kLeftChild]);
       children_[kLeftChild] =
-          new PartitionTreeNode(this,
-                                &size_vector_[1],
-                                num_partitions_ - 1,
+          new PartitionTreeNode(this, &size_vector_[1], num_partitions_ - 1,
                                 this_size_ + size_vector_[0]);
       children_[kLeftChild]->set_max_parent_size(max_parent_size_);
       children_[kLeftChild]->set_min_parent_size(min_parent_size_);
       // "Left" child is continuation of same packet.
       children_[kLeftChild]->set_packet_start(false);
       children_created = true;
     }
     if (this_size_ > 0) {
       assert(!children_[kRightChild]);
-      children_[kRightChild] = new PartitionTreeNode(this,
-                                                     &size_vector_[1],
-                                                     num_partitions_ - 1,
-                                                     size_vector_[0]);
+      children_[kRightChild] = new PartitionTreeNode(
+          this, &size_vector_[1], num_partitions_ - 1, size_vector_[0]);
       children_[kRightChild]->set_max_parent_size(
           std::max(max_parent_size_, this_size_int()));
       children_[kRightChild]->set_min_parent_size(
           std::min(min_parent_size_, this_size_int()));
       // "Right" child starts a new packet.
       children_[kRightChild]->set_packet_start(true);
       children_created = true;
     }
   }
   return children_created;
@@ skipping 44 matching lines @@
       if (second->Cost(penalty) < first->Cost(penalty)) {
         return second;
       }
     }
     return first;
   }
 }
 
 Vp8PartitionAggregator::Vp8PartitionAggregator(
     const RTPFragmentationHeader& fragmentation,
-    size_t first_partition_idx, size_t last_partition_idx)
+    size_t first_partition_idx,
+    size_t last_partition_idx)
     : root_(NULL),
       num_partitions_(last_partition_idx - first_partition_idx + 1),
       size_vector_(new size_t[num_partitions_]),
       largest_partition_size_(0) {
   assert(last_partition_idx >= first_partition_idx);
   assert(last_partition_idx < fragmentation.fragmentationVectorSize);
   for (size_t i = 0; i < num_partitions_; ++i) {
     size_vector_[i] =
         fragmentation.fragmentationLength[i + first_partition_idx];
-    largest_partition_size_ = std::max(largest_partition_size_,
-                                       size_vector_[i]);
+    largest_partition_size_ =
+        std::max(largest_partition_size_, size_vector_[i]);
   }
   root_ = PartitionTreeNode::CreateRootNode(size_vector_, num_partitions_);
 }
 
 Vp8PartitionAggregator::~Vp8PartitionAggregator() {
-  delete [] size_vector_;
+  delete[] size_vector_;
   delete root_;
 }
 
 void Vp8PartitionAggregator::SetPriorMinMax(int min_size, int max_size) {
   assert(root_);
   assert(min_size >= 0);
   assert(max_size >= min_size);
   root_->set_min_parent_size(min_size);
   root_->set_max_parent_size(max_size);
 }
 
 Vp8PartitionAggregator::ConfigVec
 Vp8PartitionAggregator::FindOptimalConfiguration(size_t max_size,
                                                  size_t penalty) {
   assert(root_);
   assert(max_size >= largest_partition_size_);
   PartitionTreeNode* opt = root_->GetOptimalNode(max_size, penalty);
   ConfigVec config_vector(num_partitions_, 0);
   PartitionTreeNode* temp_node = opt;
   size_t packet_index = opt->NumPackets();
   for (size_t i = num_partitions_; i > 0; --i) {
     assert(packet_index > 0);
     assert(temp_node != NULL);
     config_vector[i - 1] = packet_index - 1;
-    if (temp_node->packet_start()) --packet_index;
+    if (temp_node->packet_start())
+      --packet_index;
     temp_node = temp_node->parent();
   }
   return config_vector;
 }
 
 void Vp8PartitionAggregator::CalcMinMax(const ConfigVec& config,
-                                        int* min_size, int* max_size) const {
+                                        int* min_size,
+                                        int* max_size) const {
   if (*min_size < 0) {
     *min_size = std::numeric_limits<int>::max();
   }
   if (*max_size < 0) {
     *max_size = 0;
   }
   size_t i = 0;
   while (i < config.size()) {
     size_t this_size = 0;
     size_t j = i;
@@ skipping 45 matching lines @@
     } else {
       cost = n * penalty;
     }
     if (fragment_size <= max_payload_size && cost < best_cost) {
       num_fragments = n;
       best_cost = cost;
     }
   }
   assert(num_fragments > 0);
   // TODO(mflodman) Assert disabled since it's falsely triggered, see issue 293.
-  //assert(large_partition_size / num_fragments + 1 <= max_payload_size);
+  // assert(large_partition_size / num_fragments + 1 <= max_payload_size);
   return num_fragments;
 }
 
 }  // namespace