Switch to standard integer types in media/.

media/formats/webm/webm_cluster_parser_unittest.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 <algorithm>
 #include <cstdlib>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 301 matching lines @@
 
     parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
         default_audio_duration, default_video_duration));
   }
 
   // Helper that hard-codes some non-varying constructor parameters.
   WebMClusterParser* CreateParserHelper(
       base::TimeDelta audio_default_duration,
       base::TimeDelta video_default_duration,
       const WebMTracksParser::TextTracks& text_tracks,
-      const std::set<int64>& ignored_tracks,
+      const std::set<int64_t>& ignored_tracks,
       const std::string& audio_encryption_key_id,
       const std::string& video_encryption_key_id,
       const AudioCodec audio_codec) {
     return new WebMClusterParser(
         kTimecodeScale, kAudioTrackNum, audio_default_duration, kVideoTrackNum,
         video_default_duration, text_tracks, ignored_tracks,
         audio_encryption_key_id, video_encryption_key_id, audio_codec,
         media_log_);
   }
 
   // Create a default version of the parser for test.
   WebMClusterParser* CreateDefaultParser() {
     return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
-                              std::set<int64>(), std::string(), std::string(),
+                              std::set<int64_t>(), std::string(), std::string(),
                               kUnknownAudioCodec);
   }
 
   // Create a parser for test with custom audio and video default durations, and
   // optionally custom text tracks.
   WebMClusterParser* CreateParserWithDefaultDurationsAndOptionalTextTracks(
       base::TimeDelta audio_default_duration,
       base::TimeDelta video_default_duration,
       const WebMTracksParser::TextTracks& text_tracks = TextTracks()) {
     return CreateParserHelper(audio_default_duration, video_default_duration,
-                              text_tracks, std::set<int64>(), std::string(),
+                              text_tracks, std::set<int64_t>(), std::string(),
                               std::string(), kUnknownAudioCodec);
   }
 
   // Create a parser for test with custom ignored tracks.
   WebMClusterParser* CreateParserWithIgnoredTracks(
-      std::set<int64>& ignored_tracks) {
+      std::set<int64_t>& ignored_tracks) {
     return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
                               ignored_tracks, std::string(), std::string(),
                               kUnknownAudioCodec);
   }
 
   // Create a parser for test with custom encryption key ids and audio codec.
   WebMClusterParser* CreateParserWithKeyIdsAndAudioCodec(
       const std::string& audio_encryption_key_id,
       const std::string& video_encryption_key_id,
       const AudioCodec audio_codec) {
     return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
-                              std::set<int64>(), audio_encryption_key_id,
+                              std::set<int64_t>(), audio_encryption_key_id,
                               video_encryption_key_id, audio_codec);
   }
 
   scoped_refptr<StrictMock<MockMediaLog>> media_log_;
   scoped_ptr<WebMClusterParser> parser_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebMClusterParserTest);
 };
 
@@ skipping 196 matching lines @@
   };
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, IgnoredTracks) {
-  std::set<int64> ignored_tracks;
+  std::set<int64_t> ignored_tracks;
   ignored_tracks.insert(kTextTrackNum);
 
   parser_.reset(CreateParserWithIgnoredTracks(ignored_tracks));
 
   const BlockInfo kInputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
       {kAudioTrackNum, 23, 23, true, NULL, 0},
       {kVideoTrackNum, 33, 34, true, NULL, 0},
       {kTextTrackNum, 33, 99, true, NULL, 0},
       {kAudioTrackNum, 46, 23, true, NULL, 0},
@@ skipping 550 matching lines @@
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
 
   // Will verify that duration of buffer matches that of BlockDuration.
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 }  // namespace media