Remove kint64max.

media/formats/webm/webm_parser.cc

 // Copyright 2014 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/formats/webm/webm_parser.h"
 
 // This file contains code to parse WebM file elements. It was created
 // from information in the Matroska spec.
 // http://www.matroska.org/technical/specs/index.html
 // This file contains code for encrypted WebM. Current WebM
 // encrypted request for comments specification is here
 // http://wiki.webmproject.org/encryption/webm-encryption-rfc
 
 #include <iomanip>
+#include <limits>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/formats/webm/webm_constants.h"
 
 namespace media {
 
 enum ElementType {
   UNKNOWN,
   LIST,  // Referred to as Master Element in the Matroska spec.
@@ skipping 391 matching lines @@
 // |size| - The number of bytes in |buf|
 // |max_bytes| - The maximum number of bytes the field can be. ID fields
 //               set this to 4 & element size fields set this to 8. If the
 //               first byte indicates a larger field size than this it is a
 //               parser error.
 // |mask_first_byte| - For element size fields the field length encoding bits
 //                     need to be masked off. This parameter is true for
 //                     element size fields and is false for ID field values.
 //
 // Returns: The number of bytes parsed on success. -1 on error.
-static int ParseWebMElementHeaderField(const uint8* buf, int size,
-                                       int max_bytes, bool mask_first_byte,
-                                       int64* num) {
+static int ParseWebMElementHeaderField(const uint8_t* buf,
+                                       int size,
+                                       int max_bytes,
+                                       bool mask_first_byte,
+                                       int64_t* num) {
   DCHECK(buf);
   DCHECK(num);
 
   if (size < 0)
     return -1;
 
   if (size == 0)
     return 0;
 
   int mask = 0x80;
-  uint8 ch = buf[0];
+  uint8_t ch = buf[0];
   int extra_bytes = -1;
   bool all_ones = false;
   for (int i = 0; i < max_bytes; ++i) {
     if ((ch & mask) != 0) {
       mask = ~mask & 0xff;
       *num = mask_first_byte ? ch & mask : ch;
       all_ones = (ch & mask) == mask;
       extra_bytes = i;
       break;
     }
     mask = 0x80 | mask >> 1;
   }
 
   if (extra_bytes == -1)
     return -1;
 
   // Return 0 if we need more data.
   if ((1 + extra_bytes) > size)
     return 0;
 
   int bytes_used = 1;
 
   for (int i = 0; i < extra_bytes; ++i) {
     ch = buf[bytes_used++];
     all_ones &= (ch == 0xff);
     *num = (*num << 8) | ch;
   }
 
   if (all_ones)
-    *num = kint64max;
+    *num = std::numeric_limits<int64_t>::max();
 
   return bytes_used;
 }
 
-int WebMParseElementHeader(const uint8* buf, int size,
-                           int* id, int64* element_size) {
+int WebMParseElementHeader(const uint8_t* buf,
+                           int size,
+                           int* id,
+                           int64_t* element_size) {
   DCHECK(buf);
   DCHECK_GE(size, 0);
   DCHECK(id);
   DCHECK(element_size);
 
   if (size == 0)
     return 0;
 
-  int64 tmp = 0;
+  int64_t tmp = 0;
   int num_id_bytes = ParseWebMElementHeaderField(buf, size, 4, false, &tmp);
 
   if (num_id_bytes <= 0)
     return num_id_bytes;
 
-  if (tmp == kint64max)
+  if (tmp == std::numeric_limits<int64_t>::max())
     tmp = kWebMReservedId;
 
   *id = static_cast<int>(tmp);
 
   int num_size_bytes = ParseWebMElementHeaderField(buf + num_id_bytes,
                                                    size - num_id_bytes,
                                                    8, true, &tmp);
 
   if (num_size_bytes <= 0)
     return num_size_bytes;
 
-  if (tmp == kint64max)
+  if (tmp == std::numeric_limits<int64_t>::max())
     tmp = kWebMUnknownSize;
 
   *element_size = tmp;
   DVLOG(3) << "WebMParseElementHeader() : id " << std::hex << *id << std::dec
            << " size " << *element_size;
   return num_id_bytes + num_size_bytes;
 }
 
 // Finds ElementType for a specific ID.
 static ElementType FindIdType(int id,
@@ skipping 23 matching lines @@
 }
 
 static int FindListLevel(int id) {
   const ListElementInfo* list_info = FindListInfo(id);
   if (list_info)
     return list_info->level_;
 
   return -1;
 }
 
-static int ParseUInt(const uint8* buf, int size, int id,
+static int ParseUInt(const uint8_t* buf,
+                     int size,
+                     int id,
                      WebMParserClient* client) {
   if ((size <= 0) || (size > 8))
     return -1;
 
   // Read in the big-endian integer.
-  uint64 value = 0;
+  uint64_t value = 0;
   for (int i = 0; i < size; ++i)
     value = (value << 8) | buf[i];
 
-  // We use int64 in place of uint64 everywhere for convenience.  See this bug
+  // We use int64_t in place of uint64_t everywhere for convenience.  See this
+  // bug
   // for more details: http://crbug.com/366750#c3
-  if (!base::IsValueInRangeForNumericType<int64>(value))
+  if (!base::IsValueInRangeForNumericType<int64_t>(value))
     return -1;
 
   if (!client->OnUInt(id, value))
     return -1;
 
   return size;
 }
 
-static int ParseFloat(const uint8* buf, int size, int id,
+static int ParseFloat(const uint8_t* buf,
+                      int size,
+                      int id,
                       WebMParserClient* client) {
-
   if ((size != 4) && (size != 8))
     return -1;
 
   double value = -1;
 
   // Read the bytes from big-endian form into a native endian integer.
-  int64 tmp = 0;
+  int64_t tmp = 0;
   for (int i = 0; i < size; ++i)
     tmp = (tmp << 8) | buf[i];
 
   // Use a union to convert the integer bit pattern into a floating point
   // number.
   if (size == 4) {
     union {
-      int32 src;
+      int32_t src;
       float dst;
     } tmp2;
-    tmp2.src = static_cast<int32>(tmp);
+    tmp2.src = static_cast<int32_t>(tmp);
     value = tmp2.dst;
   } else if (size == 8) {
     union {
-      int64 src;
+      int64_t src;
       double dst;
     } tmp2;
     tmp2.src = tmp;
     value = tmp2.dst;
   } else {
     return -1;
   }
 
   if (!client->OnFloat(id, value))
     return -1;
 
   return size;
 }
 
-static int ParseBinary(const uint8* buf, int size, int id,
+static int ParseBinary(const uint8_t* buf,
+                       int size,
+                       int id,
                        WebMParserClient* client) {
   return client->OnBinary(id, buf, size) ? size : -1;
 }
 
-static int ParseString(const uint8* buf, int size, int id,
+static int ParseString(const uint8_t* buf,
+                       int size,
+                       int id,
                        WebMParserClient* client) {
-  const uint8* end = static_cast<const uint8*>(memchr(buf, '\0', size));
+  const uint8_t* end = static_cast<const uint8_t*>(memchr(buf, '\0', size));
   int length = (end != NULL) ? static_cast<int>(end - buf) : size;
   std::string str(reinterpret_cast<const char*>(buf), length);
   return client->OnString(id, str) ? size : -1;
 }
 
-static int ParseNonListElement(ElementType type, int id, int64 element_size,
-                               const uint8* buf, int size,
+static int ParseNonListElement(ElementType type,
+                               int id,
+                               int64_t element_size,
+                               const uint8_t* buf,
+                               int size,
                                WebMParserClient* client) {
   DCHECK_GE(size, element_size);
 
   int result = -1;
   switch(type) {
     case LIST:
       NOTIMPLEMENTED();
       result = -1;
       break;
     case UINT:
@@ skipping 26 matching lines @@
 WebMParserClient* WebMParserClient::OnListStart(int id) {
   DVLOG(1) << "Unexpected list element start with ID " << std::hex << id;
   return NULL;
 }
 
 bool WebMParserClient::OnListEnd(int id) {
   DVLOG(1) << "Unexpected list element end with ID " << std::hex << id;
   return false;
 }
 
-bool WebMParserClient::OnUInt(int id, int64 val) {
+bool WebMParserClient::OnUInt(int id, int64_t val) {
   DVLOG(1) << "Unexpected unsigned integer element with ID " << std::hex << id;
   return false;
 }
 
 bool WebMParserClient::OnFloat(int id, double val) {
   DVLOG(1) << "Unexpected float element with ID " << std::hex << id;
   return false;
 }
 
-bool WebMParserClient::OnBinary(int id, const uint8* data, int size) {
+bool WebMParserClient::OnBinary(int id, const uint8_t* data, int size) {
   DVLOG(1) << "Unexpected binary element with ID " << std::hex << id;
   return false;
 }
 
 bool WebMParserClient::OnString(int id, const std::string& str) {
   DVLOG(1) << "Unexpected string element with ID " << std::hex << id;
   return false;
 }
 
 WebMListParser::WebMListParser(int id, WebMParserClient* client)
     : state_(NEED_LIST_HEADER),
       root_id_(id),
       root_level_(FindListLevel(id)),
       root_client_(client) {
   DCHECK_GE(root_level_, 0);
   DCHECK(client);
 }
 
 WebMListParser::~WebMListParser() {}
 
 void WebMListParser::Reset() {
   ChangeState(NEED_LIST_HEADER);
   list_state_stack_.clear();
 }
 
-int WebMListParser::Parse(const uint8* buf, int size) {
+int WebMListParser::Parse(const uint8_t* buf, int size) {
   DCHECK(buf);
 
   if (size < 0 || state_ == PARSE_ERROR || state_ == DONE_PARSING_LIST)
     return -1;
 
   if (size == 0)
     return 0;
 
-  const uint8* cur = buf;
+  const uint8_t* cur = buf;
   int cur_size = size;
   int bytes_parsed = 0;
 
   while (cur_size > 0 && state_ != PARSE_ERROR && state_ != DONE_PARSING_LIST) {
     int element_id = 0;
-    int64 element_size = 0;
+    int64_t element_size = 0;
     int result = WebMParseElementHeader(cur, cur_size, &element_id,
                                         &element_size);
 
     if (result < 0)
       return result;
 
     if (result == 0)
       return bytes_parsed;
 
     switch(state_) {
@@ skipping 13 matching lines @@
 
         ChangeState(INSIDE_LIST);
         if (!OnListStart(root_id_, element_size))
           return -1;
 
         break;
       }
 
       case INSIDE_LIST: {
         int header_size = result;
-        const uint8* element_data = cur + header_size;
+        const uint8_t* element_data = cur + header_size;
         int element_data_size = cur_size - header_size;
 
         if (element_size < element_data_size)
           element_data_size = element_size;
 
         result = ParseListElement(header_size, element_id, element_size,
                                   element_data, element_data_size);
 
         DCHECK_LE(result, header_size + element_data_size);
         if (result < 0) {
@@ skipping 23 matching lines @@
 
 bool WebMListParser::IsParsingComplete() const {
   return state_ == DONE_PARSING_LIST;
 }
 
 void WebMListParser::ChangeState(State new_state) {
   state_ = new_state;
 }
 
 int WebMListParser::ParseListElement(int header_size,
-                                     int id, int64 element_size,
-                                     const uint8* data, int size) {
+                                     int id,
+                                     int64_t element_size,
+                                     const uint8_t* data,
+                                     int size) {
   DCHECK_GT(list_state_stack_.size(), 0u);
 
   ListState& list_state = list_state_stack_.back();
   DCHECK(list_state.element_info_);
 
   const ListElementInfo* element_info = list_state.element_info_;
   ElementType id_type =
       FindIdType(id, element_info->id_info_, element_info->id_info_count_);
 
   // Unexpected ID.
@@ skipping 12 matching lines @@
       return -1;
 
     // Check to see if all open lists have ended.
     if (list_state_stack_.size() == 0)
       return 0;
 
     list_state = list_state_stack_.back();
   }
 
   // Make sure the whole element can fit inside the current list.
-  int64 total_element_size = header_size + element_size;
+  int64_t total_element_size = header_size + element_size;
   if (list_state.size_ != kWebMUnknownSize &&
       list_state.size_ < list_state.bytes_parsed_ + total_element_size) {
     return -1;
   }
 
   if (id_type == LIST) {
     list_state.bytes_parsed_ += header_size;
 
     if (!OnListStart(id, element_size))
       return -1;
@@ skipping 21 matching lines @@
 
   // See if we have reached the end of the current list.
   if (list_state.bytes_parsed_ == list_state.size_) {
     if (!OnListEnd())
       return -1;
   }
 
   return result;
 }
 
-bool WebMListParser::OnListStart(int id, int64 size) {
+bool WebMListParser::OnListStart(int id, int64_t size) {
   const ListElementInfo* element_info = FindListInfo(id);
   if (!element_info)
     return false;
 
   int current_level = root_level_ + list_state_stack_.size() - 1;
   if (current_level + 1 != element_info->level_)
     return false;
 
   WebMParserClient* current_list_client = NULL;
   if (!list_state_stack_.empty()) {
@@ skipping 17 matching lines @@
   if (size == 0)
     return OnListEnd();
 
   return true;
 }
 
 bool WebMListParser::OnListEnd() {
   int lists_ended = 0;
   for (; !list_state_stack_.empty(); ++lists_ended) {
     const ListState& list_state = list_state_stack_.back();
-    int64 bytes_parsed = list_state.bytes_parsed_;
+    int64_t bytes_parsed = list_state.bytes_parsed_;
     int id = list_state.id_;
 
     if (bytes_parsed != list_state.size_)
       break;
 
     list_state_stack_.pop_back();
 
     WebMParserClient* client = NULL;
     if (!list_state_stack_.empty()) {
       // Update the bytes_parsed_ for the parent element.
@@ skipping 24 matching lines @@
       if (kSegmentIds[i].id_ == id_b)
         return true;
     }
   }
 
   // kWebMIdSegment siblings.
   return ((id_b == kWebMIdSegment) || (id_b == kWebMIdEBMLHeader));
 }
 
 }  // namespace media