Remove DumpWithoutCrashing() and keys from audio_manager

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 <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
-#include "base/debug/alias.h"
-#include "base/debug/crash_logging.h"
-#include "base/debug/dump_without_crashing.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/base/media_switches.h"
 
@@ skipping 67 matching lines @@
   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
 
-  void enable_crash_key_logging() { enable_crash_key_logging_ = true; }
-
  private:
   // base::PowerObserver overrides.
   // Disable hang detection when the system goes into the suspend state.
   void OnSuspend() override {
     base::AutoLock lock(hang_lock_);
     hang_detection_enabled_ = false;
     failed_pings_ = successful_pings_ = 0;
   }
   // Reenable hang detection once the system comes out of the suspend state.
   void OnResume() override {
@@ skipping 36 matching lines @@
         return;
       }
 
       DCHECK(io_task_running_);
       const base::TimeTicks now = base::TimeTicks::Now();
       const base::TimeDelta tick_delta = now - last_audio_thread_timer_tick_;
       if (tick_delta > max_hung_task_time_) {
         successful_pings_ = 0;
         if (++failed_pings_ >= kMaxFailedPingsCount &&
             audio_thread_status_ < THREAD_HUNG) {
-          if (enable_crash_key_logging_)
-            LogAudioDriverCrashKeys();
           HistogramThreadStatus(THREAD_HUNG);
         }
       } else {
         failed_pings_ = 0;
         ++successful_pings_;
         if (audio_thread_status_ == THREAD_NONE) {
           HistogramThreadStatus(THREAD_STARTED);
         } else if (audio_thread_status_ == THREAD_HUNG &&
                    successful_pings_ >= kMaxFailedPingsCount) {
           // Require just as many successful pings to recover from failure.
@@ skipping 34 matching lines @@
         max_hung_task_time_ / 5);
   }
 
   void HistogramThreadStatus(ThreadStatus status) {
     DCHECK(monitor_task_runner_->BelongsToCurrentThread());
     audio_thread_status_ = status;
     UMA_HISTOGRAM_ENUMERATION("Media.AudioThreadStatus", audio_thread_status_,
                               THREAD_MAX + 1);
   }
 
-  void LogAudioDriverCrashKeys() {
-    DCHECK(monitor_task_runner_->BelongsToCurrentThread());
-    DCHECK(enable_crash_key_logging_);
-
-#if defined(OS_WIN)
-    std::string driver_name, driver_version;
-    if (!CoreAudioUtil::GetDxDiagDetails(&driver_name, &driver_version))
-      return;
-
-    base::debug::ScopedCrashKey crash_key(
-        "hung-audio-thread-details",
-        base::StringPrintf("%s:%s", driver_name.c_str(),
-                           driver_version.c_str()));
-
-    // Please forward crash reports to http://crbug.com/422522
-    base::debug::DumpWithoutCrashing();
-#endif
-  }
-
   FakeAudioLogFactory fake_log_factory_;
 
   const base::TimeDelta max_hung_task_time_ = base::TimeDelta::FromMinutes(1);
   scoped_refptr<base::SingleThreadTaskRunner> monitor_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
 
   base::Lock hang_lock_;
   bool hang_detection_enabled_ = true;
   base::TimeTicks last_audio_thread_timer_tick_;
   uint32_t failed_pings_ = 0;
   bool io_task_running_ = false;
   bool audio_task_running_ = false;
   ThreadStatus audio_thread_status_ = THREAD_NONE;
-  bool enable_crash_key_logging_ = false;
   uint32_t successful_pings_ = 0;
 
 #if defined(OS_WIN)
   std::unique_ptr<base::win::ScopedCOMInitializer> com_initializer_for_testing_;
 #endif
 
 #if defined(OS_LINUX)
   std::string app_name_;
 #endif
 
@@ skipping 95 matching lines @@
   if (GetHelper()->monitor_task_runner())
     return;
 
   DCHECK(AudioManager::Get());
   DCHECK(task_runner);
   DCHECK_NE(task_runner, AudioManager::Get()->GetTaskRunner());
 
   GetHelper()->StartHangTimer(std::move(task_runner));
 }
 
-// static
-void AudioManager::EnableCrashKeyLoggingForAudioThreadHangs() {
-  CHECK(!g_last_created);
-  GetHelper()->enable_crash_key_logging();
-}
-
 #if defined(OS_LINUX)
 // static
 void AudioManager::SetGlobalAppName(const std::string& app_name) {
   GetHelper()->set_app_name(app_name);
 }
 
 // static
 const std::string& AudioManager::GetGlobalAppName() {
   return GetHelper()->app_name();
 }
 #endif
 
 // static
 AudioManager* AudioManager::Get() {
   return g_last_created;
 }
 
 }  // namespace media