Move enable_webrtc to a buildflag header.

content/renderer/speech_recognition_dispatcher.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/renderer/speech_recognition_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/speech_recognition_messages.h"
 #include "content/renderer/render_view_impl.h"
+#include "media/media_features.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebSpeechGrammar.h"
 #include "third_party/WebKit/public/web/WebSpeechRecognitionParams.h"
 #include "third_party/WebKit/public/web/WebSpeechRecognitionResult.h"
 #include "third_party/WebKit/public/web/WebSpeechRecognizerClient.h"
 
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
 #include "content/renderer/media/speech_recognition_audio_sink.h"
 #endif
 
 using blink::WebVector;
 using blink::WebString;
 using blink::WebSpeechGrammar;
 using blink::WebSpeechRecognitionHandle;
 using blink::WebSpeechRecognitionResult;
 using blink::WebSpeechRecognitionParams;
 using blink::WebSpeechRecognizerClient;
@@ skipping 38 matching lines @@
   delete this;
 }
 
 void SpeechRecognitionDispatcher::start(
     const WebSpeechRecognitionHandle& handle,
     const WebSpeechRecognitionParams& params,
     WebSpeechRecognizerClient* recognizer_client) {
   DCHECK(!recognizer_client_ || recognizer_client_ == recognizer_client);
   recognizer_client_ = recognizer_client;
 
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   const blink::WebMediaStreamTrack track = params.audioTrack();
   if (!track.isNull()) {
     // Check if this type of track is allowed by implemented policy.
     if (SpeechRecognitionAudioSink::IsSupportedTrack(track)) {
       audio_track_.assign(track);
     } else {
       audio_track_.reset();
       // Notify user that the track used is not supported.
       recognizer_client_->didReceiveError(
           handle,
@@ skipping 17 matching lines @@
                                  grammar.weight()));
   }
   msg_params.language =
       base::UTF16ToUTF8(base::StringPiece16(params.language()));
   msg_params.max_hypotheses = static_cast<uint32_t>(params.maxAlternatives());
   msg_params.continuous = params.continuous();
   msg_params.interim_results = params.interimResults();
   msg_params.origin_url = params.origin().toString().utf8();
   msg_params.render_view_id = routing_id();
   msg_params.request_id = GetOrCreateIDForHandle(handle);
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   // Fall back to default input when the track is not allowed.
   msg_params.using_audio_track = !audio_track_.isNull();
 #else
   msg_params.using_audio_track = false;
 #endif
   // The handle mapping will be removed in |OnRecognitionEnd|.
   Send(new SpeechRecognitionHostMsg_StartRequest(msg_params));
 }
 
 void SpeechRecognitionDispatcher::stop(
@@ skipping 131 matching lines @@
 
   recognizer_client_->didReceiveResults(
       GetHandleFromID(request_id), final, provisional);
 }
 
 void SpeechRecognitionDispatcher::OnAudioReceiverReady(
     int request_id,
     const media::AudioParameters& params,
     const base::SharedMemoryHandle memory,
     const base::SyncSocket::TransitDescriptor descriptor) {
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   DCHECK(!speech_audio_sink_.get());
   if (audio_track_.isNull()) {
     ResetAudioSink();
     return;
   }
 
   // The instantiation and type of SyncSocket is up to the client since it
   // is dependency injected to the SpeechRecognitionAudioSink.
   std::unique_ptr<base::SyncSocket> socket(new base::CancelableSyncSocket(
       base::SyncSocket::UnwrapHandle(descriptor)));
@@ skipping 26 matching lines @@
   for (HandleMap::iterator iter = handle_map_.begin();
       iter != handle_map_.end();
       ++iter) {
     if (iter->second.equals(handle))
       return true;
   }
   return false;
 }
 
 void SpeechRecognitionDispatcher::ResetAudioSink() {
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   speech_audio_sink_.reset();
 #endif
 }
 
 const WebSpeechRecognitionHandle& SpeechRecognitionDispatcher::GetHandleFromID(
     int request_id) {
   HandleMap::iterator iter = handle_map_.find(request_id);
   CHECK(iter != handle_map_.end());
   return iter->second;
 }
 
 }  // namespace content