Cleanup: Remove unneeded scoped_ptr.h includes from content.

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"
-#include "content/common/gpu/media/h264_parser.h"
 
 namespace content {
 
 bool H264SliceHeader::IsPSlice() const {
   return (slice_type % 5 == kPSlice);
 }
 
 bool H264SliceHeader::IsBSlice() const {
   return (slice_type % 5 == kBSlice);
 }
@@ skipping 126 matching lines @@
 }
 
 #define READ_BITS_OR_RETURN(num_bits, out)                                    \
 do {                                                                          \
   int _out;                                                                   \
   if (!br_.ReadBits(num_bits, &_out)) {                                       \
     DVLOG(1) << "Error in stream: unexpected EOS while trying to read " #out; \
     return kInvalidStream;                                                    \
   }                                                                           \
   *out = _out;                                                                \
-} while(0)
+} while (0)
 
 #define READ_UE_OR_RETURN(out)                                               \
 do {                                                                         \
   if (ReadUE(out) != kOk) {                                                  \
     DVLOG(1) << "Error in stream: invalid value while trying to read " #out; \
     return kInvalidStream;                                                   \
   }                                                                          \
-} while(0)
+} while (0)
 
 #define READ_SE_OR_RETURN(out)                                               \
 do {                                                                         \
   if (ReadSE(out) != kOk) {                                                  \
     DVLOG(1) << "Error in stream: invalid value while trying to read " #out; \
     return kInvalidStream;                                                   \
   }                                                                          \
-} while(0)
+} while (0)
 
 #define IN_RANGE_OR_RETURN(val, min, max)                                 \
 do {                                                                      \
   if ((val) < (min) || (val) > (max)) {                                   \
     DVLOG(1) << "Error in stream: invalid value, expected " #val " to be" \
              << " in range [" << (min) << ":" << (max) << "]"             \
              << " found " << (val) << " instead";                         \
     return kInvalidStream;                                                \
   }                                                                       \
-} while(0)
+} while (0)
 
 #define TRUE_OR_RETURN(a)                                          \
 do {                                                               \
   if (!(a)) {                                                      \
     DVLOG(1) << "Error in stream: invalid value, expected " << #a; \
     return kInvalidStream;                                         \
   }                                                                \
-} while(0)
+} while (0)
 
 H264Parser::H264Parser() {
   Reset();
 }
 
 H264Parser::~H264Parser() {
   STLDeleteValues(&active_SPSes_);
   STLDeleteValues(&active_PPSes_);
 }
 
@@ skipping 19 matching lines @@
 }
 
 static inline bool IsStartCode(const uint8* data) {
   return data[0] == 0x00 && data[1] == 0x00 && data[2] == 0x01;
 }
 
 // Find offset from start of data to next NALU start code
 // and size of found start code (3 or 4 bytes).
 static bool FindStartCode(const uint8* data, off_t data_size,
                           off_t* offset,
-                          off_t *start_code_size) {
+                          off_t* start_code_size) {
   off_t bytes_left = data_size;
 
   while (bytes_left > 3) {
     if (IsStartCode(data)) {
       // Found three-byte start code, set pointer at its beginning.
       *offset = data_size - bytes_left;
       *start_code_size = 3;
 
       // If there is a zero byte before this start code,
       // then it's actually a four-byte start code, so backtrack one byte.
@@ skipping 577 matching lines @@
   *pps_id = pps->pic_parameter_set_id;
   delete active_PPSes_[*pps_id];
   active_PPSes_[*pps_id] = pps.release();
 
   return kOk;
 }
 
 H264Parser::Result H264Parser::ParseRefPicListModification(
     int num_ref_idx_active_minus1,
     H264ModificationOfPicNum* ref_list_mods) {
-  H264ModificationOfPicNum *pic_num_mod;
+  H264ModificationOfPicNum* pic_num_mod;
 
   if (num_ref_idx_active_minus1 >= 32)
     return kInvalidStream;
 
   for (int i = 0; i < 32; ++i) {
     pic_num_mod = &ref_list_mods[i];
     READ_UE_OR_RETURN(&pic_num_mod->modification_of_pic_nums_idc);
     TRUE_OR_RETURN(pic_num_mod->modification_of_pic_nums_idc < 4);
 
     switch (pic_num_mod->modification_of_pic_nums_idc) {
@@ skipping 122 matching lines @@
                                 shdr->chroma_log2_weight_denom,
                                 &shdr->pred_weight_table_l1);
     if (res != kOk)
       return res;
   }
 
   return kOk;
 }
 
 H264Parser::Result H264Parser::ParseDecRefPicMarking(H264SliceHeader *shdr) {
-
   if (shdr->idr_pic_flag) {
     READ_BITS_OR_RETURN(1, &shdr->no_output_of_prior_pics_flag);
     READ_BITS_OR_RETURN(1, &shdr->long_term_reference_flag);
   } else {
     READ_BITS_OR_RETURN(1, &shdr->adaptive_ref_pic_marking_mode_flag);
 
     H264DecRefPicMarking* marking;
     if (shdr->adaptive_ref_pic_marking_mode_flag) {
       size_t i;
       for (i = 0; i < arraysize(shdr->ref_pic_marking); ++i) {
@@ skipping 208 matching lines @@
       break;
 
     default:
       DVLOG(4) << "Unsupported SEI message";
       break;
   }
 
   return kOk;
 }
 
-} // namespace content
-
+}  // namespace content