Move enable_webrtc to a buildflag header.

content/browser/webrtc/webrtc_internals.cc

 // Copyright (c) 2013 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/webrtc/webrtc_internals.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/browser/webrtc/webrtc_internals_ui_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/web_contents.h"
 #include "device/power_save_blocker/power_save_blocker.h"
 #include "ipc/ipc_platform_file.h"
+#include "media/media_features.h"
 
 #if defined(OS_WIN)
 #define IntToStringType base::IntToString16
 #else
 #define IntToStringType base::IntToString
 #endif
 
 using base::ProcessId;
 using std::string;
 
@@ skipping 46 matching lines @@
                                  bool should_block_power_saving)
     : audio_debug_recordings_(false),
       event_log_recordings_(false),
       selecting_event_log_(false),
       num_open_connections_(0),
       should_block_power_saving_(should_block_power_saving),
       aggregate_updates_ms_(aggregate_updates_ms),
       weak_factory_(this) {
 // TODO(grunell): Shouldn't all the webrtc_internals* files be excluded from the
 // build if WebRTC is disabled?
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   audio_debug_recordings_file_path_ =
       GetContentClient()->browser()->GetDefaultDownloadDirectory();
   event_log_recordings_file_path_ = audio_debug_recordings_file_path_;
 
   if (audio_debug_recordings_file_path_.empty()) {
     // In this case the default path (|audio_debug_recordings_file_path_|) will
     // be empty and the platform default path will be used in the file dialog
     // (with no default file name). See SelectFileDialog::SelectFile. On Android
     // where there's no dialog we'll fail to open the file.
     VLOG(1) << "Could not get the download directory.";
   } else {
     audio_debug_recordings_file_path_ =
         audio_debug_recordings_file_path_.Append(
             FILE_PATH_LITERAL("audio_debug"));
     event_log_recordings_file_path_ =
         event_log_recordings_file_path_.Append(FILE_PATH_LITERAL("event_log"));
   }
-#endif  // defined(ENABLE_WEBRTC)
+#endif  // BUILDFLAG(ENABLE_WEBRTC)
 }
 
 WebRTCInternals::~WebRTCInternals() {
 }
 
 WebRTCInternals* WebRTCInternals::GetInstance() {
   return g_webrtc_internals.Pointer();
 }
 
 void WebRTCInternals::OnAddPeerConnection(int render_process_id,
@@ skipping 171 matching lines @@
     observer->OnUpdate("updateAllPeerConnections", &peer_connection_data_);
 
   for (const auto& request : get_user_media_requests_) {
     observer->OnUpdate("addGetUserMedia", request.get());
   }
 }
 
 void WebRTCInternals::EnableAudioDebugRecordings(
     content::WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
 #if defined(OS_ANDROID)
   EnableAudioDebugRecordingsOnAllRenderProcessHosts();
 #else
   selecting_event_log_ = false;
   DCHECK(!select_file_dialog_);
   select_file_dialog_ = ui::SelectFileDialog::Create(this, NULL);
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_SAVEAS_FILE,
       base::string16(),
       audio_debug_recordings_file_path_,
       NULL,
       0,
       FILE_PATH_LITERAL(""),
       web_contents->GetTopLevelNativeWindow(),
       NULL);
 #endif
 #endif
 }
 
 void WebRTCInternals::DisableAudioDebugRecordings() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   audio_debug_recordings_ = false;
 
   // Tear down the dialog since the user has unchecked the audio debug
   // recordings box.
   select_file_dialog_ = NULL;
 
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     i.GetCurrentValue()->DisableAudioDebugRecordings();
   }
 #endif
 }
 
 bool WebRTCInternals::IsAudioDebugRecordingsEnabled() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return audio_debug_recordings_;
 }
 
 const base::FilePath& WebRTCInternals::GetAudioDebugRecordingsFilePath() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return audio_debug_recordings_file_path_;
 }
 
 void WebRTCInternals::EnableEventLogRecordings(
     content::WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
 #if defined(OS_ANDROID)
   EnableEventLogRecordingsOnAllRenderProcessHosts();
 #else
   DCHECK(web_contents);
   DCHECK(!select_file_dialog_);
   selecting_event_log_ = true;
   select_file_dialog_ = ui::SelectFileDialog::Create(this, nullptr);
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_SAVEAS_FILE, base::string16(),
       event_log_recordings_file_path_, nullptr, 0, FILE_PATH_LITERAL(""),
       web_contents->GetTopLevelNativeWindow(), nullptr);
 #endif
 #endif
 }
 
 void WebRTCInternals::DisableEventLogRecordings() {
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   event_log_recordings_ = false;
   // Tear down the dialog since the user has unchecked the event log checkbox.
   select_file_dialog_ = nullptr;
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance())
     i.GetCurrentValue()->StopWebRTCEventLog();
 #endif
 }
 
@@ skipping 27 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OnRendererExit(host->GetID());
 
   render_process_id_set_.erase(host->GetID());
   host->RemoveObserver(this);
 }
 
 void WebRTCInternals::FileSelected(const base::FilePath& path,
                                    int /* unused_index */,
                                    void* /*unused_params */) {
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (selecting_event_log_) {
     event_log_recordings_file_path_ = path;
     EnableEventLogRecordingsOnAllRenderProcessHosts();
   } else {
     audio_debug_recordings_file_path_ = path;
     EnableAudioDebugRecordingsOnAllRenderProcessHosts();
   }
 #endif
 }
 
 void WebRTCInternals::FileSelectionCanceled(void* params) {
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (selecting_event_log_) {
     SendUpdate("eventLogRecordingsFileSelectionCancelled", nullptr);
   } else {
     SendUpdate("audioDebugRecordingsFileSelectionCancelled", nullptr);
   }
 #endif
 }
 
 void WebRTCInternals::OnRendererExit(int render_process_id) {
@@ skipping 41 matching lines @@
     }
   }
 
   if (found_any && observers_.might_have_observers()) {
     std::unique_ptr<base::DictionaryValue> update(new base::DictionaryValue());
     update->SetInteger("rid", render_process_id);
     SendUpdate("removeGetUserMediaForRenderer", std::move(update));
   }
 }
 
-#if defined(ENABLE_WEBRTC)
+#if BUILDFLAG(ENABLE_WEBRTC)
 void WebRTCInternals::EnableAudioDebugRecordingsOnAllRenderProcessHosts() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   audio_debug_recordings_ = true;
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     i.GetCurrentValue()->EnableAudioDebugRecordings(
         audio_debug_recordings_file_path_);
   }
@@ skipping 48 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   while (!pending_updates_.empty()) {
     const auto& update = pending_updates_.front();
     for (auto& observer : observers_)
       observer.OnUpdate(update.command(), update.value());
     pending_updates_.pop();
   }
 }
 
 }  // namespace content