Cleanup: avoid foo ? true : false, part 1.

content/common/gpu/media/h264_parser.cc

 // Copyright (c) 2012 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 "content/common/gpu/media/h264_parser.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 
@@ skipping 102 matching lines @@
   STLDeleteValues(&active_PPSes_);
 }
 
 void H264Parser::Reset() {
   stream_ = NULL;
   bytes_left_ = 0;
 }
 
 void H264Parser::SetStream(const uint8* stream, off_t stream_size) {
   DCHECK(stream);
-  DCHECK(stream_size > 0);
+  DCHECK_GT(stream_size, 0);
 
   stream_ = stream;
   bytes_left_ = stream_size;
 }
 
 const H264PPS* H264Parser::GetPPS(int pps_id) {
   return active_PPSes_[pps_id];
 }
 
 const H264SPS* H264Parser::GetSPS(int sps_id) {
@@ skipping 140 matching lines @@
   stream_ += off_to_nalu_start + nalu->size;
   bytes_left_ -= off_to_nalu_start + nalu->size;
 
   // Read NALU header, skip the forbidden_zero_bit, but check for it.
   READ_BITS_OR_RETURN(1, &data);
   TRUE_OR_RETURN(data == 0);
 
   READ_BITS_OR_RETURN(2, &nalu->nal_ref_idc);
   READ_BITS_OR_RETURN(5, &nalu->nal_unit_type);
 
-  DVLOG(4) << "NALU type: " << (int)nalu->nal_unit_type
-           << " at: " << (void*)nalu->data << " size: " << nalu->size
-           << " ref: " << (int)nalu->nal_ref_idc;
+  DVLOG(4) << "NALU type: " << static_cast<int>(nalu->nal_unit_type)
+           << " at: " << reinterpret_cast<const void*>(nalu->data)
+           << " size: " << nalu->size
+           << " ref: " << static_cast<int>(nalu->nal_ref_idc);
 
   return kOk;
 }
 
 // Default scaling lists (per spec).
 static const int kDefault4x4Intra[kH264ScalingList4x4Length] = {
   6, 13, 13, 20, 20, 20, 28, 28, 28, 28, 32, 32, 32, 37, 37, 42, };
 
 static const int kDefault4x4Inter[kH264ScalingList4x4Length] = {
   10, 14, 14, 20, 20, 20, 24, 24, 24, 24, 27, 27, 27, 30, 30, 34, };
 
 static const int kDefault8x8Intra[kH264ScalingList8x8Length] = {
   6, 10, 10, 13, 11, 13, 16, 16, 16, 16, 18, 18, 18, 18, 18, 23,
   23, 23, 23, 23, 23, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27,
   27, 27, 27, 27, 29, 29, 29, 29, 29, 29, 29, 31, 31, 31, 31, 31,
   31, 33, 33, 33, 33, 33, 36, 36, 36, 36, 38, 38, 38, 40, 40, 42, };
 
 static const int kDefault8x8Inter[kH264ScalingList8x8Length] = {
   9, 13, 13, 15, 13, 15, 17, 17, 17, 17, 19, 19, 19, 19, 19, 21,
   21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 24, 24, 24, 24,
   24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27,
   27, 28, 28, 28, 28, 28, 30, 30, 30, 30, 32, 32, 32, 33, 33, 35, };
 
 static inline void DefaultScalingList4x4(
     int i,
     int scaling_list4x4[][kH264ScalingList4x4Length]) {
-  DCHECK(i < 6);
+  DCHECK_LT(i, 6);
 
   if (i < 3)
     memcpy(scaling_list4x4[i], kDefault4x4Intra, sizeof(kDefault4x4Intra));
   else if (i < 6)
     memcpy(scaling_list4x4[i], kDefault4x4Inter, sizeof(kDefault4x4Inter));
 }
 
 static inline void DefaultScalingList8x8(
     int i,
     int scaling_list8x8[][kH264ScalingList8x8Length]) {
-  DCHECK(i < 6);
+  DCHECK_LT(i, 6);
 
   if (i % 2 == 0)
     memcpy(scaling_list8x8[i], kDefault8x8Intra, sizeof(kDefault8x8Intra));
   else
     memcpy(scaling_list8x8[i], kDefault8x8Inter, sizeof(kDefault8x8Inter));
 }
 
 static void FallbackScalingList4x4(
     int i,
     const int default_scaling_list_intra[],
@@ skipping 222 matching lines @@
 }
 
 static void FillDefaultSeqScalingLists(H264SPS* sps) {
   for (int i = 0; i < 6; ++i)
     for (int j = 0; j < kH264ScalingList4x4Length; ++j)
       sps->scaling_list4x4[i][j] = 16;
 
   for (int i = 0; i < 6; ++i)
     for (int j = 0; j < kH264ScalingList8x8Length; ++j)
       sps->scaling_list8x8[i][j] = 16;
-
 }
 
 H264Parser::Result H264Parser::ParseSPS(int* sps_id) {
   // See 7.4.2.1.
   int data;
   Result res;
 
   *sps_id = -1;
 
   scoped_ptr<H264SPS> sps(new H264SPS());
@@ skipping 366 matching lines @@
 
 H264Parser::Result H264Parser::ParseSliceHeader(const H264NALU& nalu,
                                                 H264SliceHeader* shdr) {
   // See 7.4.3.
   const H264SPS* sps;
   const H264PPS* pps;
   Result res;
 
   memset(shdr, 0, sizeof(*shdr));
 
-  shdr->idr_pic_flag = ((nalu.nal_unit_type == 5) ? true : false);
+  shdr->idr_pic_flag = (nalu.nal_unit_type == 5);
   shdr->nal_ref_idc = nalu.nal_ref_idc;
   shdr->nalu_data = nalu.data;
   shdr->nalu_size = nalu.size;
 
   READ_UE_OR_RETURN(&shdr->first_mb_in_slice);
   READ_UE_OR_RETURN(&shdr->slice_type);
   TRUE_OR_RETURN(shdr->slice_type < 10);
 
   READ_UE_OR_RETURN(&shdr->pic_parameter_set_id);
 
@@ skipping 158 matching lines @@
 
     default:
       DVLOG(4) << "Unsupported SEI message";
       break;
   }
 
   return kOk;
 }
 
 }  // namespace content