Linux: Do not use a hard coded app name for PulseAudio output.

media/audio/audio_manager.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 "media/audio/audio_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_monitor.h"
 #include "build/build_config.h"
 #include "media/audio/audio_manager_factory.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/base/media_switches.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 namespace media {
 namespace {
 
 // The singleton instance of AudioManager. This is set when Create() is called.
-AudioManager* g_last_created = NULL;
+AudioManager* g_last_created = nullptr;
 
 // The singleton instance of AudioManagerFactory. This is only set if
 // SetFactory() is called. If it is set when Create() is called, its
 // CreateInstance() function is used to set |g_last_created|. Otherwise, the
 // linked implementation of media::CreateAudioManager is used to set
 // |g_last_created|.
-AudioManagerFactory* g_audio_manager_factory = NULL;
+AudioManagerFactory* g_audio_manager_factory = nullptr;
 
 // Maximum number of failed pings to the audio thread allowed. A crash will be
 // issued once this count is reached.  We require at least two pings before
 // crashing to ensure unobservable power events aren't mistakenly caught (e.g.,
 // the system suspends before a OnSuspend() event can be fired.).
 const int kMaxHangFailureCount = 2;
 
 // Helper class for managing global AudioManager data and hang timers. If the
 // audio thread is unresponsive for more than two minutes we want to crash the
 // process so we can catch offenders quickly in the field.
@@ skipping 103 matching lines @@
   AudioLogFactory* fake_log_factory() { return &fake_log_factory_; }
 
 #if defined(OS_WIN)
   // This should be called before creating an AudioManager in tests to ensure
   // that the creating thread is COM initialized.
   void InitializeCOMForTesting() {
     com_initializer_for_testing_.reset(new base::win::ScopedCOMInitializer());
   }
 #endif
 
+#if defined(OS_LINUX)
+  void set_app_name(const std::string& app_name) {
+    app_name_ = app_name;
+  }
+
+  const std::string& app_name() const {
+    return app_name_;
+  }
+#endif
+
  private:
   FakeAudioLogFactory fake_log_factory_;
 
   const base::TimeDelta max_hung_task_time_;
   scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner_;
 
   base::Lock hang_lock_;
   bool hang_detection_enabled_;
   base::TimeTicks last_audio_thread_timer_tick_;
   int hang_failures_;
   bool io_task_running_;
   bool audio_task_running_;
 
 #if defined(OS_WIN)
   scoped_ptr<base::win::ScopedCOMInitializer> com_initializer_for_testing_;
 #endif
 
+#if defined(OS_LINUX)
+  std::string app_name_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(AudioManagerHelper);
 };
 
-static bool g_hang_monitor_enabled = false;
+bool g_hang_monitor_enabled = false;
 
-static base::LazyInstance<AudioManagerHelper>::Leaky g_helper =
+base::LazyInstance<AudioManagerHelper>::Leaky g_helper =
     LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 // Forward declaration of the platform specific AudioManager factory function.
 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory);
 
 AudioManager::AudioManager() {}
 
 AudioManager::~AudioManager() {
   CHECK(!g_last_created || g_last_created == this);
-  g_last_created = NULL;
+  g_last_created = nullptr;
 }
 
 // static
 void AudioManager::SetFactory(AudioManagerFactory* factory) {
   CHECK(factory);
   CHECK(!g_last_created);
   CHECK(!g_audio_manager_factory);
   g_audio_manager_factory = factory;
 }
 
@@ skipping 41 matching lines @@
 void AudioManager::EnableHangMonitor() {
   CHECK(!g_last_created);
 // On OSX the audio thread is the UI thread, for which a hang monitor is not
 // necessary or recommended.  If it's manually requested, we should allow it
 // to start though.
 #if !defined(OS_MACOSX)
   g_hang_monitor_enabled = true;
 #endif
 }
 
+#if defined(OS_LINUX)
+// static
+void AudioManager::SetGlobalAppName(const std::string& app_name) {
+  g_helper.Pointer()->set_app_name(app_name);
+}
+
+// static
+const std::string& AudioManager::GetGlobalAppName() {
+  return g_helper.Pointer()->app_name();
+}
+#endif
+
 // static
 AudioManager* AudioManager::Get() {
   return g_last_created;
 }
 
 }  // namespace media