Cast: Refactoring RtpReceiver to Clang format

media/cast/rtp_receiver/rtp_parser/rtp_parser_unittest.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 <gtest/gtest.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "media/cast/rtp_receiver/rtp_parser/rtp_parser.h"
 #include "media/cast/rtp_receiver/rtp_parser/test/rtp_packet_builder.h"
 #include "media/cast/rtp_receiver/rtp_receiver.h"
 #include "media/cast/rtp_receiver/rtp_receiver_defines.h"
 
 namespace media {
 namespace cast {
 
 static const size_t kPacketLength = 1500;
 static const int kTestPayloadType = 127;
 static const uint32 kTestSsrc = 1234;
 static const uint32 kTestTimestamp = 111111;
 static const uint16 kTestSeqNum = 4321;
 static const uint8 kRefFrameId = 17;
 
 class RtpDataTest : public RtpData {
  public:
-  RtpDataTest() {
-    expected_header_.reset(new RtpCastHeader());
-  }
+  RtpDataTest() { expected_header_.reset(new RtpCastHeader()); }
 
   virtual ~RtpDataTest() {}
 
   void SetExpectedHeader(const RtpCastHeader& cast_header) {
     memcpy(expected_header_.get(), &cast_header, sizeof(RtpCastHeader));
   }
 
   virtual void OnReceivedPayloadData(const uint8* payloadData,
                                      size_t payloadSize,
                                      const RtpCastHeader* rtpHeader) OVERRIDE {
     VerifyCommonHeader(*rtpHeader);
     VerifyCastHeader(*rtpHeader);
   }
 
   void VerifyCommonHeader(const RtpCastHeader& parsed_header) {
     EXPECT_EQ(expected_header_->packet_id == expected_header_->max_packet_id,
-        parsed_header.webrtc.header.markerBit);
+              parsed_header.webrtc.header.markerBit);
     EXPECT_EQ(kTestPayloadType, parsed_header.webrtc.header.payloadType);
     EXPECT_EQ(kTestSsrc, parsed_header.webrtc.header.ssrc);
     EXPECT_EQ(0, parsed_header.webrtc.header.numCSRCs);
   }
 
   void VerifyCastHeader(const RtpCastHeader& parsed_header) {
     EXPECT_EQ(expected_header_->is_key_frame, parsed_header.is_key_frame);
     EXPECT_EQ(expected_header_->frame_id, parsed_header.frame_id);
     EXPECT_EQ(expected_header_->packet_id, parsed_header.packet_id);
     EXPECT_EQ(expected_header_->max_packet_id, parsed_header.max_packet_id);
     EXPECT_EQ(expected_header_->is_reference, parsed_header.is_reference);
   }
 
  private:
   scoped_ptr<RtpCastHeader> expected_header_;
+
+  DISALLOW_COPY_AND_ASSIGN(RtpDataTest);
 };
 
 class RtpParserTest : public ::testing::Test {
  protected:
   RtpParserTest() {
     PopulateConfig();
     rtp_data_.reset(new RtpDataTest());
     rtp_parser_.reset(new RtpParser(rtp_data_.get(), config_));
-  }
-
-  virtual ~RtpParserTest() {}
-
-  virtual void SetUp() {
     cast_header_.is_reference = true;
     cast_header_.reference_frame_id = kRefFrameId;
     packet_builder_.SetSsrc(kTestSsrc);
     packet_builder_.SetReferenceFrameId(kRefFrameId, true);
     packet_builder_.SetSequenceNumber(kTestSeqNum);
     packet_builder_.SetTimestamp(kTestTimestamp);
     packet_builder_.SetPayloadType(kTestPayloadType);
     packet_builder_.SetMarkerBit(true);  // Only one packet.
   }
 
+  virtual ~RtpParserTest() {}
+
   void PopulateConfig() {
     config_.payload_type = kTestPayloadType;
     config_.ssrc = kTestSsrc;
   }
 
   scoped_ptr<RtpDataTest> rtp_data_;
   RtpPacketBuilder packet_builder_;
   scoped_ptr<RtpParser> rtp_parser_;
   RtpParserConfig config_;
   RtpCastHeader cast_header_;
@@ skipping 96 matching lines @@
   uint8 packet[kPacketLength];
   packet_builder_.BuildHeader(packet, kPacketLength);
   // Parse packet as is.
   RtpCastHeader rtp_header;
   rtp_data_->SetExpectedHeader(cast_header_);
   EXPECT_TRUE(rtp_parser_->ParsePacket(packet, kPacketLength, &rtp_header));
 }
 
 }  //  namespace cast
 }  //  namespace media