Add UMA stats for open and fix memory leak

media/audio/win/audio_low_latency_input_win.h

 // 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.
 //
 // Implementation of AudioInputStream for Windows using Windows Core Audio
 // WASAPI for low latency capturing.
 //
 // Overview of operation:
 //
 // - An object of WASAPIAudioInputStream is created by the AudioManager
@@ skipping 39 matching lines @@
 //   per-session basis. It is also possible to use of the IAudioEndpointVolume
 //   interface to control the master volume level of an audio endpoint device.
 //   This implementation is using the ISimpleAudioVolume interface.
 //   MSDN states that "In rare cases, a specialized audio application might
 //   require the use of the IAudioEndpointVolume".
 //
 #ifndef MEDIA_AUDIO_WIN_AUDIO_LOW_LATENCY_INPUT_WIN_H_
 #define MEDIA_AUDIO_WIN_AUDIO_LOW_LATENCY_INPUT_WIN_H_
 
 #include <Audioclient.h>
+#include <MMDeviceAPI.h>
 #include <endpointvolume.h>
-#include <MMDeviceAPI.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/platform_thread.h"
@@ skipping 41 matching lines @@
 
  private:
   // DelegateSimpleThread::Delegate implementation.
   void Run() override;
 
   // Issues the OnError() callback to the |sink_|.
   void HandleError(HRESULT err);
 
   // The Open() method is divided into these sub methods.
   HRESULT SetCaptureDevice();
-  HRESULT ActivateCaptureDevice();
   HRESULT GetAudioEngineStreamFormat();
   bool DesiredFormatIsSupported();
   HRESULT InitializeAudioEngine();
+  void ReportOpenResult() const;
+
+  // Used to track down where we fail during initialization which at the
+  // moment seems to be happening frequently and we're not sure why.
+  // The reason might be expected (e.g. trying to open "default" on a machine
+  // that has no audio devices).

[jwd, 2017/02/09 16:04:07]

Mention this enum is used to record a histogram value and shouldn't be
re-ordered.

[tommi (sloooow) - chröme, 2017/02/09 16:31:37]

Done.

+  enum StreamOpenResult {
+    OPEN_RESULT_OK = 0,
+    OPEN_RESULT_CREATE_INSTANCE = 1,
+    OPEN_RESULT_NO_ENDPOINT = 2,
+    OPEN_RESULT_NO_STATE = 3,
+    OPEN_RESULT_DEVICE_NOT_ACTIVE = 4,
+    OPEN_RESULT_ACTIVATION_FAILED = 5,
+    OPEN_RESULT_FORMAT_NOT_SUPPORTED = 6,
+    OPEN_RESULT_AUDIO_CLIENT_INIT_FAILED = 7,
+    OPEN_RESULT_GET_BUFFER_SIZE_FAILED = 8,
+    OPEN_RESULT_LOOPBACK_ACTIVATE_FAILED = 9,
+    OPEN_RESULT_LOOPBACK_INIT_FAILED = 10,
+    OPEN_RESULT_SET_EVENT_HANDLE = 11,
+    OPEN_RESULT_NO_CAPTURE_CLIENT = 12,
+    OPEN_RESULT_NO_AUDIO_VOLUME = 13,
+    OPEN_RESULT_MAX = OPEN_RESULT_NO_AUDIO_VOLUME
+  };
 
   // Our creator, the audio manager needs to be notified when we close.
-  AudioManagerWin* manager_;
+  AudioManagerWin* const manager_;
 
   // Capturing is driven by this thread (which has no message loop).
   // All OnData() callbacks will be called from this thread.
-  base::DelegateSimpleThread* capture_thread_;
+  std::unique_ptr<base::DelegateSimpleThread> capture_thread_;
 
   // Contains the desired audio format which is set up at construction.
   WAVEFORMATEX format_;
 
-  bool opened_;
-  bool started_;
+  bool opened_ = false;
+  bool started_ = false;
+  StreamOpenResult open_result_ = OPEN_RESULT_OK;
 
   // Size in bytes of each audio frame (4 bytes for 16-bit stereo PCM)
-  size_t frame_size_;
+  size_t frame_size_ = 0;
 
   // Size in audio frames of each audio packet where an audio packet
   // is defined as the block of data which the user received in each
   // OnData() callback.
-  size_t packet_size_frames_;
+  size_t packet_size_frames_ = 0;
 
   // Size in bytes of each audio packet.
-  size_t packet_size_bytes_;
+  size_t packet_size_bytes_ = 0;
 
   // Length of the audio endpoint buffer.
-  uint32_t endpoint_buffer_size_frames_;
+  uint32_t endpoint_buffer_size_frames_ = 0;
 
   // Contains the unique name of the selected endpoint device.
   // Note that AudioDeviceDescription::kDefaultDeviceId represents the default
   // device role and is not a valid ID as such.
   std::string device_id_;
 
   // Conversion factor used in delay-estimation calculations.
   // Converts a raw performance counter value to 100-nanosecond unit.
-  double perf_count_to_100ns_units_;
+  double perf_count_to_100ns_units_ = 0.0;
 
   // Conversion factor used in delay-estimation calculations.
   // Converts from milliseconds to audio frames.
-  double ms_to_frame_count_;
+  double ms_to_frame_count_ = 0.0;
 
   // Pointer to the object that will receive the recorded audio samples.
-  AudioInputCallback* sink_;
+  AudioInputCallback* sink_ = nullptr;
 
   // Windows Multimedia Device (MMDevice) API interfaces.
 
   // An IMMDevice interface which represents an audio endpoint device.
   base::win::ScopedComPtr<IMMDevice> endpoint_device_;
 
   // Windows Audio Session API (WASAPI) interfaces.
 
   // An IAudioClient interface which enables a client to create and initialize
   // an audio stream between an audio application and the audio engine.
@@ skipping 29 matching lines @@
   base::win::ScopedHandle stop_capture_event_;
 
   // Extra audio bus used for storage of deinterleaved data for the OnData
   // callback.
   std::unique_ptr<media::AudioBus> audio_bus_;
 
   // Never set it through external API. Only used when |device_id_| ==
   // kLoopbackWithMuteDeviceId.
   // True, if we have muted the system audio for the stream capturing, and
   // indicates that we need to unmute the system audio when stopping capturing.
-  bool mute_done_;
+  bool mute_done_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(WASAPIAudioInputStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_WIN_AUDIO_LOW_LATENCY_INPUT_WIN_H_