Fix threading races on HRTFElevation::audioBusMap

Source/core/platform/audio/HRTFElevation.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 19 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 
 #include "core/platform/audio/HRTFElevation.h"
 
 #include <math.h>
 #include <algorithm>
 #include "core/platform/audio/AudioBus.h"
 #include "core/platform/audio/HRTFPanner.h"
 #include "wtf/OwnPtr.h"
+#include "wtf/ThreadingPrimitives.h"
 
 using namespace std;
 
 namespace WebCore {
 
 const unsigned HRTFElevation::AzimuthSpacing = 15;
 const unsigned HRTFElevation::NumberOfRawAzimuths = 360 / AzimuthSpacing;
 const unsigned HRTFElevation::InterpolationFactor = 8;
 const unsigned HRTFElevation::NumberOfTotalAzimuths = NumberOfRawAzimuths * InterpolationFactor;
 
 // Total number of components of an HRTF database.
 const size_t TotalNumberOfResponses = 240;
 
 // Number of frames in an individual impulse response.
 const size_t ResponseFrameSize = 256;
 
 // Sample-rate of the spatialization impulse responses as stored in the resource file.
 // The impulse responses may be resampled to a different sample-rate (depending on the audio hardware) when they are loaded.
 const float ResponseSampleRate = 44100;
 
 #if USE(CONCATENATED_IMPULSE_RESPONSES)
 // Lazily load a concatenated HRTF database for given subject and store it in a
 // local hash table to ensure quick efficient future retrievals.
 static PassRefPtr<AudioBus> getConcatenatedImpulseResponsesForSubject(const String& subjectName)
 {
     typedef HashMap<String, RefPtr<AudioBus> > AudioBusMap;
     DEFINE_STATIC_LOCAL(AudioBusMap, audioBusMap, ());
+    DEFINE_STATIC_LOCAL(Mutex, mutex, ());

[Ken Russell (switch to Gerrit), 2013/09/04 19:57:55]

This doesn't look any safer to me. If there is really a race then two threads
could plausibly call this function the first time and race for the
initialization of these static locals.

 
+    MutexLocker locker(mutex);
     RefPtr<AudioBus> bus;
     AudioBusMap::iterator iterator = audioBusMap.find(subjectName);
     if (iterator == audioBusMap.end()) {
         RefPtr<AudioBus> concatenatedImpulseResponses(AudioBus::loadPlatformResource(subjectName.utf8().data(), ResponseSampleRate));
         ASSERT(concatenatedImpulseResponses);
         if (!concatenatedImpulseResponses)
             return 0;
 
         bus = concatenatedImpulseResponses;
         audioBusMap.set(subjectName, bus);
@@ skipping 252 matching lines @@
     double frameDelay2R = m_kernelListR->at(azimuthIndex2)->frameDelay();
 
     // Linearly interpolate delays.
     frameDelayL = (1.0 - azimuthBlend) * frameDelayL + azimuthBlend * frameDelay2L;
     frameDelayR = (1.0 - azimuthBlend) * frameDelayR + azimuthBlend * frameDelay2R;
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)