Remove kint64max.

media/filters/chunk_demuxer.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 "media/filters/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 
@@ skipping 100 matching lines @@
                 encrypted_media_init_data_cb,
             const NewTextTrackCB& new_text_track_cb);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred. |*timestamp_offset| is used and possibly updated by the
   // append. |append_window_start| and |append_window_end| correspond to the MSE
   // spec's similarly named source buffer attributes that are used in coded
   // frame processing. |init_segment_received_cb| is run for each new fully
   // parsed initialization segment.
-  bool Append(const uint8* data,
+  bool Append(const uint8_t* data,
               size_t length,
               TimeDelta append_window_start,
               TimeDelta append_window_end,
               TimeDelta* timestamp_offset,
               const InitSegmentReceivedCB& init_segment_received_cb);
 
   // Aborts the current append sequence and resets the parser.
   void ResetParserState(TimeDelta append_window_start,
                         TimeDelta append_window_end,
                         TimeDelta* timestamp_offset);
@@ skipping 186 matching lines @@
 }
 
 void SourceState::SetGroupStartTimestampIfInSequenceMode(
     base::TimeDelta timestamp_offset) {
   DCHECK(!parsing_media_segment_);
 
   frame_processor_->SetGroupStartTimestampIfInSequenceMode(timestamp_offset);
 }
 
 bool SourceState::Append(
-    const uint8* data,
+    const uint8_t* data,
     size_t length,
     TimeDelta append_window_start,
     TimeDelta append_window_end,
     TimeDelta* timestamp_offset,
     const InitSegmentReceivedCB& init_segment_received_cb) {
   DCHECK(timestamp_offset);
   DCHECK(!timestamp_offset_during_append_);
   DCHECK(!init_segment_received_cb.is_null());
   DCHECK(init_segment_received_cb_.is_null());
   append_window_start_during_append_ = append_window_start;
@@ skipping 1107 matching lines @@
   SourceStateMap::const_iterator itr = source_state_map_.find(id);
   if (itr == source_state_map_.end()) {
     LOG(WARNING) << __FUNCTION__ << " stream " << id << " not found";
     return false;
   }
   return itr->second->EvictCodedFrames(media_time_dts, newDataSize);
 }
 
 void ChunkDemuxer::AppendData(
     const std::string& id,
-    const uint8* data,
+    const uint8_t* data,
     size_t length,
     TimeDelta append_window_start,
     TimeDelta append_window_end,
     TimeDelta* timestamp_offset,
     const InitSegmentReceivedCB& init_segment_received_cb) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
   DCHECK(!id.empty());
   DCHECK(timestamp_offset);
   DCHECK(!init_segment_received_cb.is_null());
@@ skipping 120 matching lines @@
   DCHECK_GE(duration, 0);
 
   if (duration == GetDuration_Locked())
     return;
 
   // Compute & bounds check the TimeDelta representation of duration.
   // This can be different if the value of |duration| doesn't fit the range or
   // precision of TimeDelta.
   TimeDelta min_duration = TimeDelta::FromInternalValue(1);
   // Don't use TimeDelta::Max() here, as we want the largest finite time delta.
-  TimeDelta max_duration = TimeDelta::FromInternalValue(kint64max - 1);
+  TimeDelta max_duration =
+      TimeDelta::FromInternalValue(std::numeric_limits<int64_t>::max() - 1);
   double min_duration_in_seconds = min_duration.InSecondsF();
   double max_duration_in_seconds = max_duration.InSecondsF();
 
   TimeDelta duration_td;
   if (duration == std::numeric_limits<double>::infinity()) {
     duration_td = media::kInfiniteDuration();
   } else if (duration < min_duration_in_seconds) {
     duration_td = min_duration;
   } else if (duration > max_duration_in_seconds) {
     duration_td = max_duration;
@@ skipping 356 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media