Switch to standard integer types in content/browser/.

content/browser/speech/google_streaming_remote_engine.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/google_streaming_remote_engine.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/big_endian.h"
@@ skipping 20 matching lines @@
 
 namespace content {
 namespace {
 
 const char kWebServiceBaseUrl[] =
     "https://www.google.com/speech-api/full-duplex/v1";
 const char kDownstreamUrl[] = "/down?";
 const char kUpstreamUrl[] = "/up?";
 
 // This matches the maximum maxAlternatives value supported by the server.
-const uint32 kMaxMaxAlternatives = 30;
+const uint32_t kMaxMaxAlternatives = 30;
 
 // TODO(hans): Remove this and other logging when we don't need it anymore.
 void DumpResponse(const std::string& response) {
   DVLOG(1) << "------------";
   proto::SpeechRecognitionEvent event;
   if (!event.ParseFromString(response)) {
     DVLOG(1) << "Parse failed!";
     return;
   }
   if (event.has_status())
@@ skipping 62 matching lines @@
   FSMEventArgs event_args(EVENT_AUDIO_CHUNKS_ENDED);
   DispatchEvent(event_args);
 }
 
 void GoogleStreamingRemoteEngine::OnURLFetchComplete(const URLFetcher* source) {
   const bool kResponseComplete = true;
   DispatchHTTPResponse(source, kResponseComplete);
 }
 
 void GoogleStreamingRemoteEngine::OnURLFetchDownloadProgress(
-    const URLFetcher* source, int64 current, int64 total) {
+    const URLFetcher* source,
+    int64_t current,
+    int64_t total) {
   const bool kPartialResponse = false;
   DispatchHTTPResponse(source, kPartialResponse);
 }
 
 void GoogleStreamingRemoteEngine::DispatchHTTPResponse(const URLFetcher* source,
                                                        bool end_of_response) {
   DCHECK(CalledOnValidThread());
   DCHECK(source);
   const bool response_is_good = source->GetStatus().is_success() &&
                                 source->GetResponseCode() == 200;
@@ skipping 199 matching lines @@
   std::vector<std::string> upstream_args;
   upstream_args.push_back("key=" +
       net::EscapeQueryParamValue(google_apis::GetAPIKey(), true));
   upstream_args.push_back("pair=" + request_key);
   upstream_args.push_back("output=pb");
   upstream_args.push_back(
       "lang=" + net::EscapeQueryParamValue(GetAcceptedLanguages(), true));
   upstream_args.push_back(
       config_.filter_profanities ? "pFilter=2" : "pFilter=0");
   if (config_.max_hypotheses > 0U) {
-    uint32 max_alternatives =
+    uint32_t max_alternatives =
         std::min(kMaxMaxAlternatives, config_.max_hypotheses);
     upstream_args.push_back("maxAlternatives=" +
                             base::UintToString(max_alternatives));
   }
   upstream_args.push_back("app=chromium");
   if (!config_.hardware_info.empty()) {
     upstream_args.push_back(
         "xhw=" + net::EscapeQueryParamValue(config_.hardware_info, true));
   }
   for (const SpeechRecognitionGrammar& grammar : config_.grammars) {
@@ skipping 36 matching lines @@
   upstream_fetcher_->SetReferrer(config_.origin_url);
   upstream_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                                   net::LOAD_DO_NOT_SEND_COOKIES |
                                   net::LOAD_DO_NOT_SEND_AUTH_DATA);
   upstream_fetcher_->Start();
   previous_response_length_ = 0;
 
   if (preamble_encoder_) {
     // Encode and send preamble right away.
     scoped_refptr<AudioChunk> chunk = new AudioChunk(
-        reinterpret_cast<const uint8*>(config_.preamble->sample_data.data()),
-        config_.preamble->sample_data.size(),
-        config_.preamble->sample_depth);
+        reinterpret_cast<const uint8_t*>(config_.preamble->sample_data.data()),
+        config_.preamble->sample_data.size(), config_.preamble->sample_depth);
     preamble_encoder_->Encode(*chunk);
     preamble_encoder_->Flush();
     scoped_refptr<AudioChunk> encoded_data(
         preamble_encoder_->GetEncodedDataAndClear());
     UploadAudioChunk(encoded_data->AsString(), FRAME_PREAMBLE_AUDIO, false);
   }
   return STATE_BOTH_STREAMS_CONNECTED;
 }
 
 GoogleStreamingRemoteEngine::FSMState
@@ skipping 98 matching lines @@
   DCHECK(upstream_fetcher_.get());
   DCHECK(encoder_.get());
 
   DVLOG(1) <<  "Closing upstream.";
 
   // The encoder requires a non-empty final buffer. So we encode a packet
   // of silence in case encoder had no data already.
   size_t sample_count =
       config_.audio_sample_rate * kAudioPacketIntervalMs / 1000;
   scoped_refptr<AudioChunk> dummy_chunk = new AudioChunk(
-      sample_count * sizeof(int16), encoder_->GetBitsPerSample() / 8);
+      sample_count * sizeof(int16_t), encoder_->GetBitsPerSample() / 8);
   encoder_->Encode(*dummy_chunk.get());
   encoder_->Flush();
   scoped_refptr<AudioChunk> encoded_dummy_data =
       encoder_->GetEncodedDataAndClear();
   DCHECK(!encoded_dummy_data->IsEmpty());
   encoder_.reset();
 
   UploadAudioChunk(encoded_dummy_data->AsString(),
                    FRAME_RECOGNITION_AUDIO,
                    true);
@@ skipping 67 matching lines @@
         langs = accepted_language_list.substr(0, separator);
     }
   }
   if (langs.empty())
     langs = "en-US";
   return langs;
 }
 
 // TODO(primiano): Is there any utility in the codebase that already does this?
 std::string GoogleStreamingRemoteEngine::GenerateRequestKey() const {
-  const int64 kKeepLowBytes = 0x00000000FFFFFFFFLL;
-  const int64 kKeepHighBytes = 0xFFFFFFFF00000000LL;
+  const int64_t kKeepLowBytes = 0x00000000FFFFFFFFLL;
+  const int64_t kKeepHighBytes = 0xFFFFFFFF00000000LL;
 
   // Just keep the least significant bits of timestamp, in order to reduce
   // probability of collisions.
-  int64 key = (base::Time::Now().ToInternalValue() & kKeepLowBytes) |
-              (base::RandUint64() & kKeepHighBytes);
+  int64_t key = (base::Time::Now().ToInternalValue() & kKeepLowBytes) |
+                (base::RandUint64() & kKeepHighBytes);
   return base::HexEncode(reinterpret_cast<void*>(&key), sizeof(key));
 }
 
 void GoogleStreamingRemoteEngine::UploadAudioChunk(const std::string& data,
                                                    FrameType type,
                                                    bool is_final) {
   if (use_framed_post_data_) {
     std::string frame(data.size() + 8, 0);
     base::WriteBigEndian(&frame[0], static_cast<uint32_t>(data.size()));
     base::WriteBigEndian(&frame[4], static_cast<uint32_t>(type));
     frame.replace(8, data.size(), data);
     upstream_fetcher_->AppendChunkToUpload(frame, is_final);
   } else {
     upstream_fetcher_->AppendChunkToUpload(data, is_final);
   }
 }
 
 GoogleStreamingRemoteEngine::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value) {
 }
 
 GoogleStreamingRemoteEngine::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace content