# This file is used in addition to the one already maintained in Chrome.
# It acts as a place holder for future additions for WebRTC.
# It must exist for the Python wrapper script to work properly.

GDI USAGE ERROR
name=https://code.google.com/p/webrtc/issues/detail?id=2323 (1)
system call NtGdiDeleteObjectApp
GDI32.dll!DeleteDC
GDI32.dll!DeleteDC
*!webrtc::`anonymous namespace'::WindowCapturerWin::Capture
...
*!testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test,void>

UNINITIALIZED READ
name=<https://code.google.com/p/webrtc/issues/detail?id=2323 (2)>
system call NtUserGetThreadDesktop parameter value #1
*!webrtc::Desktop::GetThreadDesktop
*!webrtc::ScopedThreadDesktop::ScopedThreadDesktop
*!webrtc::ScreenCapturerWinGdi::ScreenCapturerWinGdi
*!webrtc::ScreenCapturer::Create
*!webrtc::ScreenCapturerTest::SetUp
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=<https://code.google.com/p/webrtc/issues/detail?id=2323 (3)>
system call NtUserGetThreadDesktop parameter value #1
*!webrtc::Desktop::GetThreadDesktop
*!webrtc::ScopedThreadDesktop::ScopedThreadDesktop
*!webrtc::ScreenCapturerWinGdi::ScreenCapturerWinGdi
*!webrtc::ScreenCapturer::Create
*!webrtc::ScreenCapturerTest_UseMagnifier_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=<https://code.google.com/p/webrtc/issues/detail?id=2323 (4)>
system call NtUserGetThreadDesktop parameter value #1
*!webrtc::Desktop::GetThreadDesktop
*!webrtc::ScopedThreadDesktop::ScopedThreadDesktop
*!webrtc::ScreenCapturerWinMagnifier::ScreenCapturerWinMagnifier
*!webrtc::ScreenCapturer::Create
*!webrtc::ScreenCapturerTest_UseMagnifier_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=2323 (5)
system call NtUserGetIconInfo parameter value #0
USER32.dll!GetIconInfo
*!webrtc::CreateMouseCursorFromHCursor
*!webrtc::`anonymous namespace'::ScreenCapturerWin::CaptureCursor
*!webrtc::`anonymous namespace'::ScreenCapturerWin::Capture
*!webrtc::ScreenCapturerTest_Capture_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=2323 (6)
system call NtUserGetWindowPlacement
*!webrtc::GetCroppedWindowRect
*!webrtc::`anonymous namespace'::WindowCapturerWin::Capture
*!webrtc::WindowCapturerTest_Capture_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=2323 (7)
system call NtUserGetWindowPlacement parameter #1
*!webrtc::GetCroppedWindowRect
*!webrtc::`anonymous namespace'::WindowCapturerWin::Capture
*!webrtc::WindowCapturerTest_Capture_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

LEAK
name=https://code.google.com/p/webrtc/issues/detail?id=2333
drmemorylib.dll!replace_operator_new
*!webrtc::test::UdpSocketWrapper::CreateSocket
*!webrtc::test::UdpSocketManager_AddAndRemoveSocketDoesNotLeakMemory_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test,void>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=2516
system call NtUserGetThreadDesktop parameter value #1
*!webrtc::Desktop::GetThreadDesktop
*!webrtc::ScopedThreadDesktop::ScopedThreadDesktop
*!webrtc::`anonymous namespace'::ScreenCapturerWin::ScreenCapturerWin
*!webrtc::ScreenCapturer::Create
*!webrtc::ScreenCapturerTest::SetUp
*!testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test,void>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (1)
*!_output_l
*!_vsnprintf_l
*!_vsnprintf
*!webrtc::Trace::Add
*!webrtc::ViECodecImpl::GetCodecTargetBitrate
*!cricket::WebRtcVideoMediaChannel::MaybeChangeStartBitrate
*!cricket::WebRtcVideoMediaChannel::SetSendCodec
*!cricket::WebRtcVideoMediaChannel::SetSendCodec
*!cricket::WebRtcVideoMediaChannel::SetSendCodecs
*!VideoMediaChannelTest<>::SetOneCodec
*!VideoMediaChannelTest<>::Send
*!VideoMediaChannelTest<>::TwoStreamsSendAndFailUnsignalledRecv
*!WebRtcVideoMediaChannelTest_TwoStreamsSendAndFailUnsignalledRecv_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (2)
*!_output_l
*!_vsnprintf_l
*!_vsnprintf
*!webrtc::Trace::Add
*!webrtc::ViECodecImpl::GetCodecTargetBitrate
*!cricket::WebRtcVideoMediaChannel::MaybeChangeStartBitrate
*!cricket::WebRtcVideoMediaChannel::MaybeResetVieSendCodec
*!cricket::WebRtcVideoMediaChannel::SendFrame
*!cricket::WebRtcVideoMediaChannel::SendFrame
*!sigslot::_connection2<>::emit
*!sigslot::signal2<>::operator()
*!cricket::VideoCapturer::OnFrameCaptured
*!sigslot::_connection2<>::emit
*!sigslot::signal2<>::operator()
*!cricket::FakeVideoCapturer::CaptureCustomFrame
*!cricket::FakeVideoCapturer::CaptureFrame
*!VideoMediaChannelTest<>::SendFrame
*!VideoMediaChannelTest<>::Send
*!VideoMediaChannelTest<>::TwoStreamsSendAndFailUnsignalledRecv
*!WebRtcVideoMediaChannelTest_TwoStreamsSendAndFailUnsignalledRecv_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

# rtc_unittest, fails on Win DrMemory Full
UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (4)
*!_towlower_l
*!towlower
*!tolowercase
*!rtc::IsDefaultBrowserFirefox
*!rtc::GetProxySettingsForUrl
*!rtc::AutoDetectProxy::GetProxyForUrl
*!rtc::AutoDetectProxy::DoWork
*!rtc::SignalThread::Run
*!rtc::SignalThread::Worker::Run
*!rtc::Thread::PreRun
KERNEL32.dll!BaseThreadInitThunk

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (12)
ntdll.dll!RtlIntegerToUnicodeString
ntdll.dll!RtlIntegerToUnicodeString
libjingle_peerconnection_unittes!rtc::CriticalSection::Enter
libjingle_peerconnection_unittes!rtc::CritScope::CritScope
libjingle_peerconnection_unittes!rtc::LogMessage::~LogMessage
libjingle_peerconnection_unittes!cricket::WebRtcVideoEngine::Print
libjingle_peerconnection_unittes!webrtc::TraceImpl::WriteToFile
libjingle_peerconnection_unittes!webrtc::TraceImpl::Process
libjingle_peerconnection_unittes!webrtc::TraceImpl::Run
libjingle_peerconnection_unittes!webrtc::ThreadWindows::Run
libjingle_peerconnection_unittes!webrtc::ThreadWindows::StartThread
libjingle_peerconnection_unittes!_callthreadstartex
libjingle_peerconnection_unittes!_threadstartex
KERNEL32.dll!BaseThreadInitThunk

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (14)
libjingle_peerconnection_unittes!std::list<>::begin
libjingle_peerconnection_unittes!rtc::LogMessage::~LogMessage
libjingle_peerconnection_unittes!cricket::WebRtcVideoEngine::Construct
libjingle_peerconnection_unittes!cricket::WebRtcVideoEngine::WebRtcVideoEngine
libjingle_peerconnection_unittes!cricket::CompositeMediaEngine<>::CompositeMediaEngine<>
libjingle_peerconnection_unittes!cricket::WebRtcMediaEngine::WebRtcMediaEngine
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::Initialize_s
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::OnMessage
libjingle_peerconnection_unittes!rtc::Thread::Send
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::Initialize
libjingle_peerconnection_unittes!webrtc::CreatePeerConnectionFactory
libjingle_peerconnection_unittes!PeerConnectionInterfaceTest::SetUp
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (15)
ntdll.dll!RtlIntegerToUnicodeString
ntdll.dll!RtlIntegerToUnicodeString
libjingle_peerconnection_unittes!rtc::CriticalSection::Enter
libjingle_peerconnection_unittes!rtc::CritScope::CritScope
libjingle_peerconnection_unittes!rtc::LogMessage::~LogMessage
libjingle_peerconnection_unittes!TestInvalidParameterHandler
libjingle_peerconnection_unittes!_invalid_parameter
...
libjingle_peerconnection_unittes!cricket::WebRtcVideoEngine::Construct
libjingle_peerconnection_unittes!cricket::WebRtcVideoEngine::WebRtcVideoEngine
libjingle_peerconnection_unittes!cricket::CompositeMediaEngine<>::CompositeMediaEngine<>
libjingle_peerconnection_unittes!cricket::WebRtcMediaEngine::WebRtcMediaEngine
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::Initialize_s
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::OnMessage
libjingle_peerconnection_unittes!rtc::Thread::Send
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::Initialize
libjingle_peerconnection_unittes!webrtc::CreatePeerConnectionFactory
libjingle_peerconnection_unittes!PeerConnectionInterfaceTest::SetUp
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (16)
ntdll.dll!RtlIntegerToUnicodeString
ntdll.dll!RtlIntegerToUnicodeString
libjingle_peerconnection_unittes!rtc::CriticalSection::Enter
libjingle_peerconnection_unittes!rtc::CritScope::CritScope
libjingle_peerconnection_unittes!rtc::LogMessage::~LogMessage
libjingle_peerconnection_unittes!cricket::WebRtcVoiceEngine::ConstructCodecs
libjingle_peerconnection_unittes!cricket::WebRtcVoiceEngine::Construct
libjingle_peerconnection_unittes!cricket::WebRtcVoiceEngine::WebRtcVoiceEngine
libjingle_peerconnection_unittes!cricket::CompositeMediaEngine<>::CompositeMediaEngine<>
libjingle_peerconnection_unittes!cricket::WebRtcMediaEngine::WebRtcMediaEngine
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::Initialize_s
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::OnMessage
libjingle_peerconnection_unittes!rtc::Thread::Send
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::Initialize
libjingle_peerconnection_unittes!webrtc::CreatePeerConnectionFactory
libjingle_peerconnection_unittes!PeerConnectionInterfaceTest::SetUp
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (32)
ntdll.dll!RtlIntegerToUnicodeString
ntdll.dll!RtlIntegerToUnicodeString
libjingle_peerconnection_unittes!rtc::CriticalSection::Enter
libjingle_peerconnection_unittes!rtc::CritScope::CritScope
...
libjingle_peerconnection_unittes!testing::internal::CountIf<>
libjingle_peerconnection_unittes!testing::TestResult::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::Run

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (34)
ntdll.dll!RtlIntegerToUnicodeString
ntdll.dll!RtlIntegerToUnicodeString
libjingle_peerconnection_unittes!rtc::CriticalSection::Enter
libjingle_peerconnection_unittes!rtc::CritScope::CritScope
...
libjingle_peerconnection_unittes!TestPureCallHandler
libjingle_peerconnection_unittes!_purecall
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

HANDLE LEAK
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (35)
system call NtCreateEvent
KERNELBASE.dll!CreateEventExW
KERNELBASE.dll!CreateEventW
libjingle_peerconnection_unittes!webrtc::EventWindows::EventWindows
libjingle_peerconnection_unittes!webrtc::EventWrapper::Create
libjingle_peerconnection_unittes!webrtc::ProcessThreadImpl::ProcessThreadImpl
libjingle_peerconnection_unittes!webrtc::ProcessThread::CreateProcessThread
libjingle_peerconnection_unittes!webrtc::voe::SharedData::SharedData
libjingle_peerconnection_unittes!webrtc::VoiceEngineImpl::VoiceEngineImpl
libjingle_peerconnection_unittes!webrtc::GetVoiceEngine
libjingle_peerconnection_unittes!webrtc::VoiceEngine::Create
libjingle_peerconnection_unittes!cricket::VoEWrapper::VoEWrapper
libjingle_peerconnection_unittes!cricket::WebRtcVoiceEngine::WebRtcVoiceEngine
libjingle_peerconnection_unittes!cricket::CompositeMediaEngine<>::CompositeMediaEngine<>
libjingle_peerconnection_unittes!cricket::WebRtcMediaEngine::WebRtcMediaEngine
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::Initialize_s
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::OnMessage
libjingle_peerconnection_unittes!rtc::Thread::Send
libjingle_peerconnection_unittes!webrtc::PeerConnectionFactory::Initialize
libjingle_peerconnection_unittes!webrtc::CreatePeerConnectionFactory
libjingle_peerconnection_unittes!PeerConnectionInterfaceTest::SetUp
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (36)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!webrtc::PeerConnection::CreateAnswer
libjingle_peerconnection_unittes!webrtc::ReturnType<>::Invoke<>
libjingle_peerconnection_unittes!webrtc::MethodCall2<>::OnMessage
libjingle_peerconnection_unittes!rtc::Thread::Send
libjingle_peerconnection_unittes!webrtc::MethodCall2<>::Marshal
libjingle_peerconnection_unittes!webrtc::PeerConnectionProxy::CreateAnswer
libjingle_peerconnection_unittes!PeerConnectionInterfaceTest::DoCreateOfferAnswer
libjingle_peerconnection_unittes!PeerConnectionInterfaceTest::DoCreateAnswer
libjingle_peerconnection_unittes!PeerConnectionInterfaceTest::CreateAnswerAsLocalDescription
libjingle_peerconnection_unittes!PeerConnectionInterfaceTest_ReceiveOfferCreatePrAnswerAndAnswer_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (37)
ntdll.dll!RtlIntegerToUnicodeString
ntdll.dll!RtlIntegerToUnicodeString
libjingle_peerconnection_unittes!rtc::CriticalSection::Enter
libjingle_peerconnection_unittes!rtc::CritScope::CritScope
libjingle_peerconnection_unittes!rtc::LogMessage::GetLogToStream
libjingle_peerconnection_unittes!rtc::LogMessage::ConfigureLogging
libjingle_peerconnection_unittes!main

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (5)
drmemorylib.dll!replace_memcmp
*!TestConnectivity
*!TestPhysicalInternal
*!NatTest_TestPhysicalIPv6_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (6)
*!TestConnectivity
*!TestPhysicalInternal
*!NatTest_TestPhysicalIPv6_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (7)
*!cricket::Candidate::generation
*!P2PTransportChannelTestBase::TestHandleIceUfragPasswordChanged
*!P2PTransportChannelTest_HandleUfragPwdChangeAsIce_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (8)
drmemorylib.dll!replace_memcmp
*!PseudoTcpTest::TestTransfer
*!PseudoTcpTest_TestSendBothUseLargeWindowScale_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (9)
*!testing::internal::CmpHelperEQ<>
*!testing::internal::EqHelper<>::Compare<>
*!PseudoTcpTest::TestTransfer
*!PseudoTcpTest_TestSendBothUseLargeWindowScale_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (10)
libjingle_peerconnection_unittes!webrtc::AudioDeviceWindowsCore::DoRenderThread
libjingle_peerconnection_unittes!webrtc::AudioDeviceWindowsCore::WSAPIRenderThread
KERNEL32.dll!BaseThreadInitThunk

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (11)
libjingle_peerconnection_unittes!webrtc::AudioDeviceWindowsCore::_Lock
libjingle_peerconnection_unittes!webrtc::AudioDeviceWindowsCore::DoRenderThread
libjingle_peerconnection_unittes!webrtc::AudioDeviceWindowsCore::WSAPIRenderThread
KERNEL32.dll!BaseThreadInitThunk

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (13)
libjingle_peerconnection_unittes!webrtc::AudioDeviceWindowsCore::_Lock
libjingle_peerconnection_unittes!webrtc::AudioDeviceWindowsCore::DoRenderThread
libjingle_peerconnection_unittes!webrtc::AudioDeviceWindowsCore::WSAPIRenderThread
KERNEL32.dll!BaseThreadInitThunk

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (17)
libjingle_peerconnection_unittes!testing::Test::HasSameFixtureClass
libjingle_peerconnection_unittes!testing::Test::Run

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (18)
libjingle_peerconnection_unittes!std::_String_val<>::_Myptr
libjingle_peerconnection_unittes!std::basic_string<>::c_str
libjingle_peerconnection_unittes!testing::TestInfo::name
libjingle_peerconnection_unittes!testing::Test::HasSameFixtureClass
libjingle_peerconnection_unittes!testing::Test::Run

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (19)
libjingle_peerconnection_unittes!std::vector<>::_Inside
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (20)
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (21)
libjingle_peerconnection_unittes!std::vector<>::_Unused_capacity
libjingle_peerconnection_unittes!std::vector<>::_Reserve
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (22)
libjingle_peerconnection_unittes!std::vector<>::size
libjingle_peerconnection_unittes!std::vector<>::_Reserve
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (23)
libjingle_peerconnection_unittes!std::vector<>::capacity
libjingle_peerconnection_unittes!std::vector<>::_Grow_to
libjingle_peerconnection_unittes!std::vector<>::_Reserve
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (24)
libjingle_peerconnection_unittes!std::vector<>::_Reallocate
libjingle_peerconnection_unittes!std::vector<>::_Reserve
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (25)
libjingle_peerconnection_unittes!std::vector<>::size
libjingle_peerconnection_unittes!std::vector<>::_Reallocate
libjingle_peerconnection_unittes!std::vector<>::_Reserve
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (26)
libjingle_peerconnection_unittes!std::_Container_base12::_Orphan_all
libjingle_peerconnection_unittes!std::vector<>::_Reallocate
libjingle_peerconnection_unittes!std::vector<>::_Reserve
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (27)
libjingle_peerconnection_unittes!std::_Container_base12::_Getpfirst
libjingle_peerconnection_unittes!std::vector<>::_Orphan_range
libjingle_peerconnection_unittes!std::vector<>::push_back
libjingle_peerconnection_unittes!testing::TestResult::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (28)
libjingle_peerconnection_unittes!std::vector<>::begin
libjingle_peerconnection_unittes!testing::internal::CountIf<>
libjingle_peerconnection_unittes!testing::TestResult::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::Run

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (29)
libjingle_peerconnection_unittes!std::_Iterator_base12::_Adopt
libjingle_peerconnection_unittes!std::_Vector_const_iterator<>::_Vector_const_iterator<>
libjingle_peerconnection_unittes!std::vector<>::begin
libjingle_peerconnection_unittes!testing::internal::CountIf<>
libjingle_peerconnection_unittes!testing::TestResult::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::Run

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (30)
libjingle_peerconnection_unittes!std::vector<>::end
libjingle_peerconnection_unittes!testing::internal::CountIf<>
libjingle_peerconnection_unittes!testing::TestResult::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::Run

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (31)
libjingle_peerconnection_unittes!std::_Iterator_base12::_Adopt
libjingle_peerconnection_unittes!std::_Vector_const_iterator<>::_Vector_const_iterator<>
libjingle_peerconnection_unittes!std::vector<>::end
libjingle_peerconnection_unittes!testing::internal::CountIf<>
libjingle_peerconnection_unittes!testing::TestResult::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::HasFatalFailure
libjingle_peerconnection_unittes!testing::Test::Run

UNADDRESSABLE ACCESS
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (33)
libjingle_peerconnection_unittes!testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult
libjingle_peerconnection_unittes!testing::UnitTest::AddTestPartResult
libjingle_peerconnection_unittes!testing::internal::ReportFailureInUnknownLocation
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (38)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest_TestReceiveSdesOfferCreateSdesAnswer_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (39)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest_TestSetLocalPrAnswer_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (40)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAndSetRemoteOfferAndLocalAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest_TestLocalCandidatesAddedToSessionDescription_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (41)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest_TestSetLocalAndRemoteDescriptionWithCandidates_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (42)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAndSetRemoteOfferAndLocalAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest_TestAVOfferWithAudioOnlyAnswer_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (43)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAndSetRemoteOfferAndLocalAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest_TestAVOfferWithVideoOnlyAnswer_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (44)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest_TestCreateAnswerWithNewUfragAndPassword_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3158 (45)
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::InternalCreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSessionDescriptionFactory::CreateAnswer
libjingle_peerconnection_unittes!webrtc::WebRtcSession::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest::CreateAnswer
libjingle_peerconnection_unittes!WebRtcSessionTest_TestCreateAnswerWithOldUfragAndPassword_Test::TestBody
libjingle_peerconnection_unittes!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3184 (1)
*!webrtc::MouseCursorMonitorWin::Capture
*!webrtc::MouseCursorMonitorTest_FromScreen_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3184 (2)
*!webrtc::DesktopRect::Contains
*!webrtc::MouseCursorMonitorWin::Capture
*!webrtc::MouseCursorMonitorTest_FromScreen_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3184 (3)
*!webrtc::MouseCursorMonitorWin::Capture
*!webrtc::MouseCursorMonitorTest_FromWindow_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3184 (4)
system call NtUserGetWindowPlacement
*!webrtc::GetCroppedWindowRect
*!webrtc::MouseCursorMonitorWin::Capture
*!webrtc::MouseCursorMonitorTest_FromWindow_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3184 (5)
*!webrtc::GetCroppedWindowRect
*!webrtc::MouseCursorMonitorWin::Capture
*!webrtc::MouseCursorMonitorTest_FromWindow_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3184 (6)
system call NtUserWindowFromPoint parameter value #0
*!webrtc::MouseCursorMonitorWin::Capture
*!webrtc::MouseCursorMonitorTest_FromWindow_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3184 (7)
*!webrtc::MouseCursorMonitorWin::Capture
*!webrtc::MouseCursorMonitorTest_ShapeOnly_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3490 (3)
drmemorylib.dll!replace_memcmp
*!rtc::AsyncWriteTest_TestWrite_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>

UNINITIALIZED READ
name=https://code.google.com/p/webrtc/issues/detail?id=3490 (4)
*!testing::internal::CmpHelperEQ<>
*!testing::internal::EqHelper<>::Compare<>
*!rtc::AsyncWriteTest_TestWrite_Test::TestBody
*!testing::internal::HandleSehExceptionsInMethodIfSupported<>
