Switch to standard integer types in content/browser/.

content/browser/speech/endpointer/endpointer.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/browser/speech/endpointer/endpointer.h"
 
 #include "base/time/time.h"
 #include "content/browser/speech/audio_buffer.h"
 
 using base::Time;
 
 namespace {
 const int kFrameRate = 50;  // 1 frame = 20ms of audio.
 }
 
 namespace content {
 
 Endpointer::Endpointer(int sample_rate)
     : speech_input_possibly_complete_silence_length_us_(-1),
       speech_input_complete_silence_length_us_(-1),
       audio_frame_time_us_(0),
       sample_rate_(sample_rate),
       frame_size_(0) {
   Reset();
 
   frame_size_ = static_cast<int>(sample_rate / static_cast<float>(kFrameRate));
 
   speech_input_minimum_length_us_ =
-      static_cast<int64>(1.7 * Time::kMicrosecondsPerSecond);
+      static_cast<int64_t>(1.7 * Time::kMicrosecondsPerSecond);
   speech_input_complete_silence_length_us_ =
-      static_cast<int64>(0.5 * Time::kMicrosecondsPerSecond);
+      static_cast<int64_t>(0.5 * Time::kMicrosecondsPerSecond);
   long_speech_input_complete_silence_length_us_ = -1;
   long_speech_length_us_ = -1;
   speech_input_possibly_complete_silence_length_us_ =
       1 * Time::kMicrosecondsPerSecond;
 
   // Set the default configuration for Push To Talk mode.
   EnergyEndpointerParams ep_config;
   ep_config.set_frame_period(1.0f / static_cast<float>(kFrameRate));
   ep_config.set_frame_duration(1.0f / static_cast<float>(kFrameRate));
   ep_config.set_endpoint_margin(0.2f);
@@ skipping 36 matching lines @@
 
 void Endpointer::SetEnvironmentEstimationMode() {
   Reset();
   energy_endpointer_.SetEnvironmentEstimationMode();
 }
 
 void Endpointer::SetUserInputMode() {
   energy_endpointer_.SetUserInputMode();
 }
 
-EpStatus Endpointer::Status(int64 *time) {
+EpStatus Endpointer::Status(int64_t* time) {
   return energy_endpointer_.Status(time);
 }
 
 EpStatus Endpointer::ProcessAudio(const AudioChunk& raw_audio, float* rms_out) {
-  const int16* audio_data = raw_audio.SamplesData16();
+  const int16_t* audio_data = raw_audio.SamplesData16();
   const int num_samples = raw_audio.NumSamples();
   EpStatus ep_status = EP_PRE_SPEECH;
 
   // Process the input data in blocks of frame_size_, dropping any incomplete
   // frames at the end (which is ok since typically the caller will be recording
   // audio in multiples of our frame size).
   int sample_index = 0;
   while (sample_index + frame_size_ <= num_samples) {
     // Have the endpointer process the frame.
     energy_endpointer_.ProcessAudioFrame(audio_frame_time_us_,
                                          audio_data + sample_index,
                                          frame_size_,
                                          rms_out);
     sample_index += frame_size_;
     audio_frame_time_us_ += (frame_size_ * Time::kMicrosecondsPerSecond) /
                          sample_rate_;
 
     // Get the status of the endpointer.
-    int64 ep_time;
+    int64_t ep_time;
     ep_status = energy_endpointer_.Status(&ep_time);
 
     // Handle state changes.
     if ((EP_SPEECH_PRESENT == ep_status) &&
         (EP_POSSIBLE_ONSET == old_ep_status_)) {
       speech_end_time_us_ = -1;
       waiting_for_speech_possibly_complete_timeout_ = false;
       waiting_for_speech_complete_timeout_ = false;
       // Trigger SpeechInputDidStart event on first detection.
       if (false == speech_previously_detected_) {
@@ skipping 14 matching lines @@
               speech_input_possibly_complete_silence_length_us_)) {
         waiting_for_speech_possibly_complete_timeout_ = false;
       }
       if (waiting_for_speech_complete_timeout_) {
         // The length of the silence timeout period can be held constant, or it
         // can be changed after a fixed amount of time from the beginning of
         // speech.
         bool has_stepped_silence =
             (long_speech_length_us_ > 0) &&
             (long_speech_input_complete_silence_length_us_ > 0);
-        int64 requested_silence_length;
+        int64_t requested_silence_length;
         if (has_stepped_silence &&
             (ep_time - speech_start_time_us_) > long_speech_length_us_) {
           requested_silence_length =
               long_speech_input_complete_silence_length_us_;
         } else {
           requested_silence_length =
               speech_input_complete_silence_length_us_;
         }
 
         // Speech complete timeout.
         if ((ep_time - speech_end_time_us_) > requested_silence_length) {
           waiting_for_speech_complete_timeout_ = false;
           speech_input_complete_ = true;
         }
       }
     }
     old_ep_status_ = ep_status;
   }
   return ep_status;
 }
 
 }  // namespace content