Changeset 187972 in webkit

Timestamp:

Aug 5, 2015, 12:20:22 PM (10 years ago)

Author:

[email protected]

Message:

Rename Mutex to DeprecatedMutex
​https://bugs.webkit.org/show_bug.cgi?id=147675

Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

• bytecode/SamplingTool.cpp:

(JSC::SamplingTool::doRun):
(JSC::SamplingTool::notifyOfScope):

• bytecode/SamplingTool.h:
• dfg/DFGThreadData.h:
• dfg/DFGWorklist.cpp:

(JSC::DFG::Worklist::~Worklist):
(JSC::DFG::Worklist::isActiveForVM):
(JSC::DFG::Worklist::enqueue):
(JSC::DFG::Worklist::compilationState):
(JSC::DFG::Worklist::waitUntilAllPlansForVMAreReady):
(JSC::DFG::Worklist::removeAllReadyPlansForVM):
(JSC::DFG::Worklist::completeAllReadyPlansForVM):
(JSC::DFG::Worklist::visitWeakReferences):
(JSC::DFG::Worklist::removeDeadPlans):
(JSC::DFG::Worklist::queueLength):
(JSC::DFG::Worklist::dump):
(JSC::DFG::Worklist::runThread):

• dfg/DFGWorklist.h:
• disassembler/Disassembler.cpp:
• heap/CopiedSpace.cpp:

(JSC::CopiedSpace::doneFillingBlock):
(JSC::CopiedSpace::doneCopying):

• heap/CopiedSpace.h:
• heap/CopiedSpaceInlines.h:

(JSC::CopiedSpace::recycleBorrowedBlock):
(JSC::CopiedSpace::allocateBlockForCopyingPhase):

• heap/HeapTimer.h:
• heap/MachineStackMarker.cpp:

(JSC::ActiveMachineThreadsManager::Locker::Locker):
(JSC::ActiveMachineThreadsManager::add):
(JSC::ActiveMachineThreadsManager::remove):
(JSC::ActiveMachineThreadsManager::ActiveMachineThreadsManager):
(JSC::MachineThreads::~MachineThreads):
(JSC::MachineThreads::addCurrentThread):
(JSC::MachineThreads::removeThreadIfFound):
(JSC::MachineThreads::tryCopyOtherThreadStack):
(JSC::MachineThreads::tryCopyOtherThreadStacks):
(JSC::MachineThreads::gatherConservativeRoots):

• heap/MachineStackMarker.h:
• interpreter/JSStack.cpp:

(JSC::stackStatisticsMutex):
(JSC::JSStack::addToCommittedByteCount):
(JSC::JSStack::committedByteCount):

• jit/JITThunks.h:
• profiler/ProfilerDatabase.h:

Source/WebCore:

No new tests because this is just a renaming.

• Modules/webaudio/AsyncAudioDecoder.cpp:

(WebCore::AsyncAudioDecoder::AsyncAudioDecoder):
(WebCore::AsyncAudioDecoder::runLoop):

• Modules/webaudio/AsyncAudioDecoder.h:
• Modules/webaudio/AudioContext.h:
• Modules/webaudio/MediaStreamAudioSource.cpp:

(WebCore::MediaStreamAudioSource::addAudioConsumer):
(WebCore::MediaStreamAudioSource::removeAudioConsumer):
(WebCore::MediaStreamAudioSource::setAudioFormat):
(WebCore::MediaStreamAudioSource::consumeAudio):

• Modules/webaudio/MediaStreamAudioSource.h:
• Modules/webdatabase/Database.cpp:

(WebCore::Database::close):
(WebCore::Database::runTransaction):
(WebCore::Database::inProgressTransactionCompleted):
(WebCore::Database::hasPendingTransaction):

• Modules/webdatabase/DatabaseBackend.h:
• Modules/webdatabase/DatabaseBackendBase.cpp:

(WebCore::DatabaseBackendBase::performOpenAndVerify):
(WebCore::DatabaseBackendBase::isInterrupted):

• Modules/webdatabase/DatabaseContext.cpp:

(WebCore::DatabaseContext::databaseThread):
(WebCore::DatabaseContext::setPaused):

• Modules/webdatabase/DatabaseContext.h:
• Modules/webdatabase/DatabaseTask.h:
• Modules/webdatabase/DatabaseThread.cpp:

(WebCore::DatabaseThread::start):
(WebCore::DatabaseThread::setPaused):
(WebCore::DatabaseThread::handlePausedQueue):
(WebCore::DatabaseThread::databaseThread):

• Modules/webdatabase/DatabaseThread.h:
• Modules/webdatabase/DatabaseTracker.cpp:

(WebCore::DatabaseTracker::setDatabaseDirectoryPath):
(WebCore::DatabaseTracker::canEstablishDatabase):
(WebCore::DatabaseTracker::retryCanEstablishDatabase):
(WebCore::DatabaseTracker::hasEntryForOrigin):
(WebCore::DatabaseTracker::getMaxSizeForDatabase):
(WebCore::DatabaseTracker::closeAllDatabases):
(WebCore::DatabaseTracker::interruptAllDatabasesForContext):
(WebCore::DatabaseTracker::fullPathForDatabase):
(WebCore::DatabaseTracker::origins):
(WebCore::DatabaseTracker::databaseNamesForOrigin):
(WebCore::DatabaseTracker::detailsForNameAndOrigin):
(WebCore::DatabaseTracker::setDatabaseDetails):
(WebCore::DatabaseTracker::doneCreatingDatabase):
(WebCore::DatabaseTracker::addOpenDatabase):
(WebCore::DatabaseTracker::removeOpenDatabase):
(WebCore::DatabaseTracker::getOpenDatabases):
(WebCore::DatabaseTracker::originLockFor):
(WebCore::DatabaseTracker::quotaForOrigin):
(WebCore::DatabaseTracker::setQuota):
(WebCore::DatabaseTracker::deleteOrigin):
(WebCore::DatabaseTracker::deleteDatabase):
(WebCore::DatabaseTracker::deleteDatabaseFile):
(WebCore::DatabaseTracker::removeDeletedOpenedDatabases):
(WebCore::DatabaseTracker::deleteDatabaseFileIfEmpty):
(WebCore::DatabaseTracker::openDatabaseMutex):
(WebCore::DatabaseTracker::setDatabasesPaused):
(WebCore::DatabaseTracker::setClient):
(WebCore::notificationMutex):
(WebCore::DatabaseTracker::scheduleNotifyDatabaseChanged):
(WebCore::DatabaseTracker::notifyDatabasesChanged):

• Modules/webdatabase/DatabaseTracker.h:
• Modules/webdatabase/OriginLock.h:
• Modules/webdatabase/SQLCallbackWrapper.h:

(WebCore::SQLCallbackWrapper::clear):
(WebCore::SQLCallbackWrapper::unwrap):
(WebCore::SQLCallbackWrapper::hasCallback):

• Modules/webdatabase/SQLTransactionBackend.cpp:

(WebCore::SQLTransactionBackend::doCleanup):
(WebCore::SQLTransactionBackend::enqueueStatementBackend):
(WebCore::SQLTransactionBackend::getNextStatement):

• Modules/webdatabase/SQLTransactionBackend.h:
• bindings/js/WorkerScriptController.cpp:

(WebCore::WorkerScriptController::scheduleExecutionTermination):
(WebCore::WorkerScriptController::isExecutionTerminating):

• bindings/js/WorkerScriptController.h:
• dom/default/PlatformMessagePortChannel.cpp:

(WebCore::MessagePortChannel::postMessageToRemote):
(WebCore::MessagePortChannel::tryGetMessageFromRemote):
(WebCore::MessagePortChannel::isConnectedTo):
(WebCore::MessagePortChannel::hasPendingActivity):
(WebCore::MessagePortChannel::locallyEntangledPort):
(WebCore::PlatformMessagePortChannel::setRemotePort):
(WebCore::PlatformMessagePortChannel::entangledChannel):
(WebCore::PlatformMessagePortChannel::closeInternal):

• dom/default/PlatformMessagePortChannel.h:
• loader/icon/IconDatabase.cpp:

(WebCore::IconDatabase::removeAllIcons):
(WebCore::IconDatabase::synchronousIconForPageURL):
(WebCore::IconDatabase::synchronousNativeIconForPageURL):
(WebCore::IconDatabase::synchronousIconURLForPageURL):
(WebCore::IconDatabase::retainIconForPageURL):
(WebCore::IconDatabase::performRetainIconForPageURL):
(WebCore::IconDatabase::releaseIconForPageURL):
(WebCore::IconDatabase::performReleaseIconForPageURL):
(WebCore::IconDatabase::setIconDataForIconURL):
(WebCore::IconDatabase::setIconURLForPageURL):
(WebCore::IconDatabase::synchronousLoadDecisionForIconURL):
(WebCore::IconDatabase::synchronousIconDataKnownForIconURL):
(WebCore::IconDatabase::pageURLMappingCount):
(WebCore::IconDatabase::retainedPageURLCount):
(WebCore::IconDatabase::iconRecordCount):
(WebCore::IconDatabase::iconRecordCountWithData):
(WebCore::IconDatabase::wakeSyncThread):
(WebCore::IconDatabase::isOpenBesidesMainThreadCallbacks):
(WebCore::IconDatabase::databasePath):
(WebCore::IconDatabase::getOrCreatePageURLRecord):
(WebCore::IconDatabase::iconDatabaseSyncThread):
(WebCore::IconDatabase::performOpenInitialization):
(WebCore::IconDatabase::performURLImport):
(WebCore::IconDatabase::syncThreadMainLoop):
(WebCore::IconDatabase::performPendingRetainAndReleaseOperations):
(WebCore::IconDatabase::readFromDatabase):
(WebCore::IconDatabase::writeToDatabase):
(WebCore::IconDatabase::pruneUnretainedIcons):
(WebCore::IconDatabase::cleanupSyncThread):

• loader/icon/IconDatabase.h:
• page/scrolling/ScrollingTree.cpp:

(WebCore::ScrollingTree::shouldHandleWheelEventSynchronously):
(WebCore::ScrollingTree::commitNewTreeState):
(WebCore::ScrollingTree::setMainFramePinState):
(WebCore::ScrollingTree::mainFrameScrollPosition):
(WebCore::ScrollingTree::setMainFrameScrollPosition):
(WebCore::ScrollingTree::isPointInNonFastScrollableRegion):
(WebCore::ScrollingTree::isRubberBandInProgress):
(WebCore::ScrollingTree::setMainFrameIsRubberBanding):
(WebCore::ScrollingTree::isScrollSnapInProgress):
(WebCore::ScrollingTree::setMainFrameIsScrollSnapping):
(WebCore::ScrollingTree::setCanRubberBandState):
(WebCore::ScrollingTree::rubberBandsAtLeft):
(WebCore::ScrollingTree::rubberBandsAtRight):
(WebCore::ScrollingTree::rubberBandsAtBottom):
(WebCore::ScrollingTree::rubberBandsAtTop):
(WebCore::ScrollingTree::setScrollPinningBehavior):
(WebCore::ScrollingTree::scrollPinningBehavior):
(WebCore::ScrollingTree::willWheelEventStartSwipeGesture):
(WebCore::ScrollingTree::latchedNode):
(WebCore::ScrollingTree::setLatchedNode):
(WebCore::ScrollingTree::clearLatchedNode):

• page/scrolling/ScrollingTree.h:
• platform/MemoryPressureHandler.h:
• platform/audio/HRTFDatabaseLoader.cpp:

(WebCore::HRTFDatabaseLoader::loadAsynchronously):
(WebCore::HRTFDatabaseLoader::waitForLoaderThreadCompletion):

• platform/audio/HRTFDatabaseLoader.h:
• platform/cocoa/MemoryPressureHandlerCocoa.mm:

(WebCore::MemoryPressureHandler::setReceivedMemoryPressure):
(WebCore::MemoryPressureHandler::clearMemoryPressure):
(WebCore::MemoryPressureHandler::shouldWaitForMemoryClearMessage):
(WebCore::MemoryPressureHandler::respondToMemoryPressureIfNeeded):

• platform/graphics/DisplayRefreshMonitor.cpp:

(WebCore::DisplayRefreshMonitor::displayDidRefresh):

• platform/graphics/DisplayRefreshMonitor.h:

(WebCore::DisplayRefreshMonitor::setMonotonicAnimationStartTime):
(WebCore::DisplayRefreshMonitor::mutex):

• platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp:

(WebCore::MediaPlayerPrivateAVFoundation::setDelayCallbacks):
(WebCore::MediaPlayerPrivateAVFoundation::clearMainThreadPendingFlag):
(WebCore::MediaPlayerPrivateAVFoundation::dispatchNotification):

• platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
• platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp:

(WebCore::AVFWrapper::callbackContext):
(WebCore::AVFWrapper::~AVFWrapper):
(WebCore::AVFWrapper::mapLock):
(WebCore::AVFWrapper::addToMap):
(WebCore::AVFWrapper::removeFromMap):
(WebCore::AVFWrapper::periodicTimeObserverCallback):
(WebCore::AVFWrapper::processNotification):
(WebCore::AVFWrapper::loadPlayableCompletionCallback):
(WebCore::AVFWrapper::loadMetadataCompletionCallback):
(WebCore::AVFWrapper::seekCompletedCallback):
(WebCore::AVFWrapper::processCue):
(WebCore::AVFWrapper::legibleOutputCallback):
(WebCore::AVFWrapper::processShouldWaitForLoadingOfResource):
(WebCore::AVFWrapper::resourceLoaderShouldWaitForLoadingOfRequestedResource):

• platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.cpp:

(WebCore::InbandTextTrackPrivateGStreamer::handleSample):
(WebCore::InbandTextTrackPrivateGStreamer::notifyTrackOfSample):

• platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.h:
• platform/graphics/gstreamer/TrackPrivateBaseGStreamer.cpp:

(WebCore::TrackPrivateBaseGStreamer::tagsChanged):
(WebCore::TrackPrivateBaseGStreamer::notifyTrackOfTagsChanged):

• platform/graphics/gstreamer/TrackPrivateBaseGStreamer.h:
• platform/graphics/mac/DisplayRefreshMonitorMac.cpp:

(WebCore::DisplayRefreshMonitorMac::requestRefreshCallback):
(WebCore::DisplayRefreshMonitorMac::displayLinkFired):

• platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp:

(WebCore::MediaPlayerPrivateMediaFoundation::addListener):
(WebCore::MediaPlayerPrivateMediaFoundation::removeListener):
(WebCore::MediaPlayerPrivateMediaFoundation::notifyDeleted):
(WebCore::MediaPlayerPrivateMediaFoundation::AsyncCallback::Invoke):
(WebCore::MediaPlayerPrivateMediaFoundation::AsyncCallback::onMediaPlayerDeleted):

• platform/graphics/win/MediaPlayerPrivateMediaFoundation.h:
• platform/ios/LegacyTileCache.h:
• platform/ios/LegacyTileCache.mm:

(WebCore::LegacyTileCache::setTilesOpaque):
(WebCore::LegacyTileCache::doLayoutTiles):
(WebCore::LegacyTileCache::setCurrentScale):
(WebCore::LegacyTileCache::commitScaleChange):
(WebCore::LegacyTileCache::layoutTilesNow):
(WebCore::LegacyTileCache::layoutTilesNowForRect):
(WebCore::LegacyTileCache::removeAllNonVisibleTiles):
(WebCore::LegacyTileCache::removeAllTiles):
(WebCore::LegacyTileCache::removeForegroundTiles):
(WebCore::LegacyTileCache::setContentReplacementImage):
(WebCore::LegacyTileCache::contentReplacementImage):
(WebCore::LegacyTileCache::tileCreationTimerFired):
(WebCore::LegacyTileCache::setNeedsDisplayInRect):
(WebCore::LegacyTileCache::updateTilingMode):
(WebCore::LegacyTileCache::setTilingMode):
(WebCore::LegacyTileCache::doPendingRepaints):
(WebCore::LegacyTileCache::flushSavedDisplayRects):
(WebCore::LegacyTileCache::prepareToDraw):

• platform/ios/LegacyTileLayerPool.h:
• platform/ios/LegacyTileLayerPool.mm:

(WebCore::LegacyTileLayerPool::addLayer):
(WebCore::LegacyTileLayerPool::takeLayerWithSize):
(WebCore::LegacyTileLayerPool::setCapacity):
(WebCore::LegacyTileLayerPool::prune):
(WebCore::LegacyTileLayerPool::drain):

• platform/network/curl/CurlDownload.cpp:

(WebCore::CurlDownloadManager::add):
(WebCore::CurlDownloadManager::remove):
(WebCore::CurlDownloadManager::getActiveDownloadCount):
(WebCore::CurlDownloadManager::getPendingDownloadCount):
(WebCore::CurlDownloadManager::stopThreadIfIdle):
(WebCore::CurlDownloadManager::updateHandleList):
(WebCore::CurlDownload::~CurlDownload):
(WebCore::CurlDownload::init):
(WebCore::CurlDownload::getTempPath):
(WebCore::CurlDownload::getUrl):
(WebCore::CurlDownload::getResponse):
(WebCore::CurlDownload::closeFile):
(WebCore::CurlDownload::didReceiveHeader):
(WebCore::CurlDownload::didReceiveData):
(WebCore::CurlDownload::didFail):

• platform/network/curl/CurlDownload.h:
• platform/network/curl/ResourceHandleManager.cpp:

(WebCore::cookieJarPath):
(WebCore::sharedResourceMutex):
(WebCore::curl_lock_callback):
(WebCore::curl_unlock_callback):

• platform/network/ios/QuickLook.mm:

(WebCore::QLDirectoryAttributes):
(qlPreviewConverterDictionaryMutex):
(WebCore::addQLPreviewConverterWithFileForURL):
(WebCore::qlPreviewConverterUTIForURL):
(WebCore::removeQLPreviewConverterForURL):
(WebCore::safeQLURLForDocumentURLAndResourceURL):

• platform/sql/SQLiteDatabase.cpp:

(WebCore::SQLiteDatabase::close):
(WebCore::SQLiteDatabase::interrupt):
(WebCore::SQLiteDatabase::maximumSize):
(WebCore::SQLiteDatabase::setMaximumSize):
(WebCore::SQLiteDatabase::pageSize):
(WebCore::SQLiteDatabase::freeSpaceSize):
(WebCore::SQLiteDatabase::totalSize):
(WebCore::SQLiteDatabase::runIncrementalVacuumCommand):
(WebCore::SQLiteDatabase::setAuthorizer):

• platform/sql/SQLiteDatabase.h:

(WebCore::SQLiteDatabase::databaseMutex):

• platform/sql/SQLiteStatement.cpp:

(WebCore::SQLiteStatement::prepare):
(WebCore::SQLiteStatement::step):

• workers/WorkerThread.cpp:

(WebCore::WorkerThread::start):
(WebCore::WorkerThread::workerThread):
(WebCore::WorkerThread::stop):

• workers/WorkerThread.h:

Source/WebKit:

• Storage/StorageAreaSync.cpp:

(WebCore::StorageAreaSync::syncTimerFired):
(WebCore::StorageAreaSync::markImported):
(WebCore::StorageAreaSync::blockUntilImportComplete):
(WebCore::StorageAreaSync::performSync):

• Storage/StorageAreaSync.h:
• Storage/StorageTracker.cpp:

(WebCore::StorageTracker::setDatabaseDirectoryPath):
(WebCore::StorageTracker::finishedImportingOriginIdentifiers):
(WebCore::StorageTracker::syncImportOriginIdentifiers):
(WebCore::StorageTracker::syncFileSystemAndTrackerDatabase):
(WebCore::StorageTracker::setOriginDetails):
(WebCore::StorageTracker::syncSetOriginDetails):
(WebCore::StorageTracker::origins):
(WebCore::StorageTracker::deleteAllOrigins):
(WebCore::StorageTracker::syncDeleteAllOrigins):
(WebCore::StorageTracker::deleteOrigin):
(WebCore::StorageTracker::syncDeleteOrigin):
(WebCore::StorageTracker::canDeleteOrigin):
(WebCore::StorageTracker::cancelDeletingOrigin):
(WebCore::StorageTracker::diskUsageForOrigin):

• Storage/StorageTracker.h:

Source/WebKit/ios:

• WebCoreSupport/WebFixedPositionContent.mm:

(WebFixedPositionContentDataLock):
(-[WebFixedPositionContent scrollOrZoomChanged:]):
(-[WebFixedPositionContent overflowScrollPositionForLayer:changedTo:]):
(-[WebFixedPositionContent setViewportConstrainedLayers:stickyContainerMap:]):
(-[WebFixedPositionContent hasFixedOrStickyPositionLayers]):
(-[WebFixedPositionContent minimumOffsetFromFixedPositionLayersToAnchorEdge:ofRect:inLayer:]):

Source/WebKit/mac:

• Storage/WebDatabaseManager.mm:

(transactionBackgroundTaskIdentifierLock):
(+[WebDatabaseManager startBackgroundTask]):
(+[WebDatabaseManager endBackgroundTask]):

• WebView/WebView.mm:

(-[WebView _synchronizeCustomFixedPositionLayoutRect]):
(-[WebView _setCustomFixedPositionLayoutRectInWebThread:synchronize:]):
(-[WebView _setCustomFixedPositionLayoutRect:]):
(-[WebView _fetchCustomFixedPositionLayoutRect:]):

• WebView/WebViewData.h:

Source/WebKit/win:

• Plugins/PluginMainThreadScheduler.cpp:

(WebCore::PluginMainThreadScheduler::scheduleCall):
(WebCore::PluginMainThreadScheduler::registerPlugin):
(WebCore::PluginMainThreadScheduler::unregisterPlugin):
(WebCore::PluginMainThreadScheduler::dispatchCallsForPlugin):

• Plugins/PluginMainThreadScheduler.h:
• WebIconDatabase.cpp:

(WebIconDatabase::didRemoveAllIcons):
(WebIconDatabase::didImportIconURLForPageURL):
(WebIconDatabase::deliverNotifications):

• WebLocalizableStrings.cpp:

(mainBundleLocStrings):
(frameworkLocStringsMutex):
(findCachedString):
(cacheString):

Source/WebKit2:

• DatabaseProcess/DatabaseProcess.cpp:

(WebKit::DatabaseProcess::postDatabaseTask):
(WebKit::DatabaseProcess::performNextDatabaseTask):

• DatabaseProcess/DatabaseProcess.h:
• DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp:

(WebKit::UniqueIDBDatabase::shutdown):
(WebKit::UniqueIDBDatabase::postMainThreadTask):
(WebKit::UniqueIDBDatabase::performNextMainThreadTask):
(WebKit::UniqueIDBDatabase::postDatabaseTask):
(WebKit::UniqueIDBDatabase::performNextDatabaseTask):

• DatabaseProcess/IndexedDB/UniqueIDBDatabase.h:
• Platform/IPC/Connection.cpp:

(IPC::Connection::sendSyncMessage):
(IPC::Connection::sendSyncMessageFromSecondaryThread):
(IPC::Connection::waitForSyncReply):
(IPC::Connection::processIncomingSyncReply):
(IPC::Connection::connectionDidClose):

• Platform/IPC/Connection.h:
• Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp:

(WebKit::CoordinatedGraphicsScene::appendUpdate):

• Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h:
• Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.cpp:

(WebKit::ThreadedCompositor::createCompositingThread):
(WebKit::ThreadedCompositor::runCompositingThread):
(WebKit::ThreadedCompositor::terminateCompositingThread):

• Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.h:
• Shared/Network/CustomProtocols/Cocoa/CustomProtocolManagerCocoa.mm:

(WebKit::CustomProtocolManager::addCustomProtocol):
(WebKit::CustomProtocolManager::removeCustomProtocol):
(WebKit::CustomProtocolManager::registerScheme):
(WebKit::CustomProtocolManager::unregisterScheme):
(WebKit::CustomProtocolManager::supportsScheme):
(WebKit::CustomProtocolManager::protocolForID):

• Shared/Network/CustomProtocols/CustomProtocolManager.h:
• Shared/linux/SeccompFilters/SeccompBroker.cpp:
• WebProcess/Plugins/PluginProcessConnectionManager.cpp:

(WebKit::PluginProcessConnectionManager::getPluginProcessConnection):
(WebKit::PluginProcessConnectionManager::removePluginProcessConnection):
(WebKit::PluginProcessConnectionManager::pluginProcessCrashed):

• WebProcess/Plugins/PluginProcessConnectionManager.h:
• WebProcess/WebPage/EventDispatcher.cpp:

(WebKit::EventDispatcher::addScrollingTreeForPage):
(WebKit::EventDispatcher::removeScrollingTreeForPage):
(WebKit::EventDispatcher::wheelEvent):

• WebProcess/WebPage/EventDispatcher.h:
• WebProcess/soup/WebKitSoupRequestInputStream.cpp:

(webkitSoupRequestInputStreamReadAsync):
(webkitSoupRequestInputStreamAddData):

Source/WTF:

• wtf/Atomics.cpp:

(WTF::getSwapLock):
(WTF::atomicStep):

• wtf/MessageQueue.h:

(WTF::MessageQueue::infiniteTime):
(WTF::MessageQueue<DataType>::append):
(WTF::MessageQueue<DataType>::appendAndKill):
(WTF::MessageQueue<DataType>::appendAndCheckEmpty):
(WTF::MessageQueue<DataType>::prepend):
(WTF::MessageQueue<DataType>::removeIf):
(WTF::MessageQueue<DataType>::isEmpty):
(WTF::MessageQueue<DataType>::kill):
(WTF::MessageQueue<DataType>::killed):

• wtf/ParallelJobsGeneric.cpp:

(WTF::ParallelEnvironment::ThreadPrivate::execute):
(WTF::ParallelEnvironment::ThreadPrivate::waitForFinish):
(WTF::ParallelEnvironment::ThreadPrivate::workerThread):

• wtf/ParallelJobsGeneric.h:
• wtf/RunLoop.cpp:

(WTF::RunLoop::performWork):
(WTF::RunLoop::dispatch):

• wtf/RunLoop.h:
• wtf/Threading.cpp:

(WTF::threadEntryPoint):
(WTF::createThread):

• wtf/ThreadingPrimitives.h:
• wtf/ThreadingPthreads.cpp:

(WTF::threadMapMutex):
(WTF::initializeThreading):
(WTF::identifierByPthreadHandle):
(WTF::establishIdentifierForPthreadHandle):
(WTF::changeThreadPriority):
(WTF::waitForThreadCompletion):
(WTF::detachThread):
(WTF::threadDidExit):
(WTF::currentThread):
(WTF::DeprecatedMutex::DeprecatedMutex):
(WTF::DeprecatedMutex::~DeprecatedMutex):
(WTF::DeprecatedMutex::lock):
(WTF::DeprecatedMutex::tryLock):
(WTF::DeprecatedMutex::unlock):
(WTF::ThreadCondition::~ThreadCondition):
(WTF::ThreadCondition::wait):
(WTF::ThreadCondition::timedWait):
(WTF::Mutex::Mutex): Deleted.
(WTF::Mutex::~Mutex): Deleted.
(WTF::Mutex::lock): Deleted.
(WTF::Mutex::tryLock): Deleted.
(WTF::Mutex::unlock): Deleted.

• wtf/ThreadingWin.cpp:

(WTF::initializeCurrentThreadInternal):
(WTF::threadMapMutex):
(WTF::initializeThreading):
(WTF::storeThreadHandleByIdentifier):
(WTF::threadHandleForIdentifier):
(WTF::clearThreadHandleForIdentifier):
(WTF::currentThread):
(WTF::DeprecatedMutex::DeprecatedMutex):
(WTF::DeprecatedMutex::~DeprecatedMutex):
(WTF::DeprecatedMutex::lock):
(WTF::DeprecatedMutex::tryLock):
(WTF::DeprecatedMutex::unlock):
(WTF::ThreadCondition::~ThreadCondition):
(WTF::ThreadCondition::wait):
(WTF::ThreadCondition::timedWait):
(WTF::Mutex::Mutex): Deleted.
(WTF::Mutex::~Mutex): Deleted.
(WTF::Mutex::lock): Deleted.
(WTF::Mutex::tryLock): Deleted.
(WTF::Mutex::unlock): Deleted.

• wtf/WorkQueue.h:
• wtf/dtoa.cpp:
• wtf/dtoa.h:
• wtf/efl/DispatchQueueEfl.cpp:

(DispatchQueue::dispatch):
(DispatchQueue::performWork):
(DispatchQueue::performTimerWork):
(DispatchQueue::insertTimerWorkItem):
(DispatchQueue::wakeUpThread):
(DispatchQueue::getNextTimeOut):

• wtf/efl/DispatchQueueEfl.h:
• wtf/efl/RunLoopEfl.cpp:

(WTF::RunLoop::wakeUpEvent):
(WTF::RunLoop::wakeUp):

• wtf/threads/BinarySemaphore.cpp:

(WTF::BinarySemaphore::signal):
(WTF::BinarySemaphore::wait):

• wtf/threads/BinarySemaphore.h:
• wtf/win/WorkQueueWin.cpp:

(WTF::WorkQueue::handleCallback):
(WTF::WorkQueue::platformInvalidate):
(WTF::WorkQueue::dispatch):
(WTF::WorkQueue::timerCallback):
(WTF::WorkQueue::dispatchAfter):

Tools:

• DumpRenderTree/JavaScriptThreading.cpp:

(javaScriptThreadsMutex):
(runJavaScriptThread):
(startJavaScriptThreads):
(stopJavaScriptThreads):

• TestWebKitAPI/Tests/WTF/WorkQueue.cpp:

(TestWebKitAPI::TEST):

• TestWebKitAPI/Tests/WTF/glib/WorkQueueGLib.cpp:

(TestWebKitAPI::TEST):

Location:

trunk

Files:

• Source/JavaScriptCore/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/bytecode/SamplingTool.cpp (modified) (2 diffs)
• Source/JavaScriptCore/bytecode/SamplingTool.h (modified) (1 diff)
• Source/JavaScriptCore/dfg/DFGThreadData.h (modified) (1 diff)
• Source/JavaScriptCore/dfg/DFGWorklist.cpp (modified) (15 diffs)
• Source/JavaScriptCore/dfg/DFGWorklist.h (modified) (2 diffs)
• Source/JavaScriptCore/disassembler/Disassembler.cpp (modified) (4 diffs)
• Source/JavaScriptCore/heap/CopiedSpace.cpp (modified) (2 diffs)
• Source/JavaScriptCore/heap/CopiedSpace.h (modified) (1 diff)
• Source/JavaScriptCore/heap/CopiedSpaceInlines.h (modified) (2 diffs)
• Source/JavaScriptCore/heap/HeapTimer.h (modified) (1 diff)
• Source/JavaScriptCore/heap/MachineStackMarker.cpp (modified) (8 diffs)
• Source/JavaScriptCore/heap/MachineStackMarker.h (modified) (2 diffs)
• Source/JavaScriptCore/interpreter/JSStack.cpp (modified) (3 diffs)
• Source/JavaScriptCore/jit/JITThunks.h (modified) (1 diff)
• Source/JavaScriptCore/profiler/ProfilerDatabase.h (modified) (1 diff)
• Source/WTF/ChangeLog (modified) (1 diff)
• Source/WTF/wtf/Atomics.cpp (modified) (2 diffs)
• Source/WTF/wtf/MessageQueue.h (modified) (12 diffs)
• Source/WTF/wtf/ParallelJobsGeneric.cpp (modified) (3 diffs)
• Source/WTF/wtf/ParallelJobsGeneric.h (modified) (1 diff)
• Source/WTF/wtf/RunLoop.cpp (modified) (3 diffs)
• Source/WTF/wtf/RunLoop.h (modified) (2 diffs)
• Source/WTF/wtf/Threading.cpp (modified) (3 diffs)
• Source/WTF/wtf/ThreadingPrimitives.h (modified) (4 diffs)
• Source/WTF/wtf/ThreadingPthreads.cpp (modified) (16 diffs)
• Source/WTF/wtf/ThreadingWin.cpp (modified) (10 diffs)
• Source/WTF/wtf/WorkQueue.h (modified) (1 diff)
• Source/WTF/wtf/dtoa.cpp (modified) (1 diff)
• Source/WTF/wtf/dtoa.h (modified) (1 diff)
• Source/WTF/wtf/efl/DispatchQueueEfl.cpp (modified) (6 diffs)
• Source/WTF/wtf/efl/DispatchQueueEfl.h (modified) (2 diffs)
• Source/WTF/wtf/efl/RunLoopEfl.cpp (modified) (3 diffs)
• Source/WTF/wtf/threads/BinarySemaphore.cpp (modified) (2 diffs)
• Source/WTF/wtf/threads/BinarySemaphore.h (modified) (1 diff)
• Source/WTF/wtf/win/WorkQueueWin.cpp (modified) (6 diffs)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/Modules/webaudio/AsyncAudioDecoder.cpp (modified) (2 diffs)
• Source/WebCore/Modules/webaudio/AsyncAudioDecoder.h (modified) (1 diff)
• Source/WebCore/Modules/webaudio/AudioContext.h (modified) (1 diff)
• Source/WebCore/Modules/webaudio/MediaStreamAudioSource.cpp (modified) (4 diffs)
• Source/WebCore/Modules/webaudio/MediaStreamAudioSource.h (modified) (1 diff)
• Source/WebCore/Modules/webdatabase/Database.cpp (modified) (4 diffs)
• Source/WebCore/Modules/webdatabase/DatabaseBackend.h (modified) (1 diff)
• Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp (modified) (2 diffs)
• Source/WebCore/Modules/webdatabase/DatabaseTask.h (modified) (1 diff)
• Source/WebCore/Modules/webdatabase/DatabaseThread.cpp (modified) (2 diffs)
• Source/WebCore/Modules/webdatabase/DatabaseThread.h (modified) (1 diff)
• Source/WebCore/Modules/webdatabase/DatabaseTracker.cpp (modified) (30 diffs)
• Source/WebCore/Modules/webdatabase/DatabaseTracker.h (modified) (2 diffs)
• Source/WebCore/Modules/webdatabase/OriginLock.h (modified) (1 diff)
• Source/WebCore/Modules/webdatabase/SQLCallbackWrapper.h (modified) (3 diffs)
• Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp (modified) (3 diffs)
• Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h (modified) (1 diff)
• Source/WebCore/bindings/js/WorkerScriptController.cpp (modified) (2 diffs)
• Source/WebCore/bindings/js/WorkerScriptController.h (modified) (1 diff)
• Source/WebCore/dom/default/PlatformMessagePortChannel.cpp (modified) (8 diffs)
• Source/WebCore/dom/default/PlatformMessagePortChannel.h (modified) (1 diff)
• Source/WebCore/loader/icon/IconDatabase.cpp (modified) (43 diffs)
• Source/WebCore/loader/icon/IconDatabase.h (modified) (4 diffs)
• Source/WebCore/page/scrolling/ScrollingTree.cpp (modified) (21 diffs)
• Source/WebCore/page/scrolling/ScrollingTree.h (modified) (1 diff)
• Source/WebCore/platform/MemoryPressureHandler.h (modified) (1 diff)
• Source/WebCore/platform/audio/HRTFDatabaseLoader.cpp (modified) (2 diffs)
• Source/WebCore/platform/audio/HRTFDatabaseLoader.h (modified) (1 diff)
• Source/WebCore/platform/cocoa/MemoryPressureHandlerCocoa.mm (modified) (4 diffs)
• Source/WebCore/platform/graphics/DisplayRefreshMonitor.cpp (modified) (2 diffs)
• Source/WebCore/platform/graphics/DisplayRefreshMonitor.h (modified) (2 diffs)
• Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp (modified) (3 diffs)
• Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h (modified) (1 diff)
• Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp (modified) (13 diffs)
• Source/WebCore/platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.cpp (modified) (2 diffs)
• Source/WebCore/platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.h (modified) (1 diff)
• Source/WebCore/platform/graphics/gstreamer/TrackPrivateBaseGStreamer.cpp (modified) (2 diffs)
• Source/WebCore/platform/graphics/gstreamer/TrackPrivateBaseGStreamer.h (modified) (1 diff)
• Source/WebCore/platform/graphics/mac/DisplayRefreshMonitorMac.cpp (modified) (2 diffs)
• Source/WebCore/platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp (modified) (5 diffs)
• Source/WebCore/platform/graphics/win/MediaPlayerPrivateMediaFoundation.h (modified) (2 diffs)
• Source/WebCore/platform/ios/LegacyTileCache.h (modified) (1 diff)
• Source/WebCore/platform/ios/LegacyTileCache.mm (modified) (18 diffs)
• Source/WebCore/platform/ios/LegacyTileLayerPool.h (modified) (1 diff)
• Source/WebCore/platform/ios/LegacyTileLayerPool.mm (modified) (5 diffs)
• Source/WebCore/platform/network/curl/CurlDownload.cpp (modified) (16 diffs)
• Source/WebCore/platform/network/curl/CurlDownload.h (modified) (2 diffs)
• Source/WebCore/platform/network/curl/ResourceHandleManager.cpp (modified) (3 diffs)
• Source/WebCore/platform/network/ios/QuickLook.mm (modified) (5 diffs)
• Source/WebCore/platform/sql/SQLiteDatabase.cpp (modified) (9 diffs)
• Source/WebCore/platform/sql/SQLiteDatabase.h (modified) (2 diffs)
• Source/WebCore/platform/sql/SQLiteStatement.cpp (modified) (2 diffs)
• Source/WebCore/workers/WorkerThread.cpp (modified) (3 diffs)
• Source/WebCore/workers/WorkerThread.h (modified) (1 diff)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/Storage/StorageAreaSync.cpp (modified) (5 diffs)
• Source/WebKit/Storage/StorageAreaSync.h (modified) (2 diffs)
• Source/WebKit/Storage/StorageTracker.cpp (modified) (23 diffs)
• Source/WebKit/Storage/StorageTracker.h (modified) (1 diff)
• Source/WebKit/ios/ChangeLog (modified) (1 diff)
• Source/WebKit/ios/WebCoreSupport/WebFixedPositionContent.mm (modified) (6 diffs)
• Source/WebKit/mac/ChangeLog (modified) (1 diff)
• Source/WebKit/mac/Storage/WebDatabaseManager.mm (modified) (3 diffs)
• Source/WebKit/mac/WebView/WebView.mm (modified) (4 diffs)
• Source/WebKit/mac/WebView/WebViewData.h (modified) (1 diff)
• Source/WebKit/win/ChangeLog (modified) (1 diff)
• Source/WebKit/win/Plugins/PluginMainThreadScheduler.cpp (modified) (4 diffs)
• Source/WebKit/win/Plugins/PluginMainThreadScheduler.h (modified) (1 diff)
• Source/WebKit/win/WebIconDatabase.cpp (modified) (3 diffs)
• Source/WebKit/win/WebLocalizableStrings.cpp (modified) (4 diffs)
• Source/WebKit2/ChangeLog (modified) (1 diff)
• Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp (modified) (2 diffs)
• Source/WebKit2/DatabaseProcess/DatabaseProcess.h (modified) (1 diff)
• Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp (modified) (5 diffs)
• Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h (modified) (1 diff)
• Source/WebKit2/Platform/IPC/Connection.cpp (modified) (7 diffs)
• Source/WebKit2/Platform/IPC/Connection.h (modified) (1 diff)
• Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp (modified) (1 diff)
• Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h (modified) (1 diff)
• Source/WebKit2/Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.cpp (modified) (4 diffs)
• Source/WebKit2/Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.h (modified) (1 diff)
• Source/WebKit2/Shared/Network/CustomProtocols/Cocoa/CustomProtocolManagerCocoa.mm (modified) (6 diffs)
• Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.h (modified) (1 diff)
• Source/WebKit2/Shared/linux/SeccompFilters/SeccompBroker.cpp (modified) (1 diff)
• Source/WebKit2/WebProcess/Plugins/PluginProcessConnectionManager.cpp (modified) (3 diffs)
• Source/WebKit2/WebProcess/Plugins/PluginProcessConnectionManager.h (modified) (1 diff)
• Source/WebKit2/WebProcess/WebPage/EventDispatcher.cpp (modified) (3 diffs)
• Source/WebKit2/WebProcess/WebPage/EventDispatcher.h (modified) (1 diff)
• Source/WebKit2/WebProcess/soup/WebKitSoupRequestInputStream.cpp (modified) (3 diffs)
• Tools/ChangeLog (modified) (1 diff)
• Tools/DumpRenderTree/JavaScriptThreading.cpp (modified) (12 diffs)
• Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp (modified) (10 diffs)
• Tools/TestWebKitAPI/Tests/WTF/glib/WorkQueueGLib.cpp (modified) (3 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        * bytecode/SamplingTool.cpp:
+        (JSC::SamplingTool::doRun):
+        (JSC::SamplingTool::notifyOfScope):
+        * bytecode/SamplingTool.h:
+        * dfg/DFGThreadData.h:
+        * dfg/DFGWorklist.cpp:
+        (JSC::DFG::Worklist::~Worklist):
+        (JSC::DFG::Worklist::isActiveForVM):
+        (JSC::DFG::Worklist::enqueue):
+        (JSC::DFG::Worklist::compilationState):
+        (JSC::DFG::Worklist::waitUntilAllPlansForVMAreReady):
+        (JSC::DFG::Worklist::removeAllReadyPlansForVM):
+        (JSC::DFG::Worklist::completeAllReadyPlansForVM):
+        (JSC::DFG::Worklist::visitWeakReferences):
+        (JSC::DFG::Worklist::removeDeadPlans):
+        (JSC::DFG::Worklist::queueLength):
+        (JSC::DFG::Worklist::dump):
+        (JSC::DFG::Worklist::runThread):
+        * dfg/DFGWorklist.h:
+        * disassembler/Disassembler.cpp:
+        * heap/CopiedSpace.cpp:
+        (JSC::CopiedSpace::doneFillingBlock):
+        (JSC::CopiedSpace::doneCopying):
+        * heap/CopiedSpace.h:
+        * heap/CopiedSpaceInlines.h:
+        (JSC::CopiedSpace::recycleBorrowedBlock):
+        (JSC::CopiedSpace::allocateBlockForCopyingPhase):
+        * heap/HeapTimer.h:
+        * heap/MachineStackMarker.cpp:
+        (JSC::ActiveMachineThreadsManager::Locker::Locker):
+        (JSC::ActiveMachineThreadsManager::add):
+        (JSC::ActiveMachineThreadsManager::remove):
+        (JSC::ActiveMachineThreadsManager::ActiveMachineThreadsManager):
+        (JSC::MachineThreads::~MachineThreads):
+        (JSC::MachineThreads::addCurrentThread):
+        (JSC::MachineThreads::removeThreadIfFound):
+        (JSC::MachineThreads::tryCopyOtherThreadStack):
+        (JSC::MachineThreads::tryCopyOtherThreadStacks):
+        (JSC::MachineThreads::gatherConservativeRoots):
+        * heap/MachineStackMarker.h:
+        * interpreter/JSStack.cpp:
+        (JSC::stackStatisticsMutex):
+        (JSC::JSStack::addToCommittedByteCount):
+        (JSC::JSStack::committedByteCount):
+        * jit/JITThunks.h:
+        * profiler/ProfilerDatabase.h:
+
 2015-08-05  Saam barati  <[email protected]>
 

trunk/Source/JavaScriptCore/bytecode/SamplingTool.cpp

@@ -286 +286 @@
 #if ENABLE(CODEBLOCK_SAMPLING)
     if (CodeBlock* codeBlock = sample.codeBlock()) {
-        MutexLocker locker(m_scriptSampleMapMutex);
+        DeprecatedMutexLocker locker(m_scriptSampleMapMutex);
         ScriptSampleRecord* record = m_scopeSampleMap->get(codeBlock->ownerExecutable());
         ASSERT(record);
@@ -302 +302 @@
 {
 #if ENABLE(CODEBLOCK_SAMPLING)
-    MutexLocker locker(m_scriptSampleMapMutex);
+    DeprecatedMutexLocker locker(m_scriptSampleMapMutex);
     m_scopeSampleMap->set(script, adoptPtr(new ScriptSampleRecord(vm, script)));
 #else

trunk/Source/JavaScriptCore/bytecode/SamplingTool.h

@@ -339 +339 @@
         
 #if ENABLE(CODEBLOCK_SAMPLING)
-        Mutex m_scriptSampleMapMutex;
+        DeprecatedMutex m_scriptSampleMapMutex;
         std::unique_ptr<ScriptSampleRecordMap> m_scopeSampleMap;
 #endif

trunk/Source/JavaScriptCore/dfg/DFGThreadData.h

@@ -49 +49 @@
     Worklist* m_worklist;
     ThreadIdentifier m_identifier;
-    Mutex m_rightToRun;
+    DeprecatedMutex m_rightToRun;
     Safepoint* m_safepoint;
 };

trunk/Source/JavaScriptCore/dfg/DFGWorklist.cpp

@@ -47 +47 @@
 {
     {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         for (unsigned i = m_threads.size(); i--;)
             m_queue.append(nullptr); // Use null plan to indicate that we want the thread to terminate.
@@ -78 +78 @@
 bool Worklist::isActiveForVM(VM& vm) const
 {
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     PlanMap::const_iterator end = m_plans.end();
     for (PlanMap::const_iterator iter = m_plans.begin(); iter != end; ++iter) {
@@ -90 +90 @@
 {
     RefPtr<Plan> plan = passedPlan;
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     if (Options::verboseCompilationQueue()) {
         dump(locker, WTF::dataFile());
@@ -103 +103 @@
 Worklist::State Worklist::compilationState(CompilationKey key)
 {
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     PlanMap::iterator iter = m_plans.find(key);
     if (iter == m_plans.end())
@@ -119 +119 @@
     // be adding plans, our VM will not be.
     
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     
     if (Options::verboseCompilationQueue()) {
@@ -148 +148 @@
 {
     DeferGC deferGC(vm.heap);
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     for (size_t i = 0; i < m_readyPlans.size(); ++i) {
         RefPtr<Plan> plan = m_readyPlans[i];
@@ -193 +193 @@
     
     if (!!requestedKey && resultingState == NotKnown) {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         if (m_plans.contains(requestedKey))
             resultingState = Compiling;
@@ -226 +226 @@
     VM* vm = visitor.heap()->vm();
     {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         for (PlanMap::iterator iter = m_plans.begin(); iter != m_plans.end(); ++iter) {
             Plan* plan = iter->value.get();
@@ -249 +249 @@
 {
     {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         HashSet<CompilationKey> deadPlanKeys;
         for (PlanMap::iterator iter = m_plans.begin(); iter != m_plans.end(); ++iter) {
@@ -296 +296 @@
 size_t Worklist::queueLength()
 {
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     return m_queue.size();
 }
@@ -302 +302 @@
 void Worklist::dump(PrintStream& out) const
 {
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     dump(locker, out);
 }
 
-void Worklist::dump(const MutexLocker&, PrintStream& out) const
+void Worklist::dump(const DeprecatedMutexLocker&, PrintStream& out) const
 {
     out.print(
@@ -326 +326 @@
         RefPtr<Plan> plan;
         {
-            MutexLocker locker(m_lock);
+            DeprecatedMutexLocker locker(m_lock);
             while (m_queue.isEmpty())
                 m_planEnqueued.wait(m_lock);
@@ -342 +342 @@
         
         {
-            MutexLocker locker(data->m_rightToRun);
+            DeprecatedMutexLocker locker(data->m_rightToRun);
             {
-                MutexLocker locker(m_lock);
+                DeprecatedMutexLocker locker(m_lock);
                 if (plan->stage == Plan::Cancelled) {
                     m_numberOfActiveThreads--;
@@ -360 +360 @@
             
             {
-                MutexLocker locker(m_lock);
+                DeprecatedMutexLocker locker(m_lock);
                 if (plan->stage == Plan::Cancelled) {
                     m_numberOfActiveThreads--;
@@ -371 +371 @@
 
         {
-            MutexLocker locker(m_lock);
+            DeprecatedMutexLocker locker(m_lock);
             
             // We could have been cancelled between releasing rightToRun and acquiring m_lock.

trunk/Source/JavaScriptCore/dfg/DFGWorklist.h

@@ -86 +86 @@
     void removeAllReadyPlansForVM(VM&, Vector<RefPtr<Plan>, 8>&);
 
-    void dump(const MutexLocker&, PrintStream&) const;
+    void dump(const DeprecatedMutexLocker&, PrintStream&) const;
     
     CString m_threadName;
@@ -104 +104 @@
     Vector<RefPtr<Plan>, 16> m_readyPlans;
 
-    Mutex m_suspensionLock;
+    DeprecatedMutex m_suspensionLock;
     
-    mutable Mutex m_lock;
+    mutable DeprecatedMutex m_lock;
     ThreadCondition m_planEnqueued;
     ThreadCondition m_planCompiled;

trunk/Source/JavaScriptCore/disassembler/Disassembler.cpp

@@ -79 +79 @@
     void enqueue(std::unique_ptr<DisassemblyTask> task)
     {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         m_queue.append(WTF::move(task));
         m_condition.broadcast();
@@ -86 +86 @@
     void waitUntilEmpty()
     {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         while (!m_queue.isEmpty() || m_working)
             m_condition.wait(m_lock);
@@ -97 +97 @@
             std::unique_ptr<DisassemblyTask> task;
             {
-                MutexLocker locker(m_lock);
+                DeprecatedMutexLocker locker(m_lock);
                 m_working = false;
                 m_condition.broadcast();
@@ -113 +113 @@
     }
     
-    Mutex m_lock;
+    DeprecatedMutex m_lock;
     ThreadCondition m_condition;
     Deque<std::unique_ptr<DisassemblyTask>> m_queue;

trunk/Source/JavaScriptCore/heap/CopiedSpace.cpp

@@ -199 +199 @@
 
     {
-        MutexLocker locker(m_loanedBlocksLock);
+        DeprecatedMutexLocker locker(m_loanedBlocksLock);
         ASSERT(m_numberOfLoanedBlocks > 0);
         ASSERT(m_inCopyingPhase);
@@ -232 +232 @@
 {
     {
-        MutexLocker locker(m_loanedBlocksLock);
+        DeprecatedMutexLocker locker(m_loanedBlocksLock);
         while (m_numberOfLoanedBlocks > 0)
             m_loanedBlocksCondition.wait(m_loanedBlocksLock);

trunk/Source/JavaScriptCore/heap/CopiedSpace.h

@@ -139 +139 @@
     bool m_shouldDoCopyPhase;
 
-    Mutex m_loanedBlocksLock; 
+    DeprecatedMutex m_loanedBlocksLock; 
     ThreadCondition m_loanedBlocksCondition;
     size_t m_numberOfLoanedBlocks;

trunk/Source/JavaScriptCore/heap/CopiedSpaceInlines.h

@@ -114 +114 @@
 
     {
-        MutexLocker locker(m_loanedBlocksLock);
+        DeprecatedMutexLocker locker(m_loanedBlocksLock);
         ASSERT(m_numberOfLoanedBlocks > 0);
         ASSERT(m_inCopyingPhase);
@@ -129 +129 @@
 
     {
-        MutexLocker locker(m_loanedBlocksLock);
+        DeprecatedMutexLocker locker(m_loanedBlocksLock);
         m_numberOfLoanedBlocks++;
     }

trunk/Source/JavaScriptCore/heap/HeapTimer.h

@@ -60 +60 @@
     CFRunLoopTimerContext m_context;
 
-    Mutex m_shutdownMutex;
+    DeprecatedMutex m_shutdownMutex;
 #elif PLATFORM(EFL)
     static bool timerEvent(void*);

trunk/Source/JavaScriptCore/heap/MachineStackMarker.cpp

@@ -104 +104 @@
 
     private:
-        MutexLocker m_locker;
+        DeprecatedMutexLocker m_locker;
     };
 
     void add(MachineThreads* machineThreads)
     {
-        MutexLocker managerLock(m_lock);
+        DeprecatedMutexLocker managerLock(m_lock);
         m_set.add(machineThreads);
     }
@@ -115 +115 @@
     void remove(MachineThreads* machineThreads)
     {
-        MutexLocker managerLock(m_lock);
+        DeprecatedMutexLocker managerLock(m_lock);
         auto recordedMachineThreads = m_set.take(machineThreads);
         RELEASE_ASSERT(recordedMachineThreads = machineThreads);
@@ -130 +130 @@
     ActiveMachineThreadsManager() { }
     
-    Mutex m_lock;
+    DeprecatedMutex m_lock;
     MachineThreadsSet m_set;
 
@@ -264 +264 @@
     threadSpecificKeyDelete(m_threadSpecific);
 
-    MutexLocker registeredThreadsLock(m_registeredThreadsMutex);
+    DeprecatedMutexLocker registeredThreadsLock(m_registeredThreadsMutex);
     for (Thread* t = m_registeredThreads; t;) {
         Thread* next = t->next;
@@ -295 +295 @@
     Thread* thread = Thread::createForCurrentThread();
 
-    MutexLocker lock(m_registeredThreadsMutex);
+    DeprecatedMutexLocker lock(m_registeredThreadsMutex);
 
     thread->next = m_registeredThreads;
@@ -319 +319 @@
 void MachineThreads::removeThreadIfFound(PlatformThread platformThread)
 {
-    MutexLocker lock(m_registeredThreadsMutex);
+    DeprecatedMutexLocker lock(m_registeredThreadsMutex);
     Thread* t = m_registeredThreads;
     if (*t == platformThread) {
@@ -565 +565 @@
 }
 
-bool MachineThreads::tryCopyOtherThreadStacks(MutexLocker&, void* buffer, size_t capacity, size_t* size)
+bool MachineThreads::tryCopyOtherThreadStacks(DeprecatedMutexLocker&, void* buffer, size_t capacity, size_t* size)
 {
     // Prevent two VMs from suspending each other's threads at the same time,
@@ -659 +659 @@
     size_t capacity = 0;
     void* buffer = nullptr;
-    MutexLocker lock(m_registeredThreadsMutex);
+    DeprecatedMutexLocker lock(m_registeredThreadsMutex);
     while (!tryCopyOtherThreadStacks(lock, buffer, capacity, &size))
         growBuffer(size, &buffer, &capacity);

trunk/Source/JavaScriptCore/heap/MachineStackMarker.h

@@ -53 +53 @@
 
         void tryCopyOtherThreadStack(Thread*, void*, size_t capacity, size_t*);
-        bool tryCopyOtherThreadStacks(MutexLocker&, void*, size_t capacity, size_t*);
+        bool tryCopyOtherThreadStacks(DeprecatedMutexLocker&, void*, size_t capacity, size_t*);
 
         static void removeThread(void*);
@@ -60 +60 @@
         void removeThreadIfFound(PlatformThread);
 
-        Mutex m_registeredThreadsMutex;
+        DeprecatedMutex m_registeredThreadsMutex;
         Thread* m_registeredThreads;
         WTF::ThreadSpecificKey m_threadSpecific;

trunk/Source/JavaScriptCore/interpreter/JSStack.cpp

@@ -40 +40 @@
 static size_t committedBytesCount = 0;
 
-static Mutex& stackStatisticsMutex()
+static DeprecatedMutex& stackStatisticsMutex()
 {
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, staticMutex, ());
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, staticMutex, ());
     return staticMutex;
 }    
@@ -147 +147 @@
 void JSStack::addToCommittedByteCount(long byteCount)
 {
-    MutexLocker locker(stackStatisticsMutex());
+    DeprecatedMutexLocker locker(stackStatisticsMutex());
     ASSERT(static_cast<long>(committedBytesCount) + byteCount > -1);
     committedBytesCount += byteCount;
@@ -177 +177 @@
 {
 #if !ENABLE(JIT)
-    MutexLocker locker(stackStatisticsMutex());
+    DeprecatedMutexLocker locker(stackStatisticsMutex());
     return committedBytesCount;
 #else

trunk/Source/JavaScriptCore/jit/JITThunks.h

@@ -65 +65 @@
 private:
     // Main thread can hold this lock for a while, so use an adaptive mutex.
-    typedef Mutex Lock;
-    typedef MutexLocker Locker;
+    typedef DeprecatedMutex Lock;
+    typedef DeprecatedMutexLocker Locker;
 
     void finalize(Handle<Unknown>, void* context) override;

trunk/Source/JavaScriptCore/profiler/ProfilerDatabase.h

@@ -82 +82 @@
     //   power-aware backoff. An adaptive mutex will do this as a matter of course,
     //   but a spinlock won't.
-    typedef Mutex Lock;
-    typedef MutexLocker Locker;
+    typedef DeprecatedMutex Lock;
+    typedef DeprecatedMutexLocker Locker;
     
 

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        * wtf/Atomics.cpp:
+        (WTF::getSwapLock):
+        (WTF::atomicStep):
+        * wtf/MessageQueue.h:
+        (WTF::MessageQueue::infiniteTime):
+        (WTF::MessageQueue<DataType>::append):
+        (WTF::MessageQueue<DataType>::appendAndKill):
+        (WTF::MessageQueue<DataType>::appendAndCheckEmpty):
+        (WTF::MessageQueue<DataType>::prepend):
+        (WTF::MessageQueue<DataType>::removeIf):
+        (WTF::MessageQueue<DataType>::isEmpty):
+        (WTF::MessageQueue<DataType>::kill):
+        (WTF::MessageQueue<DataType>::killed):
+        * wtf/ParallelJobsGeneric.cpp:
+        (WTF::ParallelEnvironment::ThreadPrivate::execute):
+        (WTF::ParallelEnvironment::ThreadPrivate::waitForFinish):
+        (WTF::ParallelEnvironment::ThreadPrivate::workerThread):
+        * wtf/ParallelJobsGeneric.h:
+        * wtf/RunLoop.cpp:
+        (WTF::RunLoop::performWork):
+        (WTF::RunLoop::dispatch):
+        * wtf/RunLoop.h:
+        * wtf/Threading.cpp:
+        (WTF::threadEntryPoint):
+        (WTF::createThread):
+        * wtf/ThreadingPrimitives.h:
+        * wtf/ThreadingPthreads.cpp:
+        (WTF::threadMapMutex):
+        (WTF::initializeThreading):
+        (WTF::identifierByPthreadHandle):
+        (WTF::establishIdentifierForPthreadHandle):
+        (WTF::changeThreadPriority):
+        (WTF::waitForThreadCompletion):
+        (WTF::detachThread):
+        (WTF::threadDidExit):
+        (WTF::currentThread):
+        (WTF::DeprecatedMutex::DeprecatedMutex):
+        (WTF::DeprecatedMutex::~DeprecatedMutex):
+        (WTF::DeprecatedMutex::lock):
+        (WTF::DeprecatedMutex::tryLock):
+        (WTF::DeprecatedMutex::unlock):
+        (WTF::ThreadCondition::~ThreadCondition):
+        (WTF::ThreadCondition::wait):
+        (WTF::ThreadCondition::timedWait):
+        (WTF::Mutex::Mutex): Deleted.
+        (WTF::Mutex::~Mutex): Deleted.
+        (WTF::Mutex::lock): Deleted.
+        (WTF::Mutex::tryLock): Deleted.
+        (WTF::Mutex::unlock): Deleted.
+        * wtf/ThreadingWin.cpp:
+        (WTF::initializeCurrentThreadInternal):
+        (WTF::threadMapMutex):
+        (WTF::initializeThreading):
+        (WTF::storeThreadHandleByIdentifier):
+        (WTF::threadHandleForIdentifier):
+        (WTF::clearThreadHandleForIdentifier):
+        (WTF::currentThread):
+        (WTF::DeprecatedMutex::DeprecatedMutex):
+        (WTF::DeprecatedMutex::~DeprecatedMutex):
+        (WTF::DeprecatedMutex::lock):
+        (WTF::DeprecatedMutex::tryLock):
+        (WTF::DeprecatedMutex::unlock):
+        (WTF::ThreadCondition::~ThreadCondition):
+        (WTF::ThreadCondition::wait):
+        (WTF::ThreadCondition::timedWait):
+        (WTF::Mutex::Mutex): Deleted.
+        (WTF::Mutex::~Mutex): Deleted.
+        (WTF::Mutex::lock): Deleted.
+        (WTF::Mutex::tryLock): Deleted.
+        (WTF::Mutex::unlock): Deleted.
+        * wtf/WorkQueue.h:
+        * wtf/dtoa.cpp:
+        * wtf/dtoa.h:
+        * wtf/efl/DispatchQueueEfl.cpp:
+        (DispatchQueue::dispatch):
+        (DispatchQueue::performWork):
+        (DispatchQueue::performTimerWork):
+        (DispatchQueue::insertTimerWorkItem):
+        (DispatchQueue::wakeUpThread):
+        (DispatchQueue::getNextTimeOut):
+        * wtf/efl/DispatchQueueEfl.h:
+        * wtf/efl/RunLoopEfl.cpp:
+        (WTF::RunLoop::wakeUpEvent):
+        (WTF::RunLoop::wakeUp):
+        * wtf/threads/BinarySemaphore.cpp:
+        (WTF::BinarySemaphore::signal):
+        (WTF::BinarySemaphore::wait):
+        * wtf/threads/BinarySemaphore.h:
+        * wtf/win/WorkQueueWin.cpp:
+        (WTF::WorkQueue::handleCallback):
+        (WTF::WorkQueue::platformInvalidate):
+        (WTF::WorkQueue::dispatch):
+        (WTF::WorkQueue::timerCallback):
+        (WTF::WorkQueue::dispatchAfter):
+
 2015-08-04  Alex Christensen  <[email protected]>
 

trunk/Source/WTF/wtf/Atomics.cpp

@@ -73 +73 @@
 
 static const size_t kSwapLockCount = 32;
-static Mutex s_swapLocks[kSwapLockCount];
+static DeprecatedMutex s_swapLocks[kSwapLockCount];
 
-static inline Mutex& getSwapLock(const volatile int64_t* addr)
+static inline DeprecatedMutex& getSwapLock(const volatile int64_t* addr)
 {
     return s_swapLocks[(reinterpret_cast<intptr_t>(addr) >> 3U) % kSwapLockCount];
@@ -82 +82 @@
 static int64_t atomicStep(int64_t volatile* addend, int64_t step)
 {
-    Mutex& mutex = getSwapLock(addend);
+    DeprecatedMutex& mutex = getSwapLock(addend);
 
     mutex.lock();

trunk/Source/WTF/wtf/MessageQueue.h

@@ -78 +78 @@
 
     private:
-        mutable Mutex m_mutex;
+        mutable DeprecatedMutex m_mutex;
         ThreadCondition m_condition;
         Deque<std::unique_ptr<DataType>> m_queue;
@@ -92 +92 @@
     inline void MessageQueue<DataType>::append(std::unique_ptr<DataType> message)
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         m_queue.append(WTF::move(message));
         m_condition.signal();
@@ -100 +100 @@
     inline void MessageQueue<DataType>::appendAndKill(std::unique_ptr<DataType> message)
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         m_queue.append(WTF::move(message));
         m_killed = true;
@@ -110 +110 @@
     inline bool MessageQueue<DataType>::appendAndCheckEmpty(std::unique_ptr<DataType> message)
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         bool wasEmpty = m_queue.isEmpty();
         m_queue.append(WTF::move(message));
@@ -120 +120 @@
     inline void MessageQueue<DataType>::prepend(std::unique_ptr<DataType> message)
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         m_queue.prepend(WTF::move(message));
         m_condition.signal();
@@ -138 +138 @@
     inline auto MessageQueue<DataType>::waitForMessageFilteredWithTimeout(MessageQueueWaitResult& result, Predicate&& predicate, double absoluteTime) -> std::unique_ptr<DataType>
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         bool timedOut = false;
 
@@ -175 +175 @@
     inline auto MessageQueue<DataType>::tryGetMessage() -> std::unique_ptr<DataType>
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         if (m_killed)
             return nullptr;
@@ -187 +187 @@
     inline auto MessageQueue<DataType>::tryGetMessageIgnoringKilled() -> std::unique_ptr<DataType>
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         if (m_queue.isEmpty())
             return nullptr;
@@ -198 +198 @@
     inline void MessageQueue<DataType>::removeIf(Predicate&& predicate)
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         while (true) {
             auto found = m_queue.findIf([&predicate](const std::unique_ptr<DataType>& ptr) -> bool {
@@ -215 +215 @@
     inline bool MessageQueue<DataType>::isEmpty()
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         if (m_killed)
             return true;
@@ -224 +224 @@
     inline void MessageQueue<DataType>::kill()
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         m_killed = true;
         m_condition.broadcast();
@@ -232 +232 @@
     inline bool MessageQueue<DataType>::killed() const
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         return m_killed;
     }

trunk/Source/WTF/wtf/ParallelJobsGeneric.cpp

@@ -106 +106 @@
 void ParallelEnvironment::ThreadPrivate::execute(ThreadFunction threadFunction, void* parameters)
 {
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
 
     m_threadFunction = threadFunction;
@@ -116 +116 @@
 void ParallelEnvironment::ThreadPrivate::waitForFinish()
 {
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
 
     while (m_running)
@@ -125 +125 @@
 {
     ThreadPrivate* sharedThread = reinterpret_cast<ThreadPrivate*>(threadData);
-    MutexLocker lock(sharedThread->m_mutex);
+    DeprecatedMutexLocker lock(sharedThread->m_mutex);
 
     while (sharedThread->m_threadID) {

trunk/Source/WTF/wtf/ParallelJobsGeneric.h

@@ -77 +77 @@
         ParallelEnvironment* m_parent;
 
-        mutable Mutex m_mutex;
+        mutable DeprecatedMutex m_mutex;
         ThreadCondition m_threadCondition;
 

trunk/Source/WTF/wtf/RunLoop.cpp

@@ -93 +93 @@
         std::function<void()> function;
         {
-            MutexLocker locker(m_functionQueueLock);
+            DeprecatedMutexLocker locker(m_functionQueueLock);
             functionsToHandle = m_functionQueue.size();
 
@@ -108 +108 @@
         std::function<void()> function;
         {
-            MutexLocker locker(m_functionQueueLock);
+            DeprecatedMutexLocker locker(m_functionQueueLock);
 
             // Even if we start off with N functions to handle and we've only handled less than N functions, the queue
@@ -126 +126 @@
 {
     {
-        MutexLocker locker(m_functionQueueLock);
+        DeprecatedMutexLocker locker(m_functionQueueLock);
         m_functionQueue.append(WTF::move(function));
     }

trunk/Source/WTF/wtf/RunLoop.h

@@ -131 +131 @@
     void performWork();
 
-    Mutex m_functionQueueLock;
+    DeprecatedMutex m_functionQueueLock;
     Deque<std::function<void ()>> m_functionQueue;
 
@@ -148 +148 @@
     int m_nestingLevel;
 #elif PLATFORM(EFL)
-    Mutex m_pipeLock;
+    DeprecatedMutex m_pipeLock;
     EflUniquePtr<Ecore_Pipe> m_pipe;
 
-    Mutex m_wakeUpEventRequestedLock;
+    DeprecatedMutex m_wakeUpEventRequestedLock;
     bool m_wakeUpEventRequested;
 

trunk/Source/WTF/wtf/Threading.cpp

@@ -36 +36 @@
     const char* name;
     std::function<void()> entryPoint;
-    Mutex creationMutex;
+    DeprecatedMutex creationMutex;
 };
 
@@ -46 +46 @@
     // establishing ThreadIdentifier.
     {
-        MutexLocker locker(context->creationMutex);
+        DeprecatedMutexLocker locker(context->creationMutex);
     }
 
@@ -71 +71 @@
 
     // Prevent the thread body from executing until we've established the thread identifier.
-    MutexLocker locker(context->creationMutex);
+    DeprecatedMutexLocker locker(context->creationMutex);
 
     return createThreadInternal(threadEntryPoint, context, name);

trunk/Source/WTF/wtf/ThreadingPrimitives.h

@@ -71 +71 @@
 #endif
     
-class Mutex {
-    WTF_MAKE_NONCOPYABLE(Mutex); WTF_MAKE_FAST_ALLOCATED;
+class DeprecatedMutex {
+    WTF_MAKE_NONCOPYABLE(DeprecatedMutex); WTF_MAKE_FAST_ALLOCATED;
 public:
-    WTF_EXPORT_PRIVATE Mutex();
-    WTF_EXPORT_PRIVATE ~Mutex();
+    WTF_EXPORT_PRIVATE DeprecatedMutex();
+    WTF_EXPORT_PRIVATE ~DeprecatedMutex();
 
     WTF_EXPORT_PRIVATE void lock();
@@ -87 +87 @@
 };
 
-typedef Locker<Mutex> MutexLocker;
+typedef Locker<DeprecatedMutex> DeprecatedMutexLocker;
 
 class ThreadCondition {
@@ -95 +95 @@
     WTF_EXPORT_PRIVATE ~ThreadCondition();
     
-    WTF_EXPORT_PRIVATE void wait(Mutex& mutex);
+    WTF_EXPORT_PRIVATE void wait(DeprecatedMutex&);
     // Returns true if the condition was signaled before absoluteTime, false if the absoluteTime was reached or is in the past.
     // The absoluteTime is in seconds, starting on January 1, 1970. The time is assumed to use the same time zone as WTF::currentTime().
-    WTF_EXPORT_PRIVATE bool timedWait(Mutex&, double absoluteTime);
+    WTF_EXPORT_PRIVATE bool timedWait(DeprecatedMutex&, double absoluteTime);
     WTF_EXPORT_PRIVATE void signal();
     WTF_EXPORT_PRIVATE void broadcast();
@@ -114 +114 @@
 } // namespace WTF
 
-using WTF::Mutex;
-using WTF::MutexLocker;
+using WTF::DeprecatedMutex;
+using WTF::DeprecatedMutexLocker;
 using WTF::ThreadCondition;
 

trunk/Source/WTF/wtf/ThreadingPthreads.cpp

@@ -103 +103 @@
 void threadWasJoined(ThreadIdentifier);
 
-static Mutex& threadMapMutex()
-{
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, mutex, ());
+static DeprecatedMutex& threadMapMutex()
+{
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, mutex, ());
     return mutex;
 }
@@ -127 +127 @@
     StackStats::initialize();
     wtfThreadData();
-    s_dtoaP5Mutex = new Mutex;
+    s_dtoaP5Mutex = new DeprecatedMutex;
     initializeDates();
 }
@@ -139 +139 @@
 static ThreadIdentifier identifierByPthreadHandle(const pthread_t& pthreadHandle)
 {
-    MutexLocker locker(threadMapMutex());
+    DeprecatedMutexLocker locker(threadMapMutex());
 
     ThreadMap::iterator i = threadMap().begin();
@@ -153 +153 @@
 {
     ASSERT(!identifierByPthreadHandle(pthreadHandle));
-    MutexLocker locker(threadMapMutex());
+    DeprecatedMutexLocker locker(threadMapMutex());
     static ThreadIdentifier identifierCount = 1;
     threadMap().add(identifierCount, std::make_unique<PthreadState>(pthreadHandle));
@@ -220 +220 @@
 
     {
-        MutexLocker locker(threadMapMutex());
+        DeprecatedMutexLocker locker(threadMapMutex());
         pthreadHandle = pthreadHandleForIdentifierWithLockAlreadyHeld(threadID);
         ASSERT(pthreadHandle);
@@ -243 +243 @@
     {
         // We don't want to lock across the call to join, since that can block our thread and cause deadlock.
-        MutexLocker locker(threadMapMutex());
+        DeprecatedMutexLocker locker(threadMapMutex());
         pthreadHandle = pthreadHandleForIdentifierWithLockAlreadyHeld(threadID);
         ASSERT(pthreadHandle);
@@ -255 +255 @@
         LOG_ERROR("ThreadIdentifier %u was unable to be joined.\n", threadID);
 
-    MutexLocker locker(threadMapMutex());
+    DeprecatedMutexLocker locker(threadMapMutex());
     PthreadState* state = threadMap().get(threadID);
     ASSERT(state);
@@ -274 +274 @@
     ASSERT(threadID);
 
-    MutexLocker locker(threadMapMutex());
+    DeprecatedMutexLocker locker(threadMapMutex());
     pthread_t pthreadHandle = pthreadHandleForIdentifierWithLockAlreadyHeld(threadID);
     ASSERT(pthreadHandle);
@@ -292 +292 @@
 void threadDidExit(ThreadIdentifier threadID)
 {
-    MutexLocker locker(threadMapMutex());
+    DeprecatedMutexLocker locker(threadMapMutex());
     PthreadState* state = threadMap().get(threadID);
     ASSERT(state);
@@ -314 +314 @@
 }
 
-Mutex::Mutex()
+DeprecatedMutex::DeprecatedMutex()
 {
     pthread_mutexattr_t attr;
@@ -326 +326 @@
 }
 
-Mutex::~Mutex()
+DeprecatedMutex::~DeprecatedMutex()
 {
     int result = pthread_mutex_destroy(&m_mutex);
@@ -332 +332 @@
 }
 
-void Mutex::lock()
+void DeprecatedMutex::lock()
 {
     int result = pthread_mutex_lock(&m_mutex);
@@ -338 +338 @@
 }
 
-bool Mutex::tryLock()
+bool DeprecatedMutex::tryLock()
 {
     int result = pthread_mutex_trylock(&m_mutex);
@@ -351 +351 @@
 }
 
-void Mutex::unlock()
+void DeprecatedMutex::unlock()
 {
     int result = pthread_mutex_unlock(&m_mutex);
@@ -367 +367 @@
 }
     
-void ThreadCondition::wait(Mutex& mutex)
+void ThreadCondition::wait(DeprecatedMutex& mutex)
 {
     int result = pthread_cond_wait(&m_condition, &mutex.impl());
@@ -373 +373 @@
 }
 
-bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
+bool ThreadCondition::timedWait(DeprecatedMutex& mutex, double absoluteTime)
 {
     if (absoluteTime < currentTime())

trunk/Source/WTF/wtf/ThreadingWin.cpp

@@ -144 +144 @@
 }
 
-static Mutex& threadMapMutex()
-{
-    static Mutex mutex;
+static DeprecatedMutex& threadMapMutex()
+{
+    static DeprecatedMutex mutex;
     return mutex;
 }
@@ -166 +166 @@
     initializeRandomNumberGenerator();
     wtfThreadData();
-    s_dtoaP5Mutex = new Mutex;
+    s_dtoaP5Mutex = new DeprecatedMutex;
     initializeDates();
 }
@@ -178 +178 @@
 static void storeThreadHandleByIdentifier(DWORD threadID, HANDLE threadHandle)
 {
-    MutexLocker locker(threadMapMutex());
+    DeprecatedMutexLocker locker(threadMapMutex());
     ASSERT(!threadMap().contains(threadID));
     threadMap().add(threadID, threadHandle);
@@ -185 +185 @@
 static HANDLE threadHandleForIdentifier(ThreadIdentifier id)
 {
-    MutexLocker locker(threadMapMutex());
+    DeprecatedMutexLocker locker(threadMapMutex());
     return threadMap().get(id);
 }
@@ -191 +191 @@
 static void clearThreadHandleForIdentifier(ThreadIdentifier id)
 {
-    MutexLocker locker(threadMapMutex());
+    DeprecatedMutexLocker locker(threadMapMutex());
     ASSERT(threadMap().contains(id));
     threadMap().remove(id);
@@ -278 +278 @@
 }
 
-Mutex::Mutex()
+DeprecatedMutex::DeprecatedMutex()
 {
     m_mutex.m_recursionCount = 0;
@@ -284 +284 @@
 }
 
-Mutex::~Mutex()
+DeprecatedMutex::~DeprecatedMutex()
 {
     DeleteCriticalSection(&m_mutex.m_internalMutex);
 }
 
-void Mutex::lock()
+void DeprecatedMutex::lock()
 {
     EnterCriticalSection(&m_mutex.m_internalMutex);
@@ -296 +296 @@
     
 #pragma warning(suppress: 26115)
-bool Mutex::tryLock()
+bool DeprecatedMutex::tryLock()
 {
     // This method is modeled after the behavior of pthread_mutex_trylock,
@@ -322 +322 @@
 }
 
-void Mutex::unlock()
+void DeprecatedMutex::unlock()
 {
     ASSERT(m_mutex.m_recursionCount);
@@ -459 +459 @@
 }
 
-void ThreadCondition::wait(Mutex& mutex)
+void ThreadCondition::wait(DeprecatedMutex& mutex)
 {
     m_condition.timedWait(mutex.impl(), INFINITE);
 }
 
-bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
+bool ThreadCondition::timedWait(DeprecatedMutex& mutex, double absoluteTime)
 {
     DWORD interval = absoluteTimeToWaitTimeoutInterval(absoluteTime);

trunk/Source/WTF/wtf/WorkQueue.h

@@ -114 +114 @@
     volatile LONG m_isWorkThreadRegistered;
 
-    Mutex m_workItemQueueLock;
+    DeprecatedMutex m_workItemQueueLock;
     Vector<RefPtr<WorkItemWin>> m_workItemQueue;
 
-    Mutex m_handlesLock;
+    DeprecatedMutex m_handlesLock;
     HashMap<HANDLE, RefPtr<HandleWorkItem>> m_handles;
 

trunk/Source/WTF/wtf/dtoa.cpp

@@ -55 +55 @@
 namespace WTF {
 
-Mutex* s_dtoaP5Mutex;
+DeprecatedMutex* s_dtoaP5Mutex;
 
 typedef union {

trunk/Source/WTF/wtf/dtoa.h

@@ -29 +29 @@
 namespace WTF {
 
-class Mutex;
+class DeprecatedMutex;
 
-extern Mutex* s_dtoaP5Mutex;
+extern DeprecatedMutex* s_dtoaP5Mutex;
 
 typedef char DtoaBuffer[80];

trunk/Source/WTF/wtf/efl/DispatchQueueEfl.cpp

@@ -96 +96 @@
 {
     {
-        MutexLocker locker(m_workItemsLock);
+        DeprecatedMutexLocker locker(m_workItemsLock);
         m_workItems.append(WTF::move(item));
     }
@@ -147 +147 @@
 
         {
-            MutexLocker locker(m_workItemsLock);
+            DeprecatedMutexLocker locker(m_workItemsLock);
             if (m_workItems.isEmpty())
                 return;
@@ -165 +165 @@
     {
         // Protects m_timerWorkItems.
-        MutexLocker locker(m_timerWorkItemsLock);
+        DeprecatedMutexLocker locker(m_timerWorkItemsLock);
         if (m_timerWorkItems.isEmpty())
             return;
@@ -210 +210 @@
     size_t position = 0;
 
-    MutexLocker locker(m_timerWorkItemsLock);
+    DeprecatedMutexLocker locker(m_timerWorkItemsLock);
     // The items should be ordered by expire time.
     for (; position < m_timerWorkItems.size(); ++position)
@@ -230 +230 @@
 void DispatchQueue::wakeUpThread()
 {
-    MutexLocker locker(m_writeToPipeDescriptorLock);
+    DeprecatedMutexLocker locker(m_writeToPipeDescriptorLock);
     if (write(m_writeToPipeDescriptor, &wakeUpThreadMessage, sizeof(char)) == -1)
         LOG_ERROR("Failed to wake up DispatchQueue Thread");
@@ -237 +237 @@
 timeval* DispatchQueue::getNextTimeOut() const
 {
-    MutexLocker locker(m_timerWorkItemsLock);
+    DeprecatedMutexLocker locker(m_timerWorkItemsLock);
     if (m_timerWorkItems.isEmpty())
         return 0;

trunk/Source/WTF/wtf/efl/DispatchQueueEfl.h

@@ -64 +64 @@
     int m_readFromPipeDescriptor;
     int m_writeToPipeDescriptor;
-    Mutex m_writeToPipeDescriptorLock;
+    DeprecatedMutex m_writeToPipeDescriptorLock;
 
     bool m_isThreadRunning;
@@ -72 +72 @@
 
     Vector<std::unique_ptr<WorkItem>> m_workItems;
-    Mutex m_workItemsLock;
+    DeprecatedMutex m_workItemsLock;
 
     Vector<std::unique_ptr<TimerWorkItem>> m_timerWorkItems;
-    mutable Mutex m_timerWorkItemsLock;
+    mutable DeprecatedMutex m_timerWorkItemsLock;
 };
 

trunk/Source/WTF/wtf/efl/RunLoopEfl.cpp

@@ -60 +60 @@
 
     {
-        MutexLocker locker(loop->m_wakeUpEventRequestedLock);
+        DeprecatedMutexLocker locker(loop->m_wakeUpEventRequestedLock);
         loop->m_wakeUpEventRequested = false;
     }
@@ -70 +70 @@
 {
     {
-        MutexLocker locker(m_wakeUpEventRequestedLock);
+        DeprecatedMutexLocker locker(m_wakeUpEventRequestedLock);
         if (m_wakeUpEventRequested)
             return;
@@ -77 +77 @@
 
     {
-        MutexLocker locker(m_pipeLock);
+        DeprecatedMutexLocker locker(m_pipeLock);
         ecore_pipe_write(m_pipe.get(), wakupEcorePipeMessage, ecorePipeMessageSize);
     }

trunk/Source/WTF/wtf/threads/BinarySemaphore.cpp

@@ -40 +40 @@
 void BinarySemaphore::signal()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     m_isSet = true;
@@ -48 +48 @@
 bool BinarySemaphore::wait(double absoluteTime)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     bool timedOut = false;

trunk/Source/WTF/wtf/threads/BinarySemaphore.h

@@ -45 +45 @@
     bool m_isSet;
 
-    Mutex m_mutex;
+    DeprecatedMutex m_mutex;
     ThreadCondition m_condition;
 };

trunk/Source/WTF/wtf/win/WorkQueueWin.cpp

@@ -42 +42 @@
 
     {
-        MutexLocker lock(queue->m_workItemQueueLock);
+        DeprecatedMutexLocker lock(queue->m_workItemQueueLock);
         queue->m_workItemQueue.append(item);
 
@@ -121 +121 @@
 {
 #if !ASSERT_DISABLED
-    MutexLocker lock(m_handlesLock);
+    DeprecatedMutexLocker lock(m_handlesLock);
     ASSERT(m_handles.isEmpty());
 #endif
@@ -132 +132 @@
 void WorkQueue::dispatch(std::function<void()> function)
 {
-    MutexLocker locker(m_workItemQueueLock);
+    DeprecatedMutexLocker locker(m_workItemQueueLock);
     ref();
     m_workItemQueue.append(WorkItemWin::create(function, this));
@@ -151 +151 @@
     WorkQueue* queue;
     std::function<void()> function;
-    Mutex timerMutex;
+    DeprecatedMutex timerMutex;
     HANDLE timer;
 
@@ -172 +172 @@
     timerContext->queue->dispatch(timerContext->function);
 
-    MutexLocker lock(timerContext->timerMutex);
+    DeprecatedMutexLocker lock(timerContext->timerMutex);
     ASSERT(timerContext->timer);
     ASSERT(timerContext->queue->m_timerQueue);
@@ -194 +194 @@
         // context->timer with a mutex to ensure the timer callback doesn't access it before the
         // timer handle has been stored in it.
-        MutexLocker lock(context->timerMutex);
+        DeprecatedMutexLocker lock(context->timerMutex);
 
         // Since our timer callback is quick, we can execute in the timer thread itself and avoid

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        No new tests because this is just a renaming.
+
+        * Modules/webaudio/AsyncAudioDecoder.cpp:
+        (WebCore::AsyncAudioDecoder::AsyncAudioDecoder):
+        (WebCore::AsyncAudioDecoder::runLoop):
+        * Modules/webaudio/AsyncAudioDecoder.h:
+        * Modules/webaudio/AudioContext.h:
+        * Modules/webaudio/MediaStreamAudioSource.cpp:
+        (WebCore::MediaStreamAudioSource::addAudioConsumer):
+        (WebCore::MediaStreamAudioSource::removeAudioConsumer):
+        (WebCore::MediaStreamAudioSource::setAudioFormat):
+        (WebCore::MediaStreamAudioSource::consumeAudio):
+        * Modules/webaudio/MediaStreamAudioSource.h:
+        * Modules/webdatabase/Database.cpp:
+        (WebCore::Database::close):
+        (WebCore::Database::runTransaction):
+        (WebCore::Database::inProgressTransactionCompleted):
+        (WebCore::Database::hasPendingTransaction):
+        * Modules/webdatabase/DatabaseBackend.h:
+        * Modules/webdatabase/DatabaseBackendBase.cpp:
+        (WebCore::DatabaseBackendBase::performOpenAndVerify):
+        (WebCore::DatabaseBackendBase::isInterrupted):
+        * Modules/webdatabase/DatabaseContext.cpp:
+        (WebCore::DatabaseContext::databaseThread):
+        (WebCore::DatabaseContext::setPaused):
+        * Modules/webdatabase/DatabaseContext.h:
+        * Modules/webdatabase/DatabaseTask.h:
+        * Modules/webdatabase/DatabaseThread.cpp:
+        (WebCore::DatabaseThread::start):
+        (WebCore::DatabaseThread::setPaused):
+        (WebCore::DatabaseThread::handlePausedQueue):
+        (WebCore::DatabaseThread::databaseThread):
+        * Modules/webdatabase/DatabaseThread.h:
+        * Modules/webdatabase/DatabaseTracker.cpp:
+        (WebCore::DatabaseTracker::setDatabaseDirectoryPath):
+        (WebCore::DatabaseTracker::canEstablishDatabase):
+        (WebCore::DatabaseTracker::retryCanEstablishDatabase):
+        (WebCore::DatabaseTracker::hasEntryForOrigin):
+        (WebCore::DatabaseTracker::getMaxSizeForDatabase):
+        (WebCore::DatabaseTracker::closeAllDatabases):
+        (WebCore::DatabaseTracker::interruptAllDatabasesForContext):
+        (WebCore::DatabaseTracker::fullPathForDatabase):
+        (WebCore::DatabaseTracker::origins):
+        (WebCore::DatabaseTracker::databaseNamesForOrigin):
+        (WebCore::DatabaseTracker::detailsForNameAndOrigin):
+        (WebCore::DatabaseTracker::setDatabaseDetails):
+        (WebCore::DatabaseTracker::doneCreatingDatabase):
+        (WebCore::DatabaseTracker::addOpenDatabase):
+        (WebCore::DatabaseTracker::removeOpenDatabase):
+        (WebCore::DatabaseTracker::getOpenDatabases):
+        (WebCore::DatabaseTracker::originLockFor):
+        (WebCore::DatabaseTracker::quotaForOrigin):
+        (WebCore::DatabaseTracker::setQuota):
+        (WebCore::DatabaseTracker::deleteOrigin):
+        (WebCore::DatabaseTracker::deleteDatabase):
+        (WebCore::DatabaseTracker::deleteDatabaseFile):
+        (WebCore::DatabaseTracker::removeDeletedOpenedDatabases):
+        (WebCore::DatabaseTracker::deleteDatabaseFileIfEmpty):
+        (WebCore::DatabaseTracker::openDatabaseMutex):
+        (WebCore::DatabaseTracker::setDatabasesPaused):
+        (WebCore::DatabaseTracker::setClient):
+        (WebCore::notificationMutex):
+        (WebCore::DatabaseTracker::scheduleNotifyDatabaseChanged):
+        (WebCore::DatabaseTracker::notifyDatabasesChanged):
+        * Modules/webdatabase/DatabaseTracker.h:
+        * Modules/webdatabase/OriginLock.h:
+        * Modules/webdatabase/SQLCallbackWrapper.h:
+        (WebCore::SQLCallbackWrapper::clear):
+        (WebCore::SQLCallbackWrapper::unwrap):
+        (WebCore::SQLCallbackWrapper::hasCallback):
+        * Modules/webdatabase/SQLTransactionBackend.cpp:
+        (WebCore::SQLTransactionBackend::doCleanup):
+        (WebCore::SQLTransactionBackend::enqueueStatementBackend):
+        (WebCore::SQLTransactionBackend::getNextStatement):
+        * Modules/webdatabase/SQLTransactionBackend.h:
+        * bindings/js/WorkerScriptController.cpp:
+        (WebCore::WorkerScriptController::scheduleExecutionTermination):
+        (WebCore::WorkerScriptController::isExecutionTerminating):
+        * bindings/js/WorkerScriptController.h:
+        * dom/default/PlatformMessagePortChannel.cpp:
+        (WebCore::MessagePortChannel::postMessageToRemote):
+        (WebCore::MessagePortChannel::tryGetMessageFromRemote):
+        (WebCore::MessagePortChannel::isConnectedTo):
+        (WebCore::MessagePortChannel::hasPendingActivity):
+        (WebCore::MessagePortChannel::locallyEntangledPort):
+        (WebCore::PlatformMessagePortChannel::setRemotePort):
+        (WebCore::PlatformMessagePortChannel::entangledChannel):
+        (WebCore::PlatformMessagePortChannel::closeInternal):
+        * dom/default/PlatformMessagePortChannel.h:
+        * loader/icon/IconDatabase.cpp:
+        (WebCore::IconDatabase::removeAllIcons):
+        (WebCore::IconDatabase::synchronousIconForPageURL):
+        (WebCore::IconDatabase::synchronousNativeIconForPageURL):
+        (WebCore::IconDatabase::synchronousIconURLForPageURL):
+        (WebCore::IconDatabase::retainIconForPageURL):
+        (WebCore::IconDatabase::performRetainIconForPageURL):
+        (WebCore::IconDatabase::releaseIconForPageURL):
+        (WebCore::IconDatabase::performReleaseIconForPageURL):
+        (WebCore::IconDatabase::setIconDataForIconURL):
+        (WebCore::IconDatabase::setIconURLForPageURL):
+        (WebCore::IconDatabase::synchronousLoadDecisionForIconURL):
+        (WebCore::IconDatabase::synchronousIconDataKnownForIconURL):
+        (WebCore::IconDatabase::pageURLMappingCount):
+        (WebCore::IconDatabase::retainedPageURLCount):
+        (WebCore::IconDatabase::iconRecordCount):
+        (WebCore::IconDatabase::iconRecordCountWithData):
+        (WebCore::IconDatabase::wakeSyncThread):
+        (WebCore::IconDatabase::isOpenBesidesMainThreadCallbacks):
+        (WebCore::IconDatabase::databasePath):
+        (WebCore::IconDatabase::getOrCreatePageURLRecord):
+        (WebCore::IconDatabase::iconDatabaseSyncThread):
+        (WebCore::IconDatabase::performOpenInitialization):
+        (WebCore::IconDatabase::performURLImport):
+        (WebCore::IconDatabase::syncThreadMainLoop):
+        (WebCore::IconDatabase::performPendingRetainAndReleaseOperations):
+        (WebCore::IconDatabase::readFromDatabase):
+        (WebCore::IconDatabase::writeToDatabase):
+        (WebCore::IconDatabase::pruneUnretainedIcons):
+        (WebCore::IconDatabase::cleanupSyncThread):
+        * loader/icon/IconDatabase.h:
+        * page/scrolling/ScrollingTree.cpp:
+        (WebCore::ScrollingTree::shouldHandleWheelEventSynchronously):
+        (WebCore::ScrollingTree::commitNewTreeState):
+        (WebCore::ScrollingTree::setMainFramePinState):
+        (WebCore::ScrollingTree::mainFrameScrollPosition):
+        (WebCore::ScrollingTree::setMainFrameScrollPosition):
+        (WebCore::ScrollingTree::isPointInNonFastScrollableRegion):
+        (WebCore::ScrollingTree::isRubberBandInProgress):
+        (WebCore::ScrollingTree::setMainFrameIsRubberBanding):
+        (WebCore::ScrollingTree::isScrollSnapInProgress):
+        (WebCore::ScrollingTree::setMainFrameIsScrollSnapping):
+        (WebCore::ScrollingTree::setCanRubberBandState):
+        (WebCore::ScrollingTree::rubberBandsAtLeft):
+        (WebCore::ScrollingTree::rubberBandsAtRight):
+        (WebCore::ScrollingTree::rubberBandsAtBottom):
+        (WebCore::ScrollingTree::rubberBandsAtTop):
+        (WebCore::ScrollingTree::setScrollPinningBehavior):
+        (WebCore::ScrollingTree::scrollPinningBehavior):
+        (WebCore::ScrollingTree::willWheelEventStartSwipeGesture):
+        (WebCore::ScrollingTree::latchedNode):
+        (WebCore::ScrollingTree::setLatchedNode):
+        (WebCore::ScrollingTree::clearLatchedNode):
+        * page/scrolling/ScrollingTree.h:
+        * platform/MemoryPressureHandler.h:
+        * platform/audio/HRTFDatabaseLoader.cpp:
+        (WebCore::HRTFDatabaseLoader::loadAsynchronously):
+        (WebCore::HRTFDatabaseLoader::waitForLoaderThreadCompletion):
+        * platform/audio/HRTFDatabaseLoader.h:
+        * platform/cocoa/MemoryPressureHandlerCocoa.mm:
+        (WebCore::MemoryPressureHandler::setReceivedMemoryPressure):
+        (WebCore::MemoryPressureHandler::clearMemoryPressure):
+        (WebCore::MemoryPressureHandler::shouldWaitForMemoryClearMessage):
+        (WebCore::MemoryPressureHandler::respondToMemoryPressureIfNeeded):
+        * platform/graphics/DisplayRefreshMonitor.cpp:
+        (WebCore::DisplayRefreshMonitor::displayDidRefresh):
+        * platform/graphics/DisplayRefreshMonitor.h:
+        (WebCore::DisplayRefreshMonitor::setMonotonicAnimationStartTime):
+        (WebCore::DisplayRefreshMonitor::mutex):
+        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp:
+        (WebCore::MediaPlayerPrivateAVFoundation::setDelayCallbacks):
+        (WebCore::MediaPlayerPrivateAVFoundation::clearMainThreadPendingFlag):
+        (WebCore::MediaPlayerPrivateAVFoundation::dispatchNotification):
+        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
+        * platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp:
+        (WebCore::AVFWrapper::callbackContext):
+        (WebCore::AVFWrapper::~AVFWrapper):
+        (WebCore::AVFWrapper::mapLock):
+        (WebCore::AVFWrapper::addToMap):
+        (WebCore::AVFWrapper::removeFromMap):
+        (WebCore::AVFWrapper::periodicTimeObserverCallback):
+        (WebCore::AVFWrapper::processNotification):
+        (WebCore::AVFWrapper::loadPlayableCompletionCallback):
+        (WebCore::AVFWrapper::loadMetadataCompletionCallback):
+        (WebCore::AVFWrapper::seekCompletedCallback):
+        (WebCore::AVFWrapper::processCue):
+        (WebCore::AVFWrapper::legibleOutputCallback):
+        (WebCore::AVFWrapper::processShouldWaitForLoadingOfResource):
+        (WebCore::AVFWrapper::resourceLoaderShouldWaitForLoadingOfRequestedResource):
+        * platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.cpp:
+        (WebCore::InbandTextTrackPrivateGStreamer::handleSample):
+        (WebCore::InbandTextTrackPrivateGStreamer::notifyTrackOfSample):
+        * platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.h:
+        * platform/graphics/gstreamer/TrackPrivateBaseGStreamer.cpp:
+        (WebCore::TrackPrivateBaseGStreamer::tagsChanged):
+        (WebCore::TrackPrivateBaseGStreamer::notifyTrackOfTagsChanged):
+        * platform/graphics/gstreamer/TrackPrivateBaseGStreamer.h:
+        * platform/graphics/mac/DisplayRefreshMonitorMac.cpp:
+        (WebCore::DisplayRefreshMonitorMac::requestRefreshCallback):
+        (WebCore::DisplayRefreshMonitorMac::displayLinkFired):
+        * platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp:
+        (WebCore::MediaPlayerPrivateMediaFoundation::addListener):
+        (WebCore::MediaPlayerPrivateMediaFoundation::removeListener):
+        (WebCore::MediaPlayerPrivateMediaFoundation::notifyDeleted):
+        (WebCore::MediaPlayerPrivateMediaFoundation::AsyncCallback::Invoke):
+        (WebCore::MediaPlayerPrivateMediaFoundation::AsyncCallback::onMediaPlayerDeleted):
+        * platform/graphics/win/MediaPlayerPrivateMediaFoundation.h:
+        * platform/ios/LegacyTileCache.h:
+        * platform/ios/LegacyTileCache.mm:
+        (WebCore::LegacyTileCache::setTilesOpaque):
+        (WebCore::LegacyTileCache::doLayoutTiles):
+        (WebCore::LegacyTileCache::setCurrentScale):
+        (WebCore::LegacyTileCache::commitScaleChange):
+        (WebCore::LegacyTileCache::layoutTilesNow):
+        (WebCore::LegacyTileCache::layoutTilesNowForRect):
+        (WebCore::LegacyTileCache::removeAllNonVisibleTiles):
+        (WebCore::LegacyTileCache::removeAllTiles):
+        (WebCore::LegacyTileCache::removeForegroundTiles):
+        (WebCore::LegacyTileCache::setContentReplacementImage):
+        (WebCore::LegacyTileCache::contentReplacementImage):
+        (WebCore::LegacyTileCache::tileCreationTimerFired):
+        (WebCore::LegacyTileCache::setNeedsDisplayInRect):
+        (WebCore::LegacyTileCache::updateTilingMode):
+        (WebCore::LegacyTileCache::setTilingMode):
+        (WebCore::LegacyTileCache::doPendingRepaints):
+        (WebCore::LegacyTileCache::flushSavedDisplayRects):
+        (WebCore::LegacyTileCache::prepareToDraw):
+        * platform/ios/LegacyTileLayerPool.h:
+        * platform/ios/LegacyTileLayerPool.mm:
+        (WebCore::LegacyTileLayerPool::addLayer):
+        (WebCore::LegacyTileLayerPool::takeLayerWithSize):
+        (WebCore::LegacyTileLayerPool::setCapacity):
+        (WebCore::LegacyTileLayerPool::prune):
+        (WebCore::LegacyTileLayerPool::drain):
+        * platform/network/curl/CurlDownload.cpp:
+        (WebCore::CurlDownloadManager::add):
+        (WebCore::CurlDownloadManager::remove):
+        (WebCore::CurlDownloadManager::getActiveDownloadCount):
+        (WebCore::CurlDownloadManager::getPendingDownloadCount):
+        (WebCore::CurlDownloadManager::stopThreadIfIdle):
+        (WebCore::CurlDownloadManager::updateHandleList):
+        (WebCore::CurlDownload::~CurlDownload):
+        (WebCore::CurlDownload::init):
+        (WebCore::CurlDownload::getTempPath):
+        (WebCore::CurlDownload::getUrl):
+        (WebCore::CurlDownload::getResponse):
+        (WebCore::CurlDownload::closeFile):
+        (WebCore::CurlDownload::didReceiveHeader):
+        (WebCore::CurlDownload::didReceiveData):
+        (WebCore::CurlDownload::didFail):
+        * platform/network/curl/CurlDownload.h:
+        * platform/network/curl/ResourceHandleManager.cpp:
+        (WebCore::cookieJarPath):
+        (WebCore::sharedResourceMutex):
+        (WebCore::curl_lock_callback):
+        (WebCore::curl_unlock_callback):
+        * platform/network/ios/QuickLook.mm:
+        (WebCore::QLDirectoryAttributes):
+        (qlPreviewConverterDictionaryMutex):
+        (WebCore::addQLPreviewConverterWithFileForURL):
+        (WebCore::qlPreviewConverterUTIForURL):
+        (WebCore::removeQLPreviewConverterForURL):
+        (WebCore::safeQLURLForDocumentURLAndResourceURL):
+        * platform/sql/SQLiteDatabase.cpp:
+        (WebCore::SQLiteDatabase::close):
+        (WebCore::SQLiteDatabase::interrupt):
+        (WebCore::SQLiteDatabase::maximumSize):
+        (WebCore::SQLiteDatabase::setMaximumSize):
+        (WebCore::SQLiteDatabase::pageSize):
+        (WebCore::SQLiteDatabase::freeSpaceSize):
+        (WebCore::SQLiteDatabase::totalSize):
+        (WebCore::SQLiteDatabase::runIncrementalVacuumCommand):
+        (WebCore::SQLiteDatabase::setAuthorizer):
+        * platform/sql/SQLiteDatabase.h:
+        (WebCore::SQLiteDatabase::databaseMutex):
+        * platform/sql/SQLiteStatement.cpp:
+        (WebCore::SQLiteStatement::prepare):
+        (WebCore::SQLiteStatement::step):
+        * workers/WorkerThread.cpp:
+        (WebCore::WorkerThread::start):
+        (WebCore::WorkerThread::workerThread):
+        (WebCore::WorkerThread::stop):
+        * workers/WorkerThread.h:
+
 2015-08-05  Matthew Daiter  <[email protected]>
 

trunk/Source/WebCore/Modules/webaudio/AsyncAudioDecoder.cpp

@@ -39 +39 @@
 {
     // Start worker thread.
-    MutexLocker lock(m_threadCreationMutex);
+    DeprecatedMutexLocker lock(m_threadCreationMutex);
     m_threadID = createThread(AsyncAudioDecoder::threadEntry, this, "Audio Decoder");
 }
@@ -77 +77 @@
     {
         // Wait for until we have m_threadID established before starting the run loop.
-        MutexLocker lock(m_threadCreationMutex);
+        DeprecatedMutexLocker lock(m_threadCreationMutex);
     }
 

trunk/Source/WebCore/Modules/webaudio/AsyncAudioDecoder.h

@@ -82 +82 @@
 
     WTF::ThreadIdentifier m_threadID;
-    Mutex m_threadCreationMutex;
+    DeprecatedMutex m_threadCreationMutex;
     MessageQueue<DecodingTask> m_queue;
 };

trunk/Source/WebCore/Modules/webaudio/AudioContext.h

@@ -381 +381 @@
 
     // Graph locking.
-    Mutex m_contextGraphMutex;
+    DeprecatedMutex m_contextGraphMutex;
     volatile ThreadIdentifier m_audioThread { 0 };
     volatile ThreadIdentifier m_graphOwnerThread; // if the lock is held then this is the thread which owns it, otherwise == UndefinedThreadIdentifier

trunk/Source/WebCore/Modules/webaudio/MediaStreamAudioSource.cpp

@@ -64 +64 @@
 void MediaStreamAudioSource::addAudioConsumer(PassRefPtr<AudioDestinationConsumer> consumer)
 {
-    MutexLocker locker(m_audioConsumersLock);
+    DeprecatedMutexLocker locker(m_audioConsumersLock);
     m_audioConsumers.append(consumer);
 }
@@ -70 +70 @@
 bool MediaStreamAudioSource::removeAudioConsumer(AudioDestinationConsumer* consumer)
 {
-    MutexLocker locker(m_audioConsumersLock);
+    DeprecatedMutexLocker locker(m_audioConsumersLock);
     size_t pos = m_audioConsumers.find(consumer);
     if (pos != notFound) {
@@ -81 +81 @@
 void MediaStreamAudioSource::setAudioFormat(size_t numberOfChannels, float sampleRate)
 {
-    MutexLocker locker(m_audioConsumersLock);
+    DeprecatedMutexLocker locker(m_audioConsumersLock);
     for (auto& consumer : m_audioConsumers)
         consumer->setFormat(numberOfChannels, sampleRate);
@@ -88 +88 @@
 void MediaStreamAudioSource::consumeAudio(AudioBus* bus, size_t numberOfFrames)
 {
-    MutexLocker locker(m_audioConsumersLock);
+    DeprecatedMutexLocker locker(m_audioConsumersLock);
     for (auto& consumer : m_audioConsumers)
         consumer->consumeAudio(bus, numberOfFrames);

trunk/Source/WebCore/Modules/webaudio/MediaStreamAudioSource.h

@@ -66 +66 @@
 
     String m_deviceId;
-    Mutex m_audioConsumersLock;
+    DeprecatedMutex m_audioConsumersLock;
     Vector<RefPtr<AudioDestinationConsumer>> m_audioConsumers;
     RealtimeMediaSourceStates m_currentStates;

trunk/Source/WebCore/Modules/webdatabase/Database.cpp

@@ -116 +116 @@
 
     {
-        MutexLocker locker(m_transactionInProgressMutex);
+        DeprecatedMutexLocker locker(m_transactionInProgressMutex);
 
         // Clean up transactions that have not been scheduled yet:
@@ -175 +175 @@
 PassRefPtr<SQLTransactionBackend> Database::runTransaction(PassRefPtr<SQLTransaction> transaction, bool readOnly, const ChangeVersionData* data)
 {
-    MutexLocker locker(m_transactionInProgressMutex);
+    DeprecatedMutexLocker locker(m_transactionInProgressMutex);
     if (!m_isTransactionQueueEnabled)
         return 0;
@@ -203 +203 @@
 void Database::inProgressTransactionCompleted()
 {
-    MutexLocker locker(m_transactionInProgressMutex);
+    DeprecatedMutexLocker locker(m_transactionInProgressMutex);
     m_transactionInProgress = false;
     scheduleTransaction();
@@ -210 +210 @@
 bool Database::hasPendingTransaction()
 {
-    MutexLocker locker(m_transactionInProgressMutex);
+    DeprecatedMutexLocker locker(m_transactionInProgressMutex);
     return m_transactionInProgress || !m_transactionQueue.isEmpty();
 }

trunk/Source/WebCore/Modules/webdatabase/DatabaseBackend.h

@@ -58 +58 @@
 
     Deque<RefPtr<SQLTransactionBackend>> m_transactionQueue;
-    Mutex m_transactionInProgressMutex;
+    DeprecatedMutex m_transactionInProgressMutex;
     bool m_transactionInProgress;
     bool m_isTransactionQueueEnabled;

trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp

@@ -323 +323 @@
     {
         // Make sure we wait till the background removal of the empty database files finished before trying to open any database.
-        MutexLocker locker(DatabaseTracker::openDatabaseMutex());
+        DeprecatedMutexLocker locker(DatabaseTracker::openDatabaseMutex());
     }
 #endif
@@ -594 +594 @@
 bool DatabaseBackendBase::isInterrupted()
 {
-    MutexLocker locker(m_sqliteDatabase.databaseMutex());
+    DeprecatedMutexLocker locker(m_sqliteDatabase.databaseMutex());
     return m_sqliteDatabase.isInterrupted();
 }

trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.h

@@ -60 +60 @@
 private:
     bool m_taskCompleted;
-    Mutex m_synchronousMutex;
+    DeprecatedMutex m_synchronousMutex;
     ThreadCondition m_synchronousCondition;
 #ifndef NDEBUG

trunk/Source/WebCore/Modules/webdatabase/DatabaseThread.cpp

@@ -62 +62 @@
 bool DatabaseThread::start()
 {
-    MutexLocker lock(m_threadCreationMutex);
+    DeprecatedMutexLocker lock(m_threadCreationMutex);
 
     if (m_threadID)
@@ -101 +101 @@
     {
         // Wait for DatabaseThread::start() to complete.
-        MutexLocker lock(m_threadCreationMutex);
+        DeprecatedMutexLocker lock(m_threadCreationMutex);
         LOG(StorageAPI, "Started DatabaseThread %p", this);
     }

trunk/Source/WebCore/Modules/webdatabase/DatabaseThread.h

@@ -73 +73 @@
     void databaseThread();
 
-    Mutex m_threadCreationMutex;
+    DeprecatedMutex m_threadCreationMutex;
     ThreadIdentifier m_threadID;
     RefPtr<DatabaseThread> m_selfRef;

trunk/Source/WebCore/Modules/webdatabase/DatabaseTracker.cpp

@@ -90 +90 @@
 void DatabaseTracker::setDatabaseDirectoryPath(const String& path)
 {
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     ASSERT(!m_database.isOpen());
     m_databaseDirectoryPath = path.isolatedCopy();
@@ -167 +167 @@
     error = DatabaseError::None;
 
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     SecurityOrigin* origin = context->securityOrigin();
 
@@ -219 +219 @@
     error = DatabaseError::None;
 
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     SecurityOrigin* origin = context->securityOrigin();
 
@@ -258 +258 @@
 bool DatabaseTracker::hasEntryForOrigin(SecurityOrigin* origin)
 {
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     return hasEntryForOriginNoLock(origin);
 }
@@ -287 +287 @@
     // The maximum size for a database is the full quota for its origin, minus the current usage within the origin,
     // plus the current usage of the given database
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     SecurityOrigin* origin = database->securityOrigin();
 
@@ -312 +312 @@
     Vector<Ref<Database>> openDatabases;
     {
-        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+        DeprecatedMutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
         if (!m_openDatabaseMap)
             return;
@@ -390 +390 @@
 String DatabaseTracker::fullPathForDatabase(SecurityOrigin* origin, const String& name, bool createIfNotExists)
 {
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     return fullPathForDatabaseNoLock(origin, name, createIfNotExists).isolatedCopy();
 }
@@ -396 +396 @@
 void DatabaseTracker::origins(Vector<RefPtr<SecurityOrigin>>& originsResult)
 {
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
 
     openTrackerDatabase(DontCreateIfDoesNotExist);
@@ -449 +449 @@
     Vector<String> temp;
     {
-        MutexLocker lockDatabase(m_databaseGuard);
+        DeprecatedMutexLocker lockDatabase(m_databaseGuard);
         if (!databaseNamesForOriginNoLock(origin, temp))
           return false;
@@ -466 +466 @@
 
     {
-        MutexLocker lockDatabase(m_databaseGuard);
+        DeprecatedMutexLocker lockDatabase(m_databaseGuard);
 
         openTrackerDatabase(DontCreateIfDoesNotExist);
@@ -501 +501 @@
     int64_t guid = 0;
 
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
 
     openTrackerDatabase(CreateIfDoesNotExist);
@@ -550 +550 @@
 void DatabaseTracker::doneCreatingDatabase(Database* database)
 {
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     doneCreatingDatabase(database->securityOrigin(), database->stringIdentifier());
 }
@@ -560 +560 @@
 
     {
-        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+        DeprecatedMutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
 
         if (!m_openDatabaseMap)
@@ -590 +590 @@
 
     {
-        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+        DeprecatedMutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
 
         if (!m_openDatabaseMap) {
@@ -630 +630 @@
 void DatabaseTracker::getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<Database>>* databases)
 {
-    MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+    DeprecatedMutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
     if (!m_openDatabaseMap)
         return;
@@ -648 +648 @@
 RefPtr<OriginLock> DatabaseTracker::originLockFor(SecurityOrigin* origin)
 {
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     String databaseIdentifier = origin->databaseIdentifier();
 
@@ -728 +728 @@
 unsigned long long DatabaseTracker::quotaForOrigin(SecurityOrigin* origin)
 {
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
     return quotaForOriginNoLock(origin);
 }
@@ -734 +734 @@
 void DatabaseTracker::setQuota(SecurityOrigin* origin, unsigned long long quota)
 {
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
 
     if (quotaForOriginNoLock(origin) == quota)
@@ -865 +865 @@
     Vector<String> databaseNames;
     {
-        MutexLocker lockDatabase(m_databaseGuard);
+        DeprecatedMutexLocker lockDatabase(m_databaseGuard);
         openTrackerDatabase(DontCreateIfDoesNotExist);
         if (!m_database.isOpen())
@@ -891 +891 @@
 
     {
-        MutexLocker lockDatabase(m_databaseGuard);
+        DeprecatedMutexLocker lockDatabase(m_databaseGuard);
         deleteOriginLockFor(origin);
         doneDeletingOrigin(origin);
@@ -1072 +1072 @@
 {
     {
-        MutexLocker lockDatabase(m_databaseGuard);
+        DeprecatedMutexLocker lockDatabase(m_databaseGuard);
         openTrackerDatabase(DontCreateIfDoesNotExist);
         if (!m_database.isOpen())
@@ -1087 +1087 @@
     if (!deleteDatabaseFile(origin, name)) {
         LOG_ERROR("Unable to delete file for database %s in origin %s", name.ascii().data(), origin->databaseIdentifier().ascii().data());
-        MutexLocker lockDatabase(m_databaseGuard);
+        DeprecatedMutexLocker lockDatabase(m_databaseGuard);
         doneDeletingDatabase(origin, name);
         return false;
     }
 
-    MutexLocker lockDatabase(m_databaseGuard);
+    DeprecatedMutexLocker lockDatabase(m_databaseGuard);
 
     SQLiteStatement statement(m_database, "DELETE FROM Databases WHERE origin=? AND name=?");
@@ -1132 +1132 @@
 #ifndef NDEBUG
     {
-        MutexLocker lockDatabase(m_databaseGuard);
+        DeprecatedMutexLocker lockDatabase(m_databaseGuard);
         ASSERT(isDeletingDatabaseOrOriginFor(origin, name));
     }
@@ -1143 +1143 @@
     // during the synchronous DatabaseThread call it triggers.
     {
-        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+        DeprecatedMutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
         if (m_openDatabaseMap) {
             // There are some open databases, lets check if they are for this origin.
@@ -1186 +1186 @@
     {
         // Acquire the lock before calling openTrackerDatabase.
-        MutexLocker lockDatabase(m_databaseGuard);
+        DeprecatedMutexLocker lockDatabase(m_databaseGuard);
         openTrackerDatabase(DontCreateIfDoesNotExist);
     }
@@ -1202 +1202 @@
     // during the synchronous DatabaseThread call it triggers.
     {
-        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+        DeprecatedMutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
         if (m_openDatabaseMap) {
             for (auto& openDatabase : *m_openDatabaseMap) {
@@ -1306 +1306 @@
 }
 
-Mutex& DatabaseTracker::openDatabaseMutex()
-{
-    static NeverDestroyed<Mutex> mutex;
+DeprecatedMutex& DatabaseTracker::openDatabaseMutex()
+{
+    static NeverDestroyed<DeprecatedMutex> mutex;
     return mutex;
 }
@@ -1331 +1331 @@
 }
 
-static Mutex& notificationMutex()
-{
-    static NeverDestroyed<Mutex> mutex;
+static DeprecatedMutex& notificationMutex()
+{
+    static NeverDestroyed<DeprecatedMutex> mutex;
     return mutex;
 }
@@ -1347 +1347 @@
 void DatabaseTracker::scheduleNotifyDatabaseChanged(SecurityOrigin* origin, const String& name)
 {
-    MutexLocker locker(notificationMutex());
+    DeprecatedMutexLocker locker(notificationMutex());
 
     notificationQueue().append(std::pair<RefPtr<SecurityOrigin>, String>(origin->isolatedCopy(), name.isolatedCopy()));
@@ -1373 +1373 @@
     NotificationQueue notifications;
     {
-        MutexLocker locker(notificationMutex());
+        DeprecatedMutexLocker locker(notificationMutex());
 
         notifications.swap(notificationQueue());

trunk/Source/WebCore/Modules/webdatabase/DatabaseTracker.h

@@ -108 +108 @@
     // clean up zero byte database files.  Any operations to open new database will have to
     // wait for that task to finish by waiting on this mutex.
-    static Mutex& openDatabaseMutex();
+    static DeprecatedMutex& openDatabaseMutex();
     
     WEBCORE_EXPORT static void emptyDatabaseFilesRemovalTaskWillBeScheduled();
@@ -151 +151 @@
     typedef HashMap<RefPtr<SecurityOrigin>, DatabaseNameMap*> DatabaseOriginMap;
 
-    Mutex m_openDatabaseMapGuard;
+    DeprecatedMutex m_openDatabaseMapGuard;
     mutable std::unique_ptr<DatabaseOriginMap> m_openDatabaseMap;
 
     // This lock protects m_database, m_originLockMap, m_databaseDirectoryPath, m_originsBeingDeleted, m_beingCreated, and m_beingDeleted.
-    Mutex m_databaseGuard;
+    DeprecatedMutex m_databaseGuard;
     SQLiteDatabase m_database;
 

trunk/Source/WebCore/Modules/webdatabase/OriginLock.h

@@ -49 +49 @@
 
     String m_lockFileName;
-    Mutex m_mutex;
+    DeprecatedMutex m_mutex;
 #if USE(FILE_LOCK)
     PlatformFileHandle m_lockHandle;

trunk/Source/WebCore/Modules/webdatabase/SQLCallbackWrapper.h

@@ -59 +59 @@
         T* callback;
         {
-            MutexLocker locker(m_mutex);
+            DeprecatedMutexLocker locker(m_mutex);
             if (!m_callback) {
                 ASSERT(!m_scriptExecutionContext);
@@ -84 +84 @@
     PassRefPtr<T> unwrap()
     {
-        MutexLocker locker(m_mutex);
+        DeprecatedMutexLocker locker(m_mutex);
         ASSERT(!m_callback || m_scriptExecutionContext->isContextThread());
         m_scriptExecutionContext = nullptr;
@@ -94 +94 @@
 
 private:
-    Mutex m_mutex;
+    DeprecatedMutex m_mutex;
     RefPtr<T> m_callback;
     RefPtr<ScriptExecutionContext> m_scriptExecutionContext;

trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp

@@ -383 +383 @@
     releaseOriginLockIfNeeded();
 
-    MutexLocker locker(m_statementMutex);
+    DeprecatedMutexLocker locker(m_statementMutex);
     m_statementQueue.clear();
 
@@ -467 +467 @@
 void SQLTransactionBackend::enqueueStatementBackend(PassRefPtr<SQLStatementBackend> statementBackend)
 {
-    MutexLocker locker(m_statementMutex);
+    DeprecatedMutexLocker locker(m_statementMutex);
     m_statementQueue.append(statementBackend);
 }
@@ -667 +667 @@
     m_currentStatementBackend = nullptr;
 
-    MutexLocker locker(m_statementMutex);
+    DeprecatedMutexLocker locker(m_statementMutex);
     if (!m_statementQueue.isEmpty())
         m_currentStatementBackend = m_statementQueue.takeFirst();

trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h

@@ -129 +129 @@
     bool m_hasVersionMismatch;
 
-    Mutex m_statementMutex;
+    DeprecatedMutex m_statementMutex;
     Deque<RefPtr<SQLStatementBackend>> m_statementQueue;
 

trunk/Source/WebCore/bindings/js/WorkerScriptController.cpp

@@ -151 +151 @@
     // termination is scheduled, isExecutionTerminating will
     // accurately reflect that state when called from another thread.
-    MutexLocker locker(m_scheduledTerminationMutex);
+    DeprecatedMutexLocker locker(m_scheduledTerminationMutex);
     if (m_vm->watchdog)
         m_vm->watchdog->fire();
@@ -159 +159 @@
 {
     // See comments in scheduleExecutionTermination regarding mutex usage.
-    MutexLocker locker(m_scheduledTerminationMutex);
+    DeprecatedMutexLocker locker(m_scheduledTerminationMutex);
     if (m_vm->watchdog)
         return m_vm->watchdog->didFire();

trunk/Source/WebCore/bindings/js/WorkerScriptController.h

@@ -98 +98 @@
         JSC::Strong<JSWorkerGlobalScope> m_workerGlobalScopeWrapper;
         bool m_executionForbidden;
-        mutable Mutex m_scheduledTerminationMutex;
+        mutable DeprecatedMutex m_scheduledTerminationMutex;
     };
 

trunk/Source/WebCore/dom/default/PlatformMessagePortChannel.cpp

@@ -89 +89 @@
 void MessagePortChannel::postMessageToRemote(PassRefPtr<SerializedScriptValue> message, std::unique_ptr<MessagePortChannelArray> channels)
 {
-    MutexLocker lock(m_channel->m_mutex);
+    DeprecatedMutexLocker lock(m_channel->m_mutex);
     if (!m_channel->m_outgoingQueue)
         return;
@@ -99 +99 @@
 bool MessagePortChannel::tryGetMessageFromRemote(RefPtr<SerializedScriptValue>& message, std::unique_ptr<MessagePortChannelArray>& channels)
 {
-    MutexLocker lock(m_channel->m_mutex);
+    DeprecatedMutexLocker lock(m_channel->m_mutex);
     auto result = m_channel->m_incomingQueue->tryGetMessage();
     if (!result)
@@ -122 +122 @@
 {
     // FIXME: What guarantees that the result remains the same after we release the lock?
-    MutexLocker lock(m_channel->m_mutex);
+    DeprecatedMutexLocker lock(m_channel->m_mutex);
     return m_channel->m_remotePort == port;
 }
@@ -129 +129 @@
 {
     // FIXME: What guarantees that the result remains the same after we release the lock?
-    MutexLocker lock(m_channel->m_mutex);
+    DeprecatedMutexLocker lock(m_channel->m_mutex);
     return !m_channel->m_incomingQueue->isEmpty();
 }
@@ -135 +135 @@
 MessagePort* MessagePortChannel::locallyEntangledPort(const ScriptExecutionContext* context)
 {
-    MutexLocker lock(m_channel->m_mutex);
+    DeprecatedMutexLocker lock(m_channel->m_mutex);
     // See if both contexts are run by the same thread (are the same context, or are both documents).
     if (m_channel->m_remotePort) {
@@ -165 +165 @@
 void PlatformMessagePortChannel::setRemotePort(MessagePort* port)
 {
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
     // Should never set port if it is already set.
     ASSERT(!port || !m_remotePort);
@@ -176 +176 @@
     // This lock only guarantees that the returned pointer will not be pointing to released memory,
     // but not that it will still be pointing to this object's entangled port channel.
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
     return m_entangledChannel;
 }
@@ -182 +182 @@
 void PlatformMessagePortChannel::closeInternal()
 {
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
     // Disentangle ourselves from the other end. We still maintain a reference to our incoming queue, since previously-existing messages should still be delivered.
     m_remotePort = nullptr;

trunk/Source/WebCore/dom/default/PlatformMessagePortChannel.h

@@ -96 +96 @@
         void closeInternal();
 
-        // Mutex used to ensure exclusive access to the object internals.
-        Mutex m_mutex;
+        // DeprecatedMutex used to ensure exclusive access to the object internals.
+        DeprecatedMutex m_mutex;
 
         // Pointer to our entangled pair - cleared when close() is called.

trunk/Source/WebCore/loader/icon/IconDatabase.cpp

@@ -187 +187 @@
     // Clear the in-memory record of every IconRecord, anything waiting to be read from disk, and anything waiting to be written to disk
     {
-        MutexLocker locker(m_urlAndIconLock);
+        DeprecatedMutexLocker locker(m_urlAndIconLock);
         
         // Clear the IconRecords for every page URL - RefCounting will cause the IconRecords themselves to be deleted
@@ -201 +201 @@
         // Clear all in-memory records of things that need to be synced out to disk
         {
-            MutexLocker locker(m_pendingSyncLock);
+            DeprecatedMutexLocker locker(m_pendingSyncLock);
             m_pageURLsPendingSync.clear();
             m_iconsPendingSync.clear();
@@ -208 +208 @@
         // Clear all in-memory records of things that need to be read in from disk
         {
-            MutexLocker locker(m_pendingReadingLock);
+            DeprecatedMutexLocker locker(m_pendingReadingLock);
             m_pageURLsPendingImport.clear();
             m_pageURLsInterestedInIcons.clear();
@@ -230 +230 @@
         return 0;
 
-    MutexLocker locker(m_urlAndIconLock);
+    DeprecatedMutexLocker locker(m_urlAndIconLock);
 
     performPendingRetainAndReleaseOperations();
@@ -246 +246 @@
     // 2 - The initial url import IS complete and this pageURL has no icon
     if (!pageRecord) {
-        MutexLocker locker(m_pendingReadingLock);
+        DeprecatedMutexLocker locker(m_pendingReadingLock);
         
         // Import is ongoing, there might be an icon.  In this case, register to be notified when the icon comes in
@@ -277 +277 @@
             pageURLCopy = pageURLOriginal.isolatedCopy();
     
-        MutexLocker locker(m_pendingReadingLock);
+        DeprecatedMutexLocker locker(m_pendingReadingLock);
         m_pageURLsInterestedInIcons.add(pageURLCopy);
         m_iconsPendingReading.add(iconRecord);
@@ -308 +308 @@
         return 0;
 
-    MutexLocker locker(m_urlAndIconLock);
+    DeprecatedMutexLocker locker(m_urlAndIconLock);
     return icon->nativeImageForCurrentFrame();
 }
@@ -330 +330 @@
         return String();
         
-    MutexLocker locker(m_urlAndIconLock);
+    DeprecatedMutexLocker locker(m_urlAndIconLock);
     
     PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURLOriginal);
@@ -418 +418 @@
 
     {
-        MutexLocker locker(m_urlsToRetainOrReleaseLock);
+        DeprecatedMutexLocker locker(m_urlsToRetainOrReleaseLock);
         m_urlsToRetain.add(pageURL.isolatedCopy());
         m_retainOrReleaseIconRequested = true;
@@ -451 +451 @@
             return;
 
-        MutexLocker locker(m_pendingSyncLock);
+        DeprecatedMutexLocker locker(m_pendingSyncLock);
         // If this pageURL waiting to be sync'ed, update the sync record
         // This saves us in the case where a page was ready to be deleted from the database but was just retained - so theres no need to delete it!
@@ -471 +471 @@
 
     {
-        MutexLocker locker(m_urlsToRetainOrReleaseLock);
+        DeprecatedMutexLocker locker(m_urlsToRetainOrReleaseLock);
         m_urlsToRelease.add(pageURL.isolatedCopy());
         m_retainOrReleaseIconRequested = true;
@@ -507 +507 @@
 
     {
-        MutexLocker locker(m_pendingReadingLock);
+        DeprecatedMutexLocker locker(m_pendingReadingLock);
         
         // Since this pageURL is going away, there's no reason anyone would ever be interested in its read results    
@@ -523 +523 @@
     // Mark stuff for deletion from the database only if we're not in private browsing
     if (!m_privateBrowsingEnabled) {
-        MutexLocker locker(m_pendingSyncLock);
+        DeprecatedMutexLocker locker(m_pendingSyncLock);
         m_pageURLsPendingSync.set(pageURLOriginal.isolatedCopy(), pageRecord->snapshot(true));
     
@@ -549 +549 @@
     Vector<String> pageURLs;
     {
-        MutexLocker locker(m_urlAndIconLock);
+        DeprecatedMutexLocker locker(m_urlAndIconLock);
     
         // If this icon was pending a read, remove it from that set because this new data should override what is on disk
         RefPtr<IconRecord> icon = m_iconURLToRecordMap.get(iconURL);
         if (icon) {
-            MutexLocker locker(m_pendingReadingLock);
+            DeprecatedMutexLocker locker(m_pendingReadingLock);
             m_iconsPendingReading.remove(icon.get());
         } else
@@ -568 +568 @@
         // Mark the IconRecord as requiring an update to the database only if private browsing is disabled
         if (!m_privateBrowsingEnabled) {
-            MutexLocker locker(m_pendingSyncLock);
+            DeprecatedMutexLocker locker(m_pendingSyncLock);
             m_iconsPendingSync.set(iconURL, icon->snapshot());
         }
@@ -609 +609 @@
     
     {
-        MutexLocker locker(m_urlAndIconLock);
+        DeprecatedMutexLocker locker(m_urlAndIconLock);
 
         PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURLOriginal);
@@ -637 +637 @@
             LOG(IconDatabase, "Icon for icon url %s is about to be destroyed - removing mapping for it", urlForLogging(iconRecord->iconURL()).ascii().data());
             m_iconURLToRecordMap.remove(iconRecord->iconURL());
-            MutexLocker locker(m_pendingReadingLock);
+            DeprecatedMutexLocker locker(m_pendingReadingLock);
             m_iconsPendingReading.remove(iconRecord.get());
         }
@@ -643 +643 @@
         // And mark this mapping to be added to the database
         if (!m_privateBrowsingEnabled) {
-            MutexLocker locker(m_pendingSyncLock);
+            DeprecatedMutexLocker locker(m_pendingSyncLock);
             m_pageURLsPendingSync.set(pageURL, pageRecord->snapshot());
             
@@ -675 +675 @@
     // 2 - When we get a new icon from the loader, in which case the timestamp is set at that time
     {
-        MutexLocker locker(m_urlAndIconLock);
+        DeprecatedMutexLocker locker(m_urlAndIconLock);
         if (IconRecord* icon = m_iconURLToRecordMap.get(iconURL)) {
             LOG(IconDatabase, "Found expiration time on a present icon based on existing IconRecord");
@@ -683 +683 @@
     
     // If we don't have a record for it, but we *have* imported all iconURLs from disk, then we should load it now
-    MutexLocker readingLocker(m_pendingReadingLock);
+    DeprecatedMutexLocker readingLocker(m_pendingReadingLock);
     if (m_iconURLImportComplete)
         return IconLoadYes;
@@ -700 +700 @@
     ASSERT_NOT_SYNC_THREAD();
     
-    MutexLocker locker(m_urlAndIconLock);
+    DeprecatedMutexLocker locker(m_urlAndIconLock);
     if (IconRecord* icon = m_iconURLToRecordMap.get(iconURL))
         return icon->imageDataStatus() != ImageDataStatusUnknown;
@@ -755 +755 @@
 size_t IconDatabase::pageURLMappingCount()
 {
-    MutexLocker locker(m_urlAndIconLock);
+    DeprecatedMutexLocker locker(m_urlAndIconLock);
     return m_pageURLToRecordMap.size();
 }
@@ -761 +761 @@
 size_t IconDatabase::retainedPageURLCount()
 {
-    MutexLocker locker(m_urlAndIconLock);
+    DeprecatedMutexLocker locker(m_urlAndIconLock);
     performPendingRetainAndReleaseOperations();
     return m_retainedPageURLs.size();
@@ -768 +768 @@
 size_t IconDatabase::iconRecordCount()
 {
-    MutexLocker locker(m_urlAndIconLock);
+    DeprecatedMutexLocker locker(m_urlAndIconLock);
     return m_iconURLToRecordMap.size();
 }
@@ -774 +774 @@
 size_t IconDatabase::iconRecordCountWithData()
 {
-    MutexLocker locker(m_urlAndIconLock);
+    DeprecatedMutexLocker locker(m_urlAndIconLock);
     size_t result = 0;
     
@@ -830 +830 @@
 void IconDatabase::wakeSyncThread()
 {
-    MutexLocker locker(m_syncLock);
+    DeprecatedMutexLocker locker(m_syncLock);
 
     if (!m_disableSuddenTerminationWhileSyncThreadHasWorkToDo)
@@ -875 +875 @@
 bool IconDatabase::isOpenBesidesMainThreadCallbacks() const
 {
-    MutexLocker locker(m_syncLock);
+    DeprecatedMutexLocker locker(m_syncLock);
     return m_syncThreadRunning || m_syncDB.isOpen();
 }
@@ -881 +881 @@
 String IconDatabase::databasePath() const
 {
-    MutexLocker locker(m_syncLock);
+    DeprecatedMutexLocker locker(m_syncLock);
     return m_completeDatabasePath.isolatedCopy();
 }
@@ -917 +917 @@
     PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURL);
     
-    MutexLocker locker(m_pendingReadingLock);
+    DeprecatedMutexLocker locker(m_pendingReadingLock);
     if (!m_iconURLImportComplete) {
         // If the initial import of all URLs hasn't completed and we have no page record, we assume we *might* know about this later and create a record for it
@@ -986 +986 @@
     
     {
-        MutexLocker locker(m_syncLock);
+        DeprecatedMutexLocker locker(m_syncLock);
         if (!m_syncDB.open(m_completeDatabasePath)) {
             LOG_ERROR("Unable to open icon database at path %s - %s", m_completeDatabasePath.ascii().data(), m_syncDB.lastErrorMsg());
@@ -1114 +1114 @@
             
             {
-                MutexLocker locker(m_syncLock);
+                DeprecatedMutexLocker locker(m_syncLock);
                 // Should've been consumed by SQLite, delete just to make sure we don't see it again in the future;
                 deleteFile(m_completeDatabasePath + "-journal");
@@ -1216 +1216 @@
 
         {
-            MutexLocker locker(m_urlAndIconLock);
+            DeprecatedMutexLocker locker(m_urlAndIconLock);
 
             PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURL);
@@ -1249 +1249 @@
         // Note that WebIconDatabase is not neccessarily API so we might be able to make this change
         {
-            MutexLocker locker(m_pendingReadingLock);
+            DeprecatedMutexLocker locker(m_pendingReadingLock);
             if (m_pageURLsPendingImport.contains(pageURL)) {
                 dispatchDidImportIconURLForPageURLOnMainThread(pageURL);
@@ -1272 +1272 @@
     Vector<String> urls;
     {
-        MutexLocker locker(m_pendingReadingLock);
+        DeprecatedMutexLocker locker(m_pendingReadingLock);
 
         urls.appendRange(m_pageURLsPendingImport.begin(), m_pageURLsPendingImport.end());
@@ -1285 +1285 @@
     // Keep a set of ones that are retained and pending notification
     {
-        MutexLocker locker(m_urlAndIconLock);
+        DeprecatedMutexLocker locker(m_urlAndIconLock);
 
         performPendingRetainAndReleaseOperations();
@@ -1302 +1302 @@
                         
                         {
-                            MutexLocker locker(m_pendingReadingLock);
+                            DeprecatedMutexLocker locker(m_pendingReadingLock);
                             m_pageURLsInterestedInIcons.remove(urls[i]);
                             m_iconsPendingReading.remove(iconRecord);
                         }
                         {
-                            MutexLocker locker(m_pendingSyncLock);
+                            DeprecatedMutexLocker locker(m_pendingSyncLock);
                             m_iconsPendingSync.set(iconRecord->iconURL(), iconRecord->snapshot(true));                    
                         }
@@ -1372 +1372 @@
 
         {
-            MutexLocker locker(m_urlAndIconLock);
+            DeprecatedMutexLocker locker(m_urlAndIconLock);
             performPendingRetainAndReleaseOperations();
         }
@@ -1452 +1452 @@
 
     {
-        MutexLocker pendingWorkLocker(m_urlsToRetainOrReleaseLock);
+        DeprecatedMutexLocker pendingWorkLocker(m_urlsToRetainOrReleaseLock);
         if (!m_retainOrReleaseIconRequested)
             return;
@@ -1489 +1489 @@
     Vector<IconRecord*> icons;
     {
-        MutexLocker locker(m_pendingReadingLock);
+        DeprecatedMutexLocker locker(m_pendingReadingLock);
         icons.appendRange(m_iconsPendingReading.begin(), m_iconsPendingReading.end());
     }
@@ -1502 +1502 @@
         // Verify this icon still wants to be read from disk
         {
-            MutexLocker urlLocker(m_urlAndIconLock);
+            DeprecatedMutexLocker urlLocker(m_urlAndIconLock);
             {
-                MutexLocker readLocker(m_pendingReadingLock);
+                DeprecatedMutexLocker readLocker(m_pendingReadingLock);
                 
                 if (m_iconsPendingReading.contains(icons[i])) {
@@ -1592 +1592 @@
     // asked for by the database on the main thread
     {
-        MutexLocker locker(m_urlAndIconLock);
+        DeprecatedMutexLocker locker(m_urlAndIconLock);
         Vector<IconSnapshot> iconSnapshots;
         Vector<PageURLSnapshot> pageSnapshots;
         {
-            MutexLocker locker(m_pendingSyncLock);
+            DeprecatedMutexLocker locker(m_pendingSyncLock);
 
             iconSnapshots.appendRange(m_iconsPendingSync.begin().values(), m_iconsPendingSync.end().values());
@@ -1659 +1659 @@
     int result;
     while ((result = pageSQL.step()) == SQLITE_ROW) {
-        MutexLocker locker(m_urlAndIconLock);
+        DeprecatedMutexLocker locker(m_urlAndIconLock);
         if (!m_pageURLToRecordMap.contains(pageSQL.getColumnText(1)))
             pageIDsToDelete.append(pageSQL.getColumnInt64(0));
@@ -1792 +1792 @@
     
     // Close the database
-    MutexLocker locker(m_syncLock);
+    DeprecatedMutexLocker locker(m_syncLock);
     
     m_databaseDirectory = String();

trunk/Source/WebCore/loader/icon/IconDatabase.h

@@ -142 +142 @@
     bool m_privateBrowsingEnabled;
 
-    mutable Mutex m_syncLock;
+    mutable DeprecatedMutex m_syncLock;
     ThreadCondition m_syncCondition;
     String m_databaseDirectory;
@@ -154 +154 @@
     std::unique_ptr<SuddenTerminationDisabler> m_disableSuddenTerminationWhileSyncThreadHasWorkToDo;
 
-    Mutex m_urlAndIconLock;
+    DeprecatedMutex m_urlAndIconLock;
     // Holding m_urlAndIconLock is required when accessing any of the following data structures or the objects they contain
     HashMap<String, IconRecord*> m_iconURLToRecordMap;
@@ -160 +160 @@
     HashSet<String> m_retainedPageURLs;
 
-    Mutex m_pendingSyncLock;
+    DeprecatedMutex m_pendingSyncLock;
     // Holding m_pendingSyncLock is required when accessing any of the following data structures
     HashMap<String, PageURLSnapshot> m_pageURLsPendingSync;
     HashMap<String, IconSnapshot> m_iconsPendingSync;
     
-    Mutex m_pendingReadingLock;    
+    DeprecatedMutex m_pendingReadingLock;    
     // Holding m_pendingSyncLock is required when accessing any of the following data structures - when dealing with IconRecord*s, holding m_urlAndIconLock is also required
     HashSet<String> m_pageURLsPendingImport;
@@ -171 +171 @@
     HashSet<IconRecord*> m_iconsPendingReading;
 
-    Mutex m_urlsToRetainOrReleaseLock;
+    DeprecatedMutex m_urlsToRetainOrReleaseLock;
     // Holding m_urlsToRetainOrReleaseLock is required when accessing any of the following data structures.
     HashCountedSet<String> m_urlsToRetain;

trunk/Source/WebCore/page/scrolling/ScrollingTree.cpp

@@ -50 +50 @@
 {
     // This method is invoked by the event handling thread
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
 
     bool shouldSetLatch = wheelEvent.shouldConsiderLatching();
@@ -116 +116 @@
             || rootNode->hasChangedProperty(ScrollingStateFrameScrollingNode::NonFastScrollableRegion)
             || rootNode->hasChangedProperty(ScrollingStateNode::ScrollLayer))) {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
 
         if (rootStateNodeChanged || rootNode->hasChangedProperty(ScrollingStateNode::ScrollLayer))
@@ -209 +209 @@
 void ScrollingTree::setMainFramePinState(bool pinnedToTheLeft, bool pinnedToTheRight, bool pinnedToTheTop, bool pinnedToTheBottom)
 {
-    MutexLocker locker(m_swipeStateMutex);
+    DeprecatedMutexLocker locker(m_swipeStateMutex);
 
     m_mainFramePinnedToTheLeft = pinnedToTheLeft;
@@ -219 +219 @@
 FloatPoint ScrollingTree::mainFrameScrollPosition()
 {
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
     return m_mainFrameScrollPosition;
 }
@@ -225 +225 @@
 void ScrollingTree::setMainFrameScrollPosition(FloatPoint position)
 {
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
     m_mainFrameScrollPosition = position;
 }
@@ -231 +231 @@
 bool ScrollingTree::isPointInNonFastScrollableRegion(IntPoint p)
 {
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
     
     return m_nonFastScrollableRegion.contains(p);
@@ -238 +238 @@
 bool ScrollingTree::isRubberBandInProgress()
 {
-    MutexLocker lock(m_mutex);    
+    DeprecatedMutexLocker lock(m_mutex);    
 
     return m_mainFrameIsRubberBanding;
@@ -245 +245 @@
 void ScrollingTree::setMainFrameIsRubberBanding(bool isRubberBanding)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     m_mainFrameIsRubberBanding = isRubberBanding;
@@ -252 +252 @@
 bool ScrollingTree::isScrollSnapInProgress()
 {
-    MutexLocker lock(m_mutex);
+    DeprecatedMutexLocker lock(m_mutex);
     
     return m_mainFrameIsScrollSnapping;
@@ -259 +259 @@
 void ScrollingTree::setMainFrameIsScrollSnapping(bool isScrollSnapping)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     
     m_mainFrameIsScrollSnapping = isScrollSnapping;
@@ -266 +266 @@
 void ScrollingTree::setCanRubberBandState(bool canRubberBandAtLeft, bool canRubberBandAtRight, bool canRubberBandAtTop, bool canRubberBandAtBottom)
 {
-    MutexLocker locker(m_swipeStateMutex);
+    DeprecatedMutexLocker locker(m_swipeStateMutex);
 
     m_rubberBandsAtLeft = canRubberBandAtLeft;
@@ -276 +276 @@
 bool ScrollingTree::rubberBandsAtLeft()
 {
-    MutexLocker lock(m_swipeStateMutex);
+    DeprecatedMutexLocker lock(m_swipeStateMutex);
 
     return m_rubberBandsAtLeft;
@@ -283 +283 @@
 bool ScrollingTree::rubberBandsAtRight()
 {
-    MutexLocker lock(m_swipeStateMutex);
+    DeprecatedMutexLocker lock(m_swipeStateMutex);
 
     return m_rubberBandsAtRight;
@@ -290 +290 @@
 bool ScrollingTree::rubberBandsAtBottom()
 {
-    MutexLocker lock(m_swipeStateMutex);
+    DeprecatedMutexLocker lock(m_swipeStateMutex);
 
     return m_rubberBandsAtBottom;
@@ -297 +297 @@
 bool ScrollingTree::rubberBandsAtTop()
 {
-    MutexLocker lock(m_swipeStateMutex);
+    DeprecatedMutexLocker lock(m_swipeStateMutex);
 
     return m_rubberBandsAtTop;
@@ -309 +309 @@
 void ScrollingTree::setScrollPinningBehavior(ScrollPinningBehavior pinning)
 {
-    MutexLocker locker(m_swipeStateMutex);
+    DeprecatedMutexLocker locker(m_swipeStateMutex);
     
     m_scrollPinningBehavior = pinning;
@@ -316 +316 @@
 ScrollPinningBehavior ScrollingTree::scrollPinningBehavior()
 {
-    MutexLocker lock(m_swipeStateMutex);
+    DeprecatedMutexLocker lock(m_swipeStateMutex);
     
     return m_scrollPinningBehavior;
@@ -326 +326 @@
         return false;
 
-    MutexLocker lock(m_swipeStateMutex);
+    DeprecatedMutexLocker lock(m_swipeStateMutex);
 
     if (wheelEvent.deltaX() > 0 && m_mainFramePinnedToTheLeft && !m_rubberBandsAtLeft)
@@ -352 +352 @@
 ScrollingNodeID ScrollingTree::latchedNode()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     return m_latchedNode;
 }
@@ -358 +358 @@
 void ScrollingTree::setLatchedNode(ScrollingNodeID node)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     m_latchedNode = node;
 }
@@ -364 +364 @@
 void ScrollingTree::clearLatchedNode()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     m_latchedNode = 0;
 }

trunk/Source/WebCore/page/scrolling/ScrollingTree.h

@@ -161 +161 @@
     ScrollingTreeNodeMap m_nodeMap;
 
-    Mutex m_mutex;
+    DeprecatedMutex m_mutex;
     Region m_nonFastScrollableRegion;
     FloatPoint m_mainFrameScrollPosition;
 
-    Mutex m_swipeStateMutex;
+    DeprecatedMutex m_swipeStateMutex;
     ScrollPinningBehavior m_scrollPinningBehavior { DoNotPin };
     ScrollingNodeID m_latchedNode { 0 };

trunk/Source/WebCore/platform/MemoryPressureHandler.h

@@ -138 +138 @@
     void (^m_releaseMemoryBlock)();
     CFRunLoopObserverRef m_observer;
-    Mutex m_observerMutex;
+    DeprecatedMutex m_observerMutex;
 #elif OS(LINUX)
     int m_eventFD;

trunk/Source/WebCore/platform/audio/HRTFDatabaseLoader.cpp

@@ -103 +103 @@
     ASSERT(isMainThread());
 
-    MutexLocker locker(m_threadLock);
+    DeprecatedMutexLocker locker(m_threadLock);
     
     if (!m_hrtfDatabase.get() && !m_databaseLoaderThread) {
@@ -118 +118 @@
 void HRTFDatabaseLoader::waitForLoaderThreadCompletion()
 {
-    MutexLocker locker(m_threadLock);
+    DeprecatedMutexLocker locker(m_threadLock);
     
     // waitForThreadCompletion() should not be called twice for the same thread.

trunk/Source/WebCore/platform/audio/HRTFDatabaseLoader.h

@@ -77 +77 @@
 
     // Holding a m_threadLock is required when accessing m_databaseLoaderThread.
-    Mutex m_threadLock;
+    DeprecatedMutex m_threadLock;
     ThreadIdentifier m_databaseLoaderThread;
 

trunk/Source/WebCore/platform/cocoa/MemoryPressureHandlerCocoa.mm

@@ -257 +257 @@
 
     {
-        MutexLocker locker(m_observerMutex);
+        DeprecatedMutexLocker locker(m_observerMutex);
         if (!m_observer) {
             m_observer = CFRunLoopObserverCreate(NULL, kCFRunLoopBeforeWaiting | kCFRunLoopExit, NO /* don't repeat */,
@@ -273 +273 @@
 
     {
-        MutexLocker locker(m_observerMutex);
+        DeprecatedMutexLocker locker(m_observerMutex);
         m_memoryPressureReason = MemoryPressureReasonNone;
     }
@@ -280 +280 @@
 bool MemoryPressureHandler::shouldWaitForMemoryClearMessage()
 {
-    MutexLocker locker(m_observerMutex);
+    DeprecatedMutexLocker locker(m_observerMutex);
     return m_memoryPressureReason & MemoryPressureReasonVMStatus;
 }
@@ -289 +289 @@
 
     {
-        MutexLocker locker(m_observerMutex);
+        DeprecatedMutexLocker locker(m_observerMutex);
         m_observer = 0;
     }

trunk/Source/WebCore/platform/graphics/DisplayRefreshMonitor.cpp

@@ -90 +90 @@
 
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         if (!m_scheduled)
             ++m_unscheduledFireCount;
@@ -122 +122 @@
 
     {
-        MutexLocker lock(m_mutex);
+        DeprecatedMutexLocker lock(m_mutex);
         m_previousFrameDone = true;
     }

trunk/Source/WebCore/platform/graphics/DisplayRefreshMonitor.h

@@ -73 +73 @@
     void setMonotonicAnimationStartTime(double startTime) { m_monotonicAnimationStartTime = startTime; }
 
-    Mutex& mutex() { return m_mutex; }
+    DeprecatedMutex& mutex() { return m_mutex; }
 
     static RefPtr<DisplayRefreshMonitor> createDefaultDisplayRefreshMonitor(PlatformDisplayID);
@@ -90 +90 @@
     int m_unscheduledFireCount; // Number of times the display link has fired with no clients.
     PlatformDisplayID m_displayID;
-    Mutex m_mutex;
+    DeprecatedMutex m_mutex;
 
     HashSet<DisplayRefreshMonitorClient*> m_clients;

trunk/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp

@@ -741 +741 @@
 void MediaPlayerPrivateAVFoundation::setDelayCallbacks(bool delay) const
 {
-    MutexLocker lock(m_queueMutex);
+    DeprecatedMutexLocker lock(m_queueMutex);
     if (delay)
         ++m_delayCallbacks;
@@ -760 +760 @@
 void MediaPlayerPrivateAVFoundation::clearMainThreadPendingFlag()
 {
-    MutexLocker lock(m_queueMutex);
+    DeprecatedMutexLocker lock(m_queueMutex);
     m_mainThreadCallPending = false;
 }
@@ -826 +826 @@
     Notification notification = Notification();
     {
-        MutexLocker lock(m_queueMutex);
+        DeprecatedMutexLocker lock(m_queueMutex);
         
         if (m_queuedNotifications.isEmpty())

trunk/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h

@@ -318 +318 @@
 
     Vector<Notification> m_queuedNotifications;
-    mutable Mutex m_queueMutex;
+    mutable DeprecatedMutex m_queueMutex;
 
     mutable std::unique_ptr<PlatformTimeRanges> m_cachedLoadedTimeRanges;

trunk/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp

@@ -158 +158 @@
     inline void* callbackContext() const { return reinterpret_cast<void*>(m_objectID); }
 
-    static Mutex& mapLock();
+    static DeprecatedMutex& mapLock();
     static HashMap<uintptr_t, AVFWrapper*>& map();
     static AVFWrapper* avfWrapperForCallbackContext(void*);
@@ -1404 +1404 @@
 }
 
-Mutex& AVFWrapper::mapLock()
-{
-    static Mutex mapLock;
+DeprecatedMutex& AVFWrapper::mapLock()
+{
+    static DeprecatedMutex mapLock;
     return mapLock;
 }
@@ -1418 +1418 @@
 void AVFWrapper::addToMap()
 {
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     
     // HashMap doesn't like a key of 0, and also make sure we aren't
@@ -1434 +1434 @@
     LOG(Media, "AVFWrapper::removeFromMap(%p %d)", this, m_objectID);
 
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     map().remove(m_objectID);
 }
@@ -1635 +1635 @@
 void AVFWrapper::periodicTimeObserverCallback(AVCFPlayerRef, CMTime cmTime, void* context)
 {
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(context);
     if (!self) {
@@ -1666 +1666 @@
     std::unique_ptr<NotificationCallbackData> notificationData { static_cast<NotificationCallbackData*>(context) };
 
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(notificationData->m_context);
     if (!self) {
@@ -1721 +1721 @@
 void AVFWrapper::loadPlayableCompletionCallback(AVCFAssetRef, void* context)
 {
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(context);
     if (!self) {
@@ -1749 +1749 @@
 void AVFWrapper::loadMetadataCompletionCallback(AVCFAssetRef, void* context)
 {
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(context);
     if (!self) {
@@ -1769 +1769 @@
 void AVFWrapper::seekCompletedCallback(AVCFPlayerItemRef, Boolean finished, void* context)
 {
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(context);
     if (!self) {
@@ -1812 +1812 @@
     std::unique_ptr<LegibleOutputData> legibleOutputData(reinterpret_cast<LegibleOutputData*>(context));
 
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(legibleOutputData->m_context);
     if (!self) {
@@ -1828 +1828 @@
 {
     ASSERT(!isMainThread());
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(context);
     if (!self) {
@@ -1866 +1866 @@
     std::unique_ptr<LoadRequestData> loadRequestData(reinterpret_cast<LoadRequestData*>(context));
 
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(loadRequestData->m_context);
     if (!self) {
@@ -1922 +1922 @@
 {
     ASSERT(dispatch_get_main_queue() != dispatch_get_current_queue());
-    MutexLocker locker(mapLock());
+    DeprecatedMutexLocker locker(mapLock());
     AVFWrapper* self = avfWrapperForCallbackContext(context);
     if (!self) {

trunk/Source/WebCore/platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.cpp

@@ -78 +78 @@
     m_sampleTimerHandler.cancel();
     {
-        MutexLocker lock(m_sampleMutex);
+        DeprecatedMutexLocker lock(m_sampleMutex);
         m_pendingSamples.append(sample);
     }
@@ -93 +93 @@
     Vector<GRefPtr<GstSample> > samples;
     {
-        MutexLocker lock(m_sampleMutex);
+        DeprecatedMutexLocker lock(m_sampleMutex);
         m_pendingSamples.swap(samples);
     }

trunk/Source/WebCore/platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.h

@@ -68 +68 @@
     Vector<GRefPtr<GstSample> > m_pendingSamples;
     String m_streamId;
-    Mutex m_sampleMutex;
+    DeprecatedMutex m_sampleMutex;
 };
 

trunk/Source/WebCore/platform/graphics/gstreamer/TrackPrivateBaseGStreamer.cpp

@@ -103 +103 @@
     g_object_get(m_pad.get(), "tags", &tags.outPtr(), NULL);
     {
-        MutexLocker lock(m_tagMutex);
+        DeprecatedMutexLocker lock(m_tagMutex);
         m_tags.swap(tags);
     }
@@ -159 +159 @@
     GRefPtr<GstTagList> tags;
     {
-        MutexLocker lock(m_tagMutex);
+        DeprecatedMutexLocker lock(m_tagMutex);
         tags.swap(m_tags);
     }

trunk/Source/WebCore/platform/graphics/gstreamer/TrackPrivateBaseGStreamer.h

@@ -74 +74 @@
     GThreadSafeMainLoopSource m_tagTimerHandler;
 
-    Mutex m_tagMutex;
+    DeprecatedMutex m_tagMutex;
     GRefPtr<GstTagList> m_tags;
 };

trunk/Source/WebCore/platform/graphics/mac/DisplayRefreshMonitorMac.cpp

@@ -85 +85 @@
     }
 
-    MutexLocker lock(mutex());
+    DeprecatedMutexLocker lock(mutex());
     setIsScheduled(true);
     return true;
@@ -92 +92 @@
 void DisplayRefreshMonitorMac::displayLinkFired(double nowSeconds, double outputTimeSeconds)
 {
-    MutexLocker lock(mutex());
+    DeprecatedMutexLocker lock(mutex());
     if (!isPreviousFrameDone())
         return;

trunk/Source/WebCore/platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp

@@ -513 +513 @@
 void MediaPlayerPrivateMediaFoundation::addListener(MediaPlayerListener* listener)
 {
-    MutexLocker locker(m_mutexListeners);
+    DeprecatedMutexLocker locker(m_mutexListeners);
 
     m_listeners.add(listener);
@@ -520 +520 @@
 void MediaPlayerPrivateMediaFoundation::removeListener(MediaPlayerListener* listener)
 {
-    MutexLocker locker(m_mutexListeners);
+    DeprecatedMutexLocker locker(m_mutexListeners);
 
     m_listeners.remove(listener);
@@ -527 +527 @@
 void MediaPlayerPrivateMediaFoundation::notifyDeleted()
 {
-    MutexLocker locker(m_mutexListeners);
+    DeprecatedMutexLocker locker(m_mutexListeners);
 
     for (HashSet<MediaPlayerListener*>::const_iterator it = m_listeners.begin(); it != m_listeners.end(); ++it)
@@ -705 +705 @@
 HRESULT STDMETHODCALLTYPE MediaPlayerPrivateMediaFoundation::AsyncCallback::Invoke(__RPC__in_opt IMFAsyncResult *pAsyncResult)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     if (!m_mediaPlayer)
@@ -720 +720 @@
 void MediaPlayerPrivateMediaFoundation::AsyncCallback::onMediaPlayerDeleted()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     m_mediaPlayer = nullptr;

trunk/Source/WebCore/platform/graphics/win/MediaPlayerPrivateMediaFoundation.h

@@ -90 +90 @@
     class MediaPlayerListener;
     HashSet<MediaPlayerListener*> m_listeners;
-    Mutex m_mutexListeners;
+    DeprecatedMutex m_mutexListeners;
 
     COMPtr<IMFMediaSession> m_mediaSession;
@@ -150 +150 @@
         MediaPlayerPrivateMediaFoundation* m_mediaPlayer;
         bool m_event;
-        Mutex m_mutex;
+        DeprecatedMutex m_mutex;
     };
 

trunk/Source/WebCore/platform/ios/LegacyTileCache.h

@@ -212 +212 @@
     float m_pendingZoomedOutScale;
 
-    mutable Mutex m_tileMutex;
-    mutable Mutex m_savedDisplayRectMutex;
-    mutable Mutex m_contentReplacementImageMutex;
+    mutable DeprecatedMutex m_tileMutex;
+    mutable DeprecatedMutex m_savedDisplayRectMutex;
+    mutable DeprecatedMutex m_contentReplacementImageMutex;
 
     bool m_tileControllerShouldUseLowScaleTiles;

trunk/Source/WebCore/platform/ios/LegacyTileCache.mm

@@ -148 +148 @@
         return;
 
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
 
     m_tilesOpaque = opaque;
@@ -161 +161 @@
         return;
 
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
     LegacyTileGrid* activeGrid = activeTileGrid();
     // Even though we aren't actually creating tiles in the inactive grid, we
@@ -201 +201 @@
         // Tile invalidation is normally suspended during zooming by UIKit but some applications
         // using custom scrollviews may zoom without triggering the callbacks. Invalidate the tiles explicitly.
-        MutexLocker locker(m_tileMutex);
+        DeprecatedMutexLocker locker(m_tileMutex);
         activeTileGrid()->dropAllTiles();
         activeTileGrid()->createTiles(CoverVisibleOnly);
@@ -226 +226 @@
     ASSERT(m_tilingMode != Disabled);
     
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
 
     if (m_pendingZoomedOutScale) {
@@ -315 +315 @@
         m_tilingMode = Minimal;
 
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
     LegacyTileGrid* activeGrid = activeTileGrid();
     if (activeGrid->checkDoSingleTileLayout()) {
@@ -328 +328 @@
 {
     ASSERT(WebThreadIsLockedOrDisabled());
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
 
     activeTileGrid()->addTilesCoveringRect(rect);
@@ -335 +335 @@
 void LegacyTileCache::removeAllNonVisibleTiles()
 {
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
     removeAllNonVisibleTilesInternal();
 }
@@ -357 +357 @@
 void LegacyTileCache::removeAllTiles()
 {
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
     m_zoomedOutTileGrid->dropAllTiles();
     if (m_zoomedInTileGrid)
@@ -365 +365 @@
 void LegacyTileCache::removeForegroundTiles()
 {
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
     if (!keepsZoomedOutTiles())
         m_zoomedOutTileGrid->dropAllTiles();
@@ -374 +374 @@
 void LegacyTileCache::setContentReplacementImage(RetainPtr<CGImageRef> contentReplacementImage)
 {
-    MutexLocker locker(m_contentReplacementImageMutex);
+    DeprecatedMutexLocker locker(m_contentReplacementImageMutex);
     m_contentReplacementImage = contentReplacementImage;
 }
@@ -380 +380 @@
 RetainPtr<CGImageRef> LegacyTileCache::contentReplacementImage() const
 {
-    MutexLocker locker(m_contentReplacementImageMutex);
+    DeprecatedMutexLocker locker(m_contentReplacementImageMutex);
     return m_contentReplacementImage;
 }
@@ -427 +427 @@
     if (isTileCreationSuspended())
         return;
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
     createTilesInActiveGrid(CoverSpeculative);
 }
@@ -621 +621 @@
 void LegacyTileCache::setNeedsDisplayInRect(const IntRect& dirtyRect)
 {
-    MutexLocker locker(m_savedDisplayRectMutex);
+    DeprecatedMutexLocker locker(m_savedDisplayRectMutex);
     bool addedFirstRect = m_savedDisplayRects.isEmpty();
     m_savedDisplayRects.append(dirtyRect);
@@ -693 +693 @@
             return;
 
-        MutexLocker locker(m_tileMutex);
+        DeprecatedMutexLocker locker(m_tileMutex);
         createTilesInActiveGrid(CoverVisibleOnly);
 
@@ -711 +711 @@
         commitScaleChange();
     else if (wasZooming) {
-        MutexLocker locker(m_tileMutex);
+        DeprecatedMutexLocker locker(m_tileMutex);
         bringActiveTileGridToFront();
     }
@@ -754 +754 @@
     if (isTileInvalidationSuspended())
         return;
-    MutexLocker locker(m_tileMutex);
+    DeprecatedMutexLocker locker(m_tileMutex);
     flushSavedDisplayRects();
 }
@@ -765 +765 @@
     Vector<IntRect> rects;
     {
-        MutexLocker locker(m_savedDisplayRectMutex);
+        DeprecatedMutexLocker locker(m_savedDisplayRectMutex);
         m_savedDisplayRects.swap(rects);
     }
@@ -793 +793 @@
 
     if (!m_savedDisplayRects.isEmpty()) {
-        MutexLocker locker(m_tileMutex);
+        DeprecatedMutexLocker locker(m_tileMutex);
         flushSavedDisplayRects();
     }

trunk/Source/WebCore/platform/ios/LegacyTileLayerPool.h

@@ -76 +76 @@
     unsigned m_totalBytes;
     unsigned m_capacity;
-    Mutex m_layerPoolMutex;
+    DeprecatedMutex m_layerPoolMutex;
 
     double m_lastAddTime;

trunk/Source/WebCore/platform/ios/LegacyTileLayerPool.mm

@@ -85 +85 @@
     }
 
-    MutexLocker locker(m_layerPoolMutex);
+    DeprecatedMutexLocker locker(m_layerPoolMutex);
     listOfLayersWithSize(layerSize).prepend(layer);
     m_totalBytes += bytesBackingLayerWithPixelSize(layerSize);
@@ -97 +97 @@
     if (!canReuseLayerWithSize(size))
         return nil;
-    MutexLocker locker(m_layerPoolMutex);
+    DeprecatedMutexLocker locker(m_layerPoolMutex);
     LayerList& reuseList = listOfLayersWithSize(size, MarkAsUsed);
     if (reuseList.isEmpty())
@@ -107 +107 @@
 void LegacyTileLayerPool::setCapacity(unsigned capacity)
 {
-    MutexLocker reuseLocker(m_layerPoolMutex);
+    DeprecatedMutexLocker reuseLocker(m_layerPoolMutex);
     if (capacity < m_capacity)
         schedulePrune();
@@ -137 +137 @@
 void LegacyTileLayerPool::prune()
 {
-    MutexLocker locker(m_layerPoolMutex);
+    DeprecatedMutexLocker locker(m_layerPoolMutex);
     ASSERT(m_needsPrune);
     m_needsPrune = false;
@@ -164 +164 @@
 void LegacyTileLayerPool::drain()
 {
-    MutexLocker reuseLocker(m_layerPoolMutex);
+    DeprecatedMutexLocker reuseLocker(m_layerPoolMutex);
     m_reuseLists.clear();
     m_sizesInPruneOrder.clear();

trunk/Source/WebCore/platform/network/curl/CurlDownload.cpp

@@ -61 +61 @@
 bool CurlDownloadManager::add(CURL* curlHandle)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     m_pendingHandleList.append(curlHandle);
@@ -71 +71 @@
 bool CurlDownloadManager::remove(CURL* curlHandle)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     m_removedHandleList.append(curlHandle);
@@ -80 +80 @@
 int CurlDownloadManager::getActiveDownloadCount() const
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     return m_activeHandleList.size();
 }
@@ -86 +86 @@
 int CurlDownloadManager::getPendingDownloadCount() const
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     return m_pendingHandleList.size();
 }
@@ -112 +112 @@
 void CurlDownloadManager::stopThreadIfIdle()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     if (!getActiveDownloadCount() && !getPendingDownloadCount())
@@ -120 +120 @@
 void CurlDownloadManager::updateHandleList()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     // Remove curl easy handles from multi list 
@@ -246 +246 @@
 CurlDownload::~CurlDownload()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     if (m_url)
@@ -263 +263 @@
         return;
 
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     m_curlHandle = curl_easy_init();
@@ -296 +296 @@
         return;
 
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     URL url(ParsedURLString, request.url());
@@ -318 +318 @@
 String CurlDownload::getTempPath() const
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     return m_tempPath;
 }
@@ -324 +324 @@
 String CurlDownload::getUrl() const
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     return String(m_url);
 }
@@ -330 +330 @@
 ResourceResponse CurlDownload::getResponse() const
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
     return m_response;
 }
@@ -336 +336 @@
 void CurlDownload::closeFile()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     if (m_tempHandle != invalidPlatformFileHandle) {
@@ -391 +391 @@
 void CurlDownload::didReceiveHeader(const String& header)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     if (header == "\r\n" || header == "\n") {
@@ -431 +431 @@
 void CurlDownload::didReceiveData(void* data, int size)
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     RefPtr<CurlDownload> protectedDownload(this);
@@ -465 +465 @@
 void CurlDownload::didFail()
 {
-    MutexLocker locker(m_mutex);
+    DeprecatedMutexLocker locker(m_mutex);
 
     closeFile();

trunk/Source/WebCore/platform/network/curl/CurlDownload.h

@@ -74 +74 @@
     Vector<CURL*> m_activeHandleList;
     Vector<CURL*> m_removedHandleList;
-    mutable Mutex m_mutex;
+    mutable DeprecatedMutex m_mutex;
     bool m_runThread;
 };
@@ -141 +141 @@
     WebCore::ResourceResponse m_response;
     bool m_deletesFileUponFailure;
-    mutable Mutex m_mutex;
+    mutable DeprecatedMutex m_mutex;
     CurlDownloadListener *m_listener;
 

trunk/Source/WebCore/platform/network/curl/ResourceHandleManager.cpp

@@ -134 +134 @@
 }
 
-static Mutex* sharedResourceMutex(curl_lock_data data) {
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, cookieMutex, ());
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, dnsMutex, ());
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, shareMutex, ());
+static DeprecatedMutex* sharedResourceMutex(curl_lock_data data)
+{
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, cookieMutex, ());
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, dnsMutex, ());
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, shareMutex, ());
 
     switch (data) {
@@ -191 +192 @@
 static void curl_lock_callback(CURL* /* handle */, curl_lock_data data, curl_lock_access /* access */, void* /* userPtr */)
 {
-    if (Mutex* mutex = sharedResourceMutex(data))
+    if (DeprecatedMutex* mutex = sharedResourceMutex(data))
         mutex->lock();
 }
@@ -197 +198 @@
 static void curl_unlock_callback(CURL* /* handle */, curl_lock_data data, void* /* userPtr */)
 {
-    if (Mutex* mutex = sharedResourceMutex(data))
+    if (DeprecatedMutex* mutex = sharedResourceMutex(data))
         mutex->unlock();
 }

trunk/Source/WebCore/platform/network/ios/QuickLook.mm

@@ -86 +86 @@
 }
 
-static Mutex& qlPreviewConverterDictionaryMutex()
-{
-    static NeverDestroyed<Mutex> mutex;
+static DeprecatedMutex& qlPreviewConverterDictionaryMutex()
+{
+    static NeverDestroyed<DeprecatedMutex> mutex;
     return mutex;
 }
@@ -108 +108 @@
     ASSERT(url);
     ASSERT(converter);
-    MutexLocker lock(qlPreviewConverterDictionaryMutex());
+    DeprecatedMutexLocker lock(qlPreviewConverterDictionaryMutex());
     [QLPreviewConverterDictionary() setObject:converter forKey:url];
     [QLContentDictionary() setObject:(fileName ? fileName : @"") forKey:url];
@@ -122 +122 @@
     id converter = nil;
     {
-        MutexLocker lock(qlPreviewConverterDictionaryMutex());
+        DeprecatedMutexLocker lock(qlPreviewConverterDictionaryMutex());
         converter = [QLPreviewConverterDictionary() objectForKey:url];
     }
@@ -132 +132 @@
 void WebCore::removeQLPreviewConverterForURL(NSURL *url)
 {
-    MutexLocker lock(qlPreviewConverterDictionaryMutex());
+    DeprecatedMutexLocker lock(qlPreviewConverterDictionaryMutex());
     [QLPreviewConverterDictionary() removeObjectForKey:url];
 
@@ -167 +167 @@
     NSURL *nsDocumentURL = documentURL;
     {
-        MutexLocker lock(qlPreviewConverterDictionaryMutex());
+        DeprecatedMutexLocker lock(qlPreviewConverterDictionaryMutex());
         converter = [QLPreviewConverterDictionary() objectForKey:nsDocumentURL];
     }

trunk/Source/WebCore/platform/sql/SQLiteDatabase.cpp

@@ -122 +122 @@
         sqlite3* db = m_db;
         {
-            MutexLocker locker(m_databaseClosingMutex);
+            DeprecatedMutexLocker locker(m_databaseClosingMutex);
             m_db = 0;
         }
@@ -153 +153 @@
     m_interrupted = true;
     while (!m_lockingMutex.tryLock()) {
-        MutexLocker locker(m_databaseClosingMutex);
+        DeprecatedMutexLocker locker(m_databaseClosingMutex);
         if (!m_db)
             return;
@@ -182 +182 @@
 
     {
-        MutexLocker locker(m_authorizerLock);
+        DeprecatedMutexLocker locker(m_authorizerLock);
         enableAuthorizer(false);
         SQLiteStatement statement(*this, ASCIILiteral("PRAGMA max_page_count"));
@@ -202 +202 @@
     int64_t newMaxPageCount = currentPageSize ? size / currentPageSize : 0;
     
-    MutexLocker locker(m_authorizerLock);
+    DeprecatedMutexLocker locker(m_authorizerLock);
     enableAuthorizer(false);
 
@@ -219 +219 @@
     // we can cache the value for future use
     if (m_pageSize == -1) {
-        MutexLocker locker(m_authorizerLock);
+        DeprecatedMutexLocker locker(m_authorizerLock);
         enableAuthorizer(false);
         
@@ -236 +236 @@
 
     {
-        MutexLocker locker(m_authorizerLock);
+        DeprecatedMutexLocker locker(m_authorizerLock);
         enableAuthorizer(false);
         // Note: freelist_count was added in SQLite 3.4.1.
@@ -252 +252 @@
 
     {
-        MutexLocker locker(m_authorizerLock);
+        DeprecatedMutexLocker locker(m_authorizerLock);
         enableAuthorizer(false);
         SQLiteStatement statement(*this, ASCIILiteral("PRAGMA page_count"));
@@ -331 +331 @@
 int SQLiteDatabase::runIncrementalVacuumCommand()
 {
-    MutexLocker locker(m_authorizerLock);
+    DeprecatedMutexLocker locker(m_authorizerLock);
     enableAuthorizer(false);
 
@@ -472 +472 @@
     }
 
-    MutexLocker locker(m_authorizerLock);
+    DeprecatedMutexLocker locker(m_authorizerLock);
 
     m_authorizer = auth;

trunk/Source/WebCore/platform/sql/SQLiteDatabase.h

@@ -109 +109 @@
     void setAuthorizer(PassRefPtr<DatabaseAuthorizer>);
 
-    Mutex& databaseMutex() { return m_lockingMutex; }
+    DeprecatedMutex& databaseMutex() { return m_lockingMutex; }
     bool isAutoCommitOn() const;
 
@@ -150 +150 @@
     bool m_sharable;
     
-    Mutex m_authorizerLock;
+    DeprecatedMutex m_authorizerLock;
     RefPtr<DatabaseAuthorizer> m_authorizer;
 
-    Mutex m_lockingMutex;
+    DeprecatedMutex m_lockingMutex;
     ThreadIdentifier m_openingThread;
 
-    Mutex m_databaseClosingMutex;
+    DeprecatedMutex m_databaseClosingMutex;
     bool m_interrupted;
 

trunk/Source/WebCore/platform/sql/SQLiteStatement.cpp

@@ -60 +60 @@
     ASSERT(!m_isPrepared);
 
-    MutexLocker databaseLock(m_database.databaseMutex());
+    DeprecatedMutexLocker databaseLock(m_database.databaseMutex());
     if (m_database.isInterrupted())
         return SQLITE_INTERRUPT;
@@ -89 +89 @@
 int SQLiteStatement::step()
 {
-    MutexLocker databaseLock(m_database.databaseMutex());
+    DeprecatedMutexLocker databaseLock(m_database.databaseMutex());
     if (m_database.isInterrupted())
         return SQLITE_INTERRUPT;

trunk/Source/WebCore/workers/WorkerThread.cpp

@@ -123 +123 @@
 {
     // Mutex protection is necessary to ensure that m_threadID is initialized when the thread starts.
-    MutexLocker lock(m_threadCreationMutex);
+    DeprecatedMutexLocker lock(m_threadCreationMutex);
 
     if (m_threadID)
@@ -146 +146 @@
 
     {
-        MutexLocker lock(m_threadCreationMutex);
+        DeprecatedMutexLocker lock(m_threadCreationMutex);
         m_workerGlobalScope = createWorkerGlobalScope(m_startupData->m_scriptURL, m_startupData->m_userAgent, m_startupData->m_contentSecurityPolicy, m_startupData->m_contentSecurityPolicyType, m_startupData->m_topOrigin.release());
 
@@ -190 +190 @@
 {
     // Mutex protection is necessary because stop() can be called before the context is fully created.
-    MutexLocker lock(m_threadCreationMutex);
+    DeprecatedMutexLocker lock(m_threadCreationMutex);
 
     // Ensure that tasks are being handled by thread event loop. If script execution weren't forbidden, a while(1) loop in JS could keep the thread alive forever.

trunk/Source/WebCore/workers/WorkerThread.h

@@ -90 +90 @@
 
         RefPtr<WorkerGlobalScope> m_workerGlobalScope;
-        Mutex m_threadCreationMutex;
+        DeprecatedMutex m_threadCreationMutex;
 
         std::unique_ptr<WorkerThreadStartupData> m_startupData;

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        * Storage/StorageAreaSync.cpp:
+        (WebCore::StorageAreaSync::syncTimerFired):
+        (WebCore::StorageAreaSync::markImported):
+        (WebCore::StorageAreaSync::blockUntilImportComplete):
+        (WebCore::StorageAreaSync::performSync):
+        * Storage/StorageAreaSync.h:
+        * Storage/StorageTracker.cpp:
+        (WebCore::StorageTracker::setDatabaseDirectoryPath):
+        (WebCore::StorageTracker::finishedImportingOriginIdentifiers):
+        (WebCore::StorageTracker::syncImportOriginIdentifiers):
+        (WebCore::StorageTracker::syncFileSystemAndTrackerDatabase):
+        (WebCore::StorageTracker::setOriginDetails):
+        (WebCore::StorageTracker::syncSetOriginDetails):
+        (WebCore::StorageTracker::origins):
+        (WebCore::StorageTracker::deleteAllOrigins):
+        (WebCore::StorageTracker::syncDeleteAllOrigins):
+        (WebCore::StorageTracker::deleteOrigin):
+        (WebCore::StorageTracker::syncDeleteOrigin):
+        (WebCore::StorageTracker::canDeleteOrigin):
+        (WebCore::StorageTracker::cancelDeletingOrigin):
+        (WebCore::StorageTracker::diskUsageForOrigin):
+        * Storage/StorageTracker.h:
+
 2015-08-04  Alex Christensen  <[email protected]>
 

trunk/Source/WebKit/Storage/StorageAreaSync.cpp

@@ -165 +165 @@
     bool partialSync = false;
     {
-        MutexLocker locker(m_syncLock);
+        DeprecatedMutexLocker locker(m_syncLock);
 
         // Do not schedule another sync if we're still trying to complete the
@@ -353 +353 @@
 void StorageAreaSync::markImported()
 {
-    MutexLocker locker(m_importLock);
+    DeprecatedMutexLocker locker(m_importLock);
     m_importComplete = true;
     m_importCondition.signal();
@@ -373 +373 @@
         return;
 
-    MutexLocker locker(m_importLock);
+    DeprecatedMutexLocker locker(m_importLock);
     while (!m_importComplete)
         m_importCondition.wait(m_importLock);
@@ -468 +468 @@
     HashMap<String, String> items;
     {
-        MutexLocker locker(m_syncLock);
+        DeprecatedMutexLocker locker(m_syncLock);
 
         ASSERT(m_syncScheduled);
@@ -483 +483 @@
 
     {
-        MutexLocker locker(m_syncLock);
+        DeprecatedMutexLocker locker(m_syncLock);
         m_syncInProgress = false;
     }

trunk/Source/WebKit/Storage/StorageAreaSync.h

@@ -86 +86 @@
     const String m_databaseIdentifier;
 
-    Mutex m_syncLock;
+    DeprecatedMutex m_syncLock;
     HashMap<String, String> m_itemsPendingSync;
     bool m_clearItemsWhileSyncing;
@@ -95 +95 @@
     bool m_syncCloseDatabase;
 
-    mutable Mutex m_importLock;
+    mutable DeprecatedMutex m_importLock;
     ThreadCondition m_importCondition;
     bool m_importComplete;

trunk/Source/WebKit/Storage/StorageTracker.cpp

@@ -101 +101 @@
 void StorageTracker::setDatabaseDirectoryPath(const String& path)
 {
-    MutexLocker locker(m_databaseMutex);
+    DeprecatedMutexLocker locker(m_databaseMutex);
 
     if (m_database.isOpen())
@@ -109 +109 @@
 
     {
-        MutexLocker locker(m_originSetMutex);
+        DeprecatedMutexLocker locker(m_originSetMutex);
         m_originSet.clear();
     }
@@ -186 +186 @@
 void StorageTracker::finishedImportingOriginIdentifiers()
 {
-    MutexLocker locker(m_databaseMutex);
+    DeprecatedMutexLocker locker(m_databaseMutex);
     if (m_client)
         m_client->didFinishLoadingOrigins();
@@ -198 +198 @@
 
     {
-        MutexLocker locker(m_databaseMutex);
+        DeprecatedMutexLocker locker(m_databaseMutex);
 
         // Don't force creation of StorageTracker's db just because a tracker
@@ -218 +218 @@
             
             {
-                MutexLocker lockOrigins(m_originSetMutex);
+                DeprecatedMutexLocker lockOrigins(m_originSetMutex);
                 while ((result = statement.step()) == SQLITE_ROW)
                     m_originSet.add(statement.getColumnText(0).isolatedCopy());
@@ -233 +233 @@
     
     {
-        MutexLocker locker(m_clientMutex);
+        DeprecatedMutexLocker locker(m_clientMutex);
 
         if (m_client) {
-            MutexLocker locker(m_originSetMutex);
+            DeprecatedMutexLocker locker(m_originSetMutex);
             OriginSet::const_iterator end = m_originSet.end();
             for (OriginSet::const_iterator it = m_originSet.begin(); it != end; ++it)
@@ -258 +258 @@
     Vector<String> paths;
     {
-        MutexLocker locker(m_databaseMutex);
+        DeprecatedMutexLocker locker(m_databaseMutex);
         paths = listDirectory(m_storageDirectoryPath, "*.localstorage");
     }
@@ -266 +266 @@
     OriginSet originSetCopy;
     {
-        MutexLocker locker(m_originSetMutex);
+        DeprecatedMutexLocker locker(m_originSetMutex);
         for (OriginSet::const_iterator it = m_originSet.begin(), end = m_originSet.end(); it != end; ++it)
             originSetCopy.add((*it).isolatedCopy());
@@ -307 +307 @@
 
     {
-        MutexLocker locker(m_originSetMutex);
+        DeprecatedMutexLocker locker(m_originSetMutex);
 
         if (m_originSet.contains(originIdentifier))
@@ -338 +338 @@
     SQLiteTransactionInProgressAutoCounter transactionCounter;
 
-    MutexLocker locker(m_databaseMutex);
+    DeprecatedMutexLocker locker(m_databaseMutex);
 
     openTrackerDatabase(true);
@@ -358 +358 @@
 
     {
-        MutexLocker locker(m_originSetMutex);
+        DeprecatedMutexLocker locker(m_originSetMutex);
         if (!m_originSet.contains(originIdentifier))
             m_originSet.add(originIdentifier);
@@ -364 +364 @@
 
     {
-        MutexLocker locker(m_clientMutex);
+        DeprecatedMutexLocker locker(m_clientMutex);
         if (m_client)
             m_client->dispatchDidModifyOrigin(originIdentifier);
@@ -377 +377 @@
         return;
 
-    MutexLocker locker(m_originSetMutex);
+    DeprecatedMutexLocker locker(m_originSetMutex);
 
     for (OriginSet::const_iterator it = m_originSet.begin(), end = m_originSet.end(); it != end; ++it)
@@ -393 +393 @@
 
     {
-        MutexLocker locker(m_originSetMutex);
+        DeprecatedMutexLocker locker(m_originSetMutex);
         willDeleteAllOrigins();
         m_originSet.clear();
@@ -418 +418 @@
     SQLiteTransactionInProgressAutoCounter transactionCounter;
     
-    MutexLocker locker(m_databaseMutex);
+    DeprecatedMutexLocker locker(m_databaseMutex);
     
     openTrackerDatabase(false);
@@ -438 +438 @@
 
         {
-            MutexLocker locker(m_clientMutex);
+            DeprecatedMutexLocker locker(m_clientMutex);
             if (m_client)
                 m_client->dispatchDidModifyOrigin(statement.getColumnText(0));
@@ -500 +500 @@
     
     {
-        MutexLocker locker(m_originSetMutex);
+        DeprecatedMutexLocker locker(m_originSetMutex);
         willDeleteOrigin(originId);
         m_originSet.remove(originId);
@@ -517 +517 @@
     SQLiteTransactionInProgressAutoCounter transactionCounter;
 
-    MutexLocker locker(m_databaseMutex);
+    DeprecatedMutexLocker locker(m_databaseMutex);
     
     if (!canDeleteOrigin(originIdentifier)) {
@@ -550 +550 @@
     bool shouldDeleteTrackerFiles = false;
     {
-        MutexLocker locker(m_originSetMutex);
+        DeprecatedMutexLocker locker(m_originSetMutex);
         m_originSet.remove(originIdentifier);
         shouldDeleteTrackerFiles = m_originSet.isEmpty();
@@ -567 +567 @@
 
     {
-        MutexLocker locker(m_clientMutex);
+        DeprecatedMutexLocker locker(m_clientMutex);
         if (m_client)
             m_client->dispatchDidModifyOrigin(originIdentifier);
@@ -593 +593 @@
 {
     ASSERT(!m_databaseMutex.tryLock());
-    MutexLocker locker(m_originSetMutex);
+    DeprecatedMutexLocker locker(m_originSetMutex);
     return m_originsBeingDeleted.contains(originIdentifier);
 }
@@ -602 +602 @@
         return;
 
-    MutexLocker locker(m_databaseMutex);
-    {
-        MutexLocker locker(m_originSetMutex);
+    DeprecatedMutexLocker locker(m_databaseMutex);
+    {
+        DeprecatedMutexLocker locker(m_originSetMutex);
         if (!m_originsBeingDeleted.isEmpty())
             m_originsBeingDeleted.remove(originIdentifier);
@@ -648 +648 @@
         return 0;
 
-    MutexLocker locker(m_databaseMutex);
+    DeprecatedMutexLocker locker(m_databaseMutex);
 
     String path = databasePathForOrigin(origin->databaseIdentifier());

trunk/Source/WebKit/Storage/StorageTracker.h

@@ -96 +96 @@
 
     // Mutex for m_database and m_storageDirectoryPath.
-    Mutex m_databaseMutex;
+    DeprecatedMutex m_databaseMutex;
     SQLiteDatabase m_database;
     String m_storageDirectoryPath;
 
-    Mutex m_clientMutex;
+    DeprecatedMutex m_clientMutex;
     StorageTrackerClient* m_client;
 
     // Guard for m_originSet and m_originsBeingDeleted.
-    Mutex m_originSetMutex;
+    DeprecatedMutex m_originSetMutex;
     typedef HashSet<String> OriginSet;
     OriginSet m_originSet;

trunk/Source/WebKit/ios/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        * WebCoreSupport/WebFixedPositionContent.mm:
+        (WebFixedPositionContentDataLock):
+        (-[WebFixedPositionContent scrollOrZoomChanged:]):
+        (-[WebFixedPositionContent overflowScrollPositionForLayer:changedTo:]):
+        (-[WebFixedPositionContent setViewportConstrainedLayers:stickyContainerMap:]):
+        (-[WebFixedPositionContent hasFixedOrStickyPositionLayers]):
+        (-[WebFixedPositionContent minimumOffsetFromFixedPositionLayersToAnchorEdge:ofRect:inLayer:]):
+
 2015-08-04  Anders Carlsson  <[email protected]>
 

trunk/Source/WebKit/ios/WebCoreSupport/WebFixedPositionContent.mm

@@ -49 +49 @@
 using namespace std;
 
-static Mutex& WebFixedPositionContentDataLock()
-{
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, mutex, ());
+static DeprecatedMutex& WebFixedPositionContentDataLock()
+{
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, mutex, ());
     return mutex;
 }
@@ -102 +102 @@
 - (void)scrollOrZoomChanged:(CGRect)positionedObjectsRect
 {
-    MutexLocker lock(WebFixedPositionContentDataLock());
+    DeprecatedMutexLocker lock(WebFixedPositionContentDataLock());
 
     LayerInfoMap::const_iterator end = _private->m_viewportConstrainedLayers.end();
@@ -141 +141 @@
 - (void)overflowScrollPositionForLayer:(CALayer *)scrollLayer changedTo:(CGPoint)scrollPosition
 {
-    MutexLocker lock(WebFixedPositionContentDataLock());
+    DeprecatedMutexLocker lock(WebFixedPositionContentDataLock());
 
     LayerInfoMap::const_iterator end = _private->m_viewportConstrainedLayers.end();
@@ -174 +174 @@
 - (void)setViewportConstrainedLayers:(WTF::HashMap<CALayer *, std::unique_ptr<WebCore::ViewportConstraints>>&)layerMap stickyContainerMap:(WTF::HashMap<CALayer*, CALayer*>&)stickyContainers
 {
-    MutexLocker lock(WebFixedPositionContentDataLock());
+    DeprecatedMutexLocker lock(WebFixedPositionContentDataLock());
 
     _private->m_viewportConstrainedLayers.clear();
@@ -191 +191 @@
 - (BOOL)hasFixedOrStickyPositionLayers
 {
-    MutexLocker lock(WebFixedPositionContentDataLock());
+    DeprecatedMutexLocker lock(WebFixedPositionContentDataLock());
     return !_private->m_viewportConstrainedLayers.isEmpty();
 }
@@ -211 +211 @@
 - (CGFloat)minimumOffsetFromFixedPositionLayersToAnchorEdge:(WebFixedPositionAnchorEdge)anchorEdge ofRect:(CGRect)rect inLayer:(CALayer *)layer
 {
-    MutexLocker lock(WebFixedPositionContentDataLock());
+    DeprecatedMutexLocker lock(WebFixedPositionContentDataLock());
     ViewportConstraints::AnchorEdgeFlags anchorEdgeFlags = anchorEdgeFlagsForAnchorEdge(anchorEdge);
     CGFloat minimumOffset = CGFLOAT_MAX;

trunk/Source/WebKit/mac/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        * Storage/WebDatabaseManager.mm:
+        (transactionBackgroundTaskIdentifierLock):
+        (+[WebDatabaseManager startBackgroundTask]):
+        (+[WebDatabaseManager endBackgroundTask]):
+        * WebView/WebView.mm:
+        (-[WebView _synchronizeCustomFixedPositionLayoutRect]):
+        (-[WebView _setCustomFixedPositionLayoutRectInWebThread:synchronize:]):
+        (-[WebView _setCustomFixedPositionLayoutRect:]):
+        (-[WebView _fetchCustomFixedPositionLayoutRect:]):
+        * WebView/WebViewData.h:
+
 2015-08-04  Anders Carlsson  <[email protected]>
 

trunk/Source/WebKit/mac/Storage/WebDatabaseManager.mm

@@ -227 +227 @@
 @implementation WebDatabaseManager (WebDatabaseManagerInternal)
 
-static Mutex& transactionBackgroundTaskIdentifierLock()
-{
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, mutex, ());
+static DeprecatedMutex& transactionBackgroundTaskIdentifierLock()
+{
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, mutex, ());
     return mutex;
 }
@@ -262 +262 @@
 + (void)startBackgroundTask
 {
-    MutexLocker lock(transactionBackgroundTaskIdentifierLock());
+    DeprecatedMutexLocker lock(transactionBackgroundTaskIdentifierLock());
 
     // If there's already an existing background task going on, there's no need to start a new one.
@@ -276 +276 @@
 + (void)endBackgroundTask
 {
-    MutexLocker lock(transactionBackgroundTaskIdentifierLock());
+    DeprecatedMutexLocker lock(transactionBackgroundTaskIdentifierLock());
 
     // It is possible that we were unable to start the background task when the first transaction began.

trunk/Source/WebKit/mac/WebView/WebView.mm

@@ -3633 +3633 @@
     IntRect newRect;
     {
-        MutexLocker locker(_private->pendingFixedPositionLayoutRectMutex);
+        DeprecatedMutexLocker locker(_private->pendingFixedPositionLayoutRectMutex);
         if (CGRectIsNull(_private->pendingFixedPositionLayoutRect))
             return;
@@ -3647 +3647 @@
 {
     {
-        MutexLocker locker(_private->pendingFixedPositionLayoutRectMutex);
+        DeprecatedMutexLocker locker(_private->pendingFixedPositionLayoutRectMutex);
         _private->pendingFixedPositionLayoutRect = rect;
     }
@@ -3661 +3661 @@
     ASSERT(WebThreadIsLocked());
     {
-        MutexLocker locker(_private->pendingFixedPositionLayoutRectMutex);
+        DeprecatedMutexLocker locker(_private->pendingFixedPositionLayoutRectMutex);
         _private->pendingFixedPositionLayoutRect = rect;
     }
@@ -3669 +3669 @@
 - (BOOL)_fetchCustomFixedPositionLayoutRect:(NSRect*)rect
 {
-    MutexLocker locker(_private->pendingFixedPositionLayoutRectMutex);
+    DeprecatedMutexLocker locker(_private->pendingFixedPositionLayoutRectMutex);
     if (CGRectIsNull(_private->pendingFixedPositionLayoutRect))
         return false;

trunk/Source/WebKit/mac/WebView/WebViewData.h

@@ -250 +250 @@
     BOOL mainViewIsScrollingOrZooming;
     int32_t didDrawTiles;
-    WTF::Mutex pendingFixedPositionLayoutRectMutex;
+    WTF::DeprecatedMutex pendingFixedPositionLayoutRectMutex;
     CGRect pendingFixedPositionLayoutRect;
 #endif

trunk/Source/WebKit/win/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        * Plugins/PluginMainThreadScheduler.cpp:
+        (WebCore::PluginMainThreadScheduler::scheduleCall):
+        (WebCore::PluginMainThreadScheduler::registerPlugin):
+        (WebCore::PluginMainThreadScheduler::unregisterPlugin):
+        (WebCore::PluginMainThreadScheduler::dispatchCallsForPlugin):
+        * Plugins/PluginMainThreadScheduler.h:
+        * WebIconDatabase.cpp:
+        (WebIconDatabase::didRemoveAllIcons):
+        (WebIconDatabase::didImportIconURLForPageURL):
+        (WebIconDatabase::deliverNotifications):
+        * WebLocalizableStrings.cpp:
+        (mainBundleLocStrings):
+        (frameworkLocStringsMutex):
+        (findCachedString):
+        (cacheString):
+
 2015-08-04  Brent Fulgham  <[email protected]>
 

trunk/Source/WebKit/win/Plugins/PluginMainThreadScheduler.cpp

@@ -43 +43 @@
 void PluginMainThreadScheduler::scheduleCall(NPP npp, MainThreadFunction function, void* userData)
 {
-    MutexLocker lock(m_queueMutex);
+    DeprecatedMutexLocker lock(m_queueMutex);
 
     CallQueueMap::iterator it = m_callQueueMap.find(npp);
@@ -59 +59 @@
 void PluginMainThreadScheduler::registerPlugin(NPP npp)
 {
-    MutexLocker lock(m_queueMutex);
+    DeprecatedMutexLocker lock(m_queueMutex);
 
     ASSERT(!m_callQueueMap.contains(npp));
@@ -67 +67 @@
 void PluginMainThreadScheduler::unregisterPlugin(NPP npp)
 {
-    MutexLocker lock(m_queueMutex);
+    DeprecatedMutexLocker lock(m_queueMutex);
 
     ASSERT(m_callQueueMap.contains(npp));
@@ -78 +78 @@
         // Check if the plug-in has been destroyed.
         {
-            MutexLocker lock(m_queueMutex);
+            DeprecatedMutexLocker lock(m_queueMutex);
             if (!m_callQueueMap.contains(npp))
                 return;

trunk/Source/WebKit/win/Plugins/PluginMainThreadScheduler.h

@@ -80 +80 @@
     bool m_callPending;
     CallQueueMap m_callQueueMap;
-    Mutex m_queueMutex;
+    DeprecatedMutex m_queueMutex;
 };
 

trunk/Source/WebKit/win/WebIconDatabase.cpp

@@ -321 +321 @@
 {
     // Queueing the empty string is a special way of saying "this queued notification is the didRemoveAllIcons notification"
-    MutexLocker locker(m_notificationMutex);
+    DeprecatedMutexLocker locker(m_notificationMutex);
     m_notificationQueue.append(String());
     scheduleNotificationDelivery();
@@ -328 +328 @@
 void WebIconDatabase::didImportIconURLForPageURL(const WTF::String& pageURL)
 {
-    MutexLocker locker(m_notificationMutex);
+    DeprecatedMutexLocker locker(m_notificationMutex);
     m_notificationQueue.append(pageURL.isolatedCopy());
     scheduleNotificationDelivery();
@@ -404 +404 @@
     Vector<String> queue;
     {
-        MutexLocker locker(m_sharedWebIconDatabase->m_notificationMutex);
+        DeprecatedMutexLocker locker(m_sharedWebIconDatabase->m_notificationMutex);
         queue.swap(m_sharedWebIconDatabase->m_notificationQueue);
         m_sharedWebIconDatabase->m_deliveryRequested = false;

trunk/Source/WebKit/win/WebLocalizableStrings.cpp

@@ -45 +45 @@
 typedef HashMap<String, LocalizedString*> LocalizedStringMap;
 
-static Mutex& mainBundleLocStringsMutex()
-{
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, mutex, ());
+static DeprecatedMutex& mainBundleLocStringsMutex()
+{
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, mutex, ());
     return mutex;
 }
@@ -57 +57 @@
 }
 
-static Mutex& frameworkLocStringsMutex()
-{
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, mutex, ());
+static DeprecatedMutex& frameworkLocStringsMutex()
+{
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, mutex, ());
     return mutex;
 }
@@ -176 +176 @@
 {
     if (!stringsBundle) {
-        MutexLocker lock(mainBundleLocStringsMutex());
+        DeprecatedMutexLocker lock(mainBundleLocStringsMutex());
         return mainBundleLocStrings().get(key);
     }
 
     if (stringsBundle->bundle == WebKitLocalizableStringsBundle.bundle) {
-        MutexLocker lock(frameworkLocStringsMutex());
+        DeprecatedMutexLocker lock(frameworkLocStringsMutex());
         return frameworkLocStrings().get(key);
     }
@@ -191 +191 @@
 {
     if (!stringsBundle) {
-        MutexLocker lock(mainBundleLocStringsMutex());
+        DeprecatedMutexLocker lock(mainBundleLocStringsMutex());
         mainBundleLocStrings().set(key, value);
         return;
     }
 
-    MutexLocker lock(frameworkLocStringsMutex());
+    DeprecatedMutexLocker lock(frameworkLocStringsMutex());
     frameworkLocStrings().set(key, value);
 }

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        * DatabaseProcess/DatabaseProcess.cpp:
+        (WebKit::DatabaseProcess::postDatabaseTask):
+        (WebKit::DatabaseProcess::performNextDatabaseTask):
+        * DatabaseProcess/DatabaseProcess.h:
+        * DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp:
+        (WebKit::UniqueIDBDatabase::shutdown):
+        (WebKit::UniqueIDBDatabase::postMainThreadTask):
+        (WebKit::UniqueIDBDatabase::performNextMainThreadTask):
+        (WebKit::UniqueIDBDatabase::postDatabaseTask):
+        (WebKit::UniqueIDBDatabase::performNextDatabaseTask):
+        * DatabaseProcess/IndexedDB/UniqueIDBDatabase.h:
+        * Platform/IPC/Connection.cpp:
+        (IPC::Connection::sendSyncMessage):
+        (IPC::Connection::sendSyncMessageFromSecondaryThread):
+        (IPC::Connection::waitForSyncReply):
+        (IPC::Connection::processIncomingSyncReply):
+        (IPC::Connection::connectionDidClose):
+        * Platform/IPC/Connection.h:
+        * Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp:
+        (WebKit::CoordinatedGraphicsScene::appendUpdate):
+        * Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h:
+        * Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.cpp:
+        (WebKit::ThreadedCompositor::createCompositingThread):
+        (WebKit::ThreadedCompositor::runCompositingThread):
+        (WebKit::ThreadedCompositor::terminateCompositingThread):
+        * Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.h:
+        * Shared/Network/CustomProtocols/Cocoa/CustomProtocolManagerCocoa.mm:
+        (WebKit::CustomProtocolManager::addCustomProtocol):
+        (WebKit::CustomProtocolManager::removeCustomProtocol):
+        (WebKit::CustomProtocolManager::registerScheme):
+        (WebKit::CustomProtocolManager::unregisterScheme):
+        (WebKit::CustomProtocolManager::supportsScheme):
+        (WebKit::CustomProtocolManager::protocolForID):
+        * Shared/Network/CustomProtocols/CustomProtocolManager.h:
+        * Shared/linux/SeccompFilters/SeccompBroker.cpp:
+        * WebProcess/Plugins/PluginProcessConnectionManager.cpp:
+        (WebKit::PluginProcessConnectionManager::getPluginProcessConnection):
+        (WebKit::PluginProcessConnectionManager::removePluginProcessConnection):
+        (WebKit::PluginProcessConnectionManager::pluginProcessCrashed):
+        * WebProcess/Plugins/PluginProcessConnectionManager.h:
+        * WebProcess/WebPage/EventDispatcher.cpp:
+        (WebKit::EventDispatcher::addScrollingTreeForPage):
+        (WebKit::EventDispatcher::removeScrollingTreeForPage):
+        (WebKit::EventDispatcher::wheelEvent):
+        * WebProcess/WebPage/EventDispatcher.h:
+        * WebProcess/soup/WebKitSoupRequestInputStream.cpp:
+        (webkitSoupRequestInputStreamReadAsync):
+        (webkitSoupRequestInputStreamAddData):
+
 2015-08-05  Daniel Bates  <[email protected]>
 

trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp

@@ -152 +152 @@
     ASSERT(RunLoop::isMain());
 
-    MutexLocker locker(m_databaseTaskMutex);
+    DeprecatedMutexLocker locker(m_databaseTaskMutex);
 
     m_databaseTasks.append(WTF::move(task));
@@ -167 +167 @@
     std::unique_ptr<AsyncTask> task;
     {
-        MutexLocker locker(m_databaseTaskMutex);
+        DeprecatedMutexLocker locker(m_databaseTaskMutex);
         ASSERT(!m_databaseTasks.isEmpty());
         task = m_databaseTasks.takeFirst();

trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.h

@@ -107 +107 @@
 
     Deque<std::unique_ptr<AsyncTask>> m_databaseTasks;
-    Mutex m_databaseTaskMutex;
+    DeprecatedMutex m_databaseTaskMutex;
 };
 

trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp

@@ -137 +137 @@
 
     {
-        MutexLocker locker(m_databaseTaskMutex);
+        DeprecatedMutexLocker locker(m_databaseTaskMutex);
         m_databaseTasks.clear();
     }
@@ -1126 +1126 @@
         return;
 
-    MutexLocker locker(m_mainThreadTaskMutex);
+    DeprecatedMutexLocker locker(m_mainThreadTaskMutex);
 
     m_mainThreadTasks.append(WTF::move(task));
@@ -1144 +1144 @@
     std::unique_ptr<AsyncTask> task;
     {
-        MutexLocker locker(m_mainThreadTaskMutex);
+        DeprecatedMutexLocker locker(m_mainThreadTaskMutex);
 
         // This database might be shutting down, in which case the task queue might be empty.
@@ -1166 +1166 @@
         return;
 
-    MutexLocker locker(m_databaseTaskMutex);
+    DeprecatedMutexLocker locker(m_databaseTaskMutex);
 
     m_databaseTasks.append(WTF::move(task));
@@ -1187 +1187 @@
     std::unique_ptr<AsyncTask> task;
     {
-        MutexLocker locker(m_databaseTaskMutex);
+        DeprecatedMutexLocker locker(m_databaseTaskMutex);
 
         // This database might be shutting down on the main thread, in which case the task queue might be empty.

trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h

@@ -211 +211 @@
 
     Deque<std::unique_ptr<AsyncTask>> m_databaseTasks;
-    Mutex m_databaseTaskMutex;
+    DeprecatedMutex m_databaseTaskMutex;
 
     Deque<std::unique_ptr<AsyncTask>> m_mainThreadTasks;
-    Mutex m_mainThreadTaskMutex;
+    DeprecatedMutex m_mainThreadTaskMutex;
 };
 

trunk/Source/WebKit2/Platform/IPC/Connection.cpp

@@ -460 +460 @@
     // Push the pending sync reply information on our stack.
     {
-        MutexLocker locker(m_syncReplyStateMutex);
+        DeprecatedMutexLocker locker(m_syncReplyStateMutex);
         if (!m_shouldWaitForSyncReplies) {
             didFailToSendSyncMessage();
@@ -487 +487 @@
     // Finally, pop the pending sync reply information.
     {
-        MutexLocker locker(m_syncReplyStateMutex);
+        DeprecatedMutexLocker locker(m_syncReplyStateMutex);
         ASSERT(m_pendingSyncReplies.last().syncRequestID == syncRequestID);
         m_pendingSyncReplies.removeLast();
@@ -509 +509 @@
     // Push the pending sync reply information on our stack.
     {
-        MutexLocker locker(m_syncReplyStateMutex);
+        DeprecatedMutexLocker locker(m_syncReplyStateMutex);
         if (!m_shouldWaitForSyncReplies)
             return nullptr;
@@ -527 +527 @@
     // Finally, pop the pending sync reply information.
     {
-        MutexLocker locker(m_syncReplyStateMutex);
+        DeprecatedMutexLocker locker(m_syncReplyStateMutex);
         ASSERT(m_secondaryThreadPendingSyncReplyMap.contains(syncRequestID));
         m_secondaryThreadPendingSyncReplyMap.remove(syncRequestID);
@@ -547 +547 @@
         
         {
-            MutexLocker locker(m_syncReplyStateMutex);
+            DeprecatedMutexLocker locker(m_syncReplyStateMutex);
 
             // Second, check if there is a sync reply at the top of the stack.
@@ -593 +593 @@
 void Connection::processIncomingSyncReply(std::unique_ptr<MessageDecoder> decoder)
 {
-    MutexLocker locker(m_syncReplyStateMutex);
+    DeprecatedMutexLocker locker(m_syncReplyStateMutex);
 
     // Go through the stack of sync requests that have pending replies and see which one
@@ -751 +751 @@
 
     {
-        MutexLocker locker(m_syncReplyStateMutex);
+        DeprecatedMutexLocker locker(m_syncReplyStateMutex);
 
         ASSERT(m_shouldWaitForSyncReplies);

trunk/Source/WebKit2/Platform/IPC/Connection.h

@@ -299 +299 @@
     friend class SyncMessageState;
 
-    Mutex m_syncReplyStateMutex;
+    DeprecatedMutex m_syncReplyStateMutex;
     bool m_shouldWaitForSyncReplies;
     Vector<PendingSyncReply> m_pendingSyncReplies;

trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp

@@ -691 +691 @@
 
     ASSERT(isMainThread());
-    MutexLocker locker(m_renderQueueMutex);
+    DeprecatedMutexLocker locker(m_renderQueueMutex);
     m_renderQueue.append(WTF::move(function));
 }

trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h

@@ -146 +146 @@
     // Render queue can be accessed ony from main thread or updatePaintNode call stack!
     Vector<std::function<void()>> m_renderQueue;
-    Mutex m_renderQueueMutex;
+    DeprecatedMutex m_renderQueueMutex;
 
     std::unique_ptr<WebCore::TextureMapper> m_textureMapper;

trunk/Source/WebKit2/Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.cpp

@@ -296 +296 @@
         return;
 
-    MutexLocker locker(m_initializeRunLoopConditionMutex);
+    DeprecatedMutexLocker locker(m_initializeRunLoopConditionMutex);
     m_threadIdentifier = createThread(compositingThreadEntry, this, "WebCore: ThreadedCompositor");
 
@@ -305 +305 @@
 {
     {
-        MutexLocker locker(m_initializeRunLoopConditionMutex);
+        DeprecatedMutexLocker locker(m_initializeRunLoopConditionMutex);
 
         m_compositingRunLoop = std::make_unique<CompositingRunLoop>([&] {
@@ -322 +322 @@
 
     {
-        MutexLocker locker(m_terminateRunLoopConditionMutex);
+        DeprecatedMutexLocker locker(m_terminateRunLoopConditionMutex);
         m_compositingRunLoop = nullptr;
         m_context = nullptr;
@@ -333 +333 @@
 void ThreadedCompositor::terminateCompositingThread()
 {
-    MutexLocker locker(m_terminateRunLoopConditionMutex);
+    DeprecatedMutexLocker locker(m_terminateRunLoopConditionMutex);
 
     m_scene->detach();

trunk/Source/WebKit2/Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.h

@@ -112 +112 @@
     ThreadIdentifier m_threadIdentifier;
     ThreadCondition m_initializeRunLoopCondition;
-    Mutex m_initializeRunLoopConditionMutex;
+    DeprecatedMutex m_initializeRunLoopConditionMutex;
     ThreadCondition m_terminateRunLoopCondition;
-    Mutex m_terminateRunLoopConditionMutex;
+    DeprecatedMutex m_terminateRunLoopConditionMutex;
 };
 

trunk/Source/WebKit2/Shared/Network/CustomProtocols/Cocoa/CustomProtocolManagerCocoa.mm

@@ -166 +166 @@
 {
     ASSERT(customProtocol);
-    MutexLocker locker(m_customProtocolMapMutex);
+    DeprecatedMutexLocker locker(m_customProtocolMapMutex);
     m_customProtocolMap.add(customProtocol.customProtocolID, customProtocol);
 }
@@ -173 +173 @@
 {
     ASSERT(customProtocol);
-    MutexLocker locker(m_customProtocolMapMutex);
+    DeprecatedMutexLocker locker(m_customProtocolMapMutex);
     m_customProtocolMap.remove(customProtocol.customProtocolID);
 }
@@ -180 +180 @@
 {
     ASSERT(!scheme.isNull());
-    MutexLocker locker(m_registeredSchemesMutex);
+    DeprecatedMutexLocker locker(m_registeredSchemesMutex);
     m_registeredSchemes.add(scheme);
 }
@@ -187 +187 @@
 {
     ASSERT(!scheme.isNull());
-    MutexLocker locker(m_registeredSchemesMutex);
+    DeprecatedMutexLocker locker(m_registeredSchemesMutex);
     m_registeredSchemes.remove(scheme);
 }
@@ -196 +196 @@
         return false;
 
-    MutexLocker locker(m_registeredSchemesMutex);
+    DeprecatedMutexLocker locker(m_registeredSchemesMutex);
     return m_registeredSchemes.contains(scheme);
 }
@@ -262 +262 @@
 RetainPtr<WKCustomProtocol> CustomProtocolManager::protocolForID(uint64_t customProtocolID)
 {
-    MutexLocker locker(m_customProtocolMapMutex);
+    DeprecatedMutexLocker locker(m_customProtocolMapMutex);
 
     CustomProtocolMap::const_iterator it = m_customProtocolMap.find(customProtocolID);

trunk/Source/WebKit2/Shared/Network/CustomProtocols/CustomProtocolManager.h

@@ -101 +101 @@
 #if PLATFORM(COCOA)
     HashSet<String> m_registeredSchemes;
-    Mutex m_registeredSchemesMutex;
+    DeprecatedMutex m_registeredSchemesMutex;
 
     typedef HashMap<uint64_t, RetainPtr<WKCustomProtocol>> CustomProtocolMap;
     CustomProtocolMap m_customProtocolMap;
-    Mutex m_customProtocolMapMutex;
+    DeprecatedMutex m_customProtocolMapMutex;
     
     // WKCustomProtocol objects can be removed from the m_customProtocolMap from multiple threads.

trunk/Source/WebKit2/Shared/linux/SeccompFilters/SeccompBroker.cpp

@@ -66 +66 @@
     int m_socket;
 
-    mutable Mutex m_socketLock;
+    mutable DeprecatedMutex m_socketLock;
 
     // Maps files that may be read by malloc() to open file descriptors.

trunk/Source/WebKit2/WebProcess/Plugins/PluginProcessConnectionManager.cpp

@@ -87 +87 @@
 
     {
-        MutexLocker locker(m_tokensAndConnectionsMutex);
+        DeprecatedMutexLocker locker(m_tokensAndConnectionsMutex);
         ASSERT(!m_tokensAndConnections.contains(pluginProcessToken));
 
@@ -102 +102 @@
 
     {
-        MutexLocker locker(m_tokensAndConnectionsMutex);
+        DeprecatedMutexLocker locker(m_tokensAndConnectionsMutex);
         ASSERT(m_tokensAndConnections.contains(pluginProcessConnection->pluginProcessToken()));
         
@@ -113 +113 @@
 void PluginProcessConnectionManager::pluginProcessCrashed(uint64_t pluginProcessToken)
 {
-    MutexLocker locker(m_tokensAndConnectionsMutex);
+    DeprecatedMutexLocker locker(m_tokensAndConnectionsMutex);
     IPC::Connection* connection = m_tokensAndConnections.get(pluginProcessToken);
 

trunk/Source/WebKit2/WebProcess/Plugins/PluginProcessConnectionManager.h

@@ -65 +65 @@
     Vector<RefPtr<PluginProcessConnection>> m_pluginProcessConnections;
 
-    Mutex m_tokensAndConnectionsMutex;
+    DeprecatedMutex m_tokensAndConnectionsMutex;
     HashMap<uint64_t, RefPtr<IPC::Connection>> m_tokensAndConnections;
 };

trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.cpp

@@ -66 +66 @@
 void EventDispatcher::addScrollingTreeForPage(WebPage* webPage)
 {
-    MutexLocker locker(m_scrollingTreesMutex);
+    DeprecatedMutexLocker locker(m_scrollingTreesMutex);
 
     ASSERT(webPage->corePage()->scrollingCoordinator());
@@ -77 +77 @@
 void EventDispatcher::removeScrollingTreeForPage(WebPage* webPage)
 {
-    MutexLocker locker(m_scrollingTreesMutex);
+    DeprecatedMutexLocker locker(m_scrollingTreesMutex);
     ASSERT(m_scrollingTrees.contains(webPage->pageID()));
 
@@ -133 +133 @@
 
 #if ENABLE(ASYNC_SCROLLING)
-    MutexLocker locker(m_scrollingTreesMutex);
+    DeprecatedMutexLocker locker(m_scrollingTreesMutex);
     if (RefPtr<ThreadedScrollingTree> scrollingTree = m_scrollingTrees.get(pageID)) {
         // FIXME: It's pretty horrible that we're updating the back/forward state here.

trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.h

@@ -93 +93 @@
 
 #if ENABLE(ASYNC_SCROLLING)
-    Mutex m_scrollingTreesMutex;
+    DeprecatedMutex m_scrollingTreesMutex;
     HashMap<uint64_t, RefPtr<WebCore::ThreadedScrollingTree>> m_scrollingTrees;
 #endif

trunk/Source/WebKit2/WebProcess/soup/WebKitSoupRequestInputStream.cpp

@@ -42 +42 @@
     uint64_t bytesRead;
 
-    Mutex readLock;
+    DeprecatedMutex readLock;
     std::unique_ptr<AsyncReadData> pendingAsyncRead;
 };
@@ -85 +85 @@
     GRefPtr<GTask> task = adoptGRef(g_task_new(stream, cancellable, callback, userData));
 
-    MutexLocker locker(stream->priv->readLock);
+    DeprecatedMutexLocker locker(stream->priv->readLock);
 
     if (!webkitSoupRequestInputStreamHasDataToRead(stream) && !webkitSoupRequestInputStreamIsWaitingForData(stream)) {
@@ -144 +144 @@
         return;
 
-    MutexLocker locker(stream->priv->readLock);
+    DeprecatedMutexLocker locker(stream->priv->readLock);
 
     if (dataLength) {

trunk/Tools/ChangeLog

@@ +1 @@
+2015-08-04  Filip Pizlo  <[email protected]>
+
+        Rename Mutex to DeprecatedMutex
+        https://bugs.webkit.org/show_bug.cgi?id=147675
+
+        Reviewed by Geoffrey Garen.
+
+        * DumpRenderTree/JavaScriptThreading.cpp:
+        (javaScriptThreadsMutex):
+        (runJavaScriptThread):
+        (startJavaScriptThreads):
+        (stopJavaScriptThreads):
+        * TestWebKitAPI/Tests/WTF/WorkQueue.cpp:
+        (TestWebKitAPI::TEST):
+        * TestWebKitAPI/Tests/WTF/glib/WorkQueueGLib.cpp:
+        (TestWebKitAPI::TEST):
+
 2015-08-05  Timothy Hatcher  <[email protected]>
 

trunk/Tools/DumpRenderTree/JavaScriptThreading.cpp

@@ -45 +45 @@
 static JSContextGroupRef javaScriptThreadsGroup;
 
-static Mutex& javaScriptThreadsMutex()
+static DeprecatedMutex& javaScriptThreadsMutex()
 {
-    DEPRECATED_DEFINE_STATIC_LOCAL(Mutex, staticMutex, ());
+    DEPRECATED_DEFINE_STATIC_LOCAL(DeprecatedMutex, staticMutex, ());
     return staticMutex;
 }
@@ -71 +71 @@
     JSGlobalContextRef ctx;
     {
-        MutexLocker locker(javaScriptThreadsMutex());
+        DeprecatedMutexLocker locker(javaScriptThreadsMutex());
         ctx = JSGlobalContextCreateInGroup(javaScriptThreadsGroup, 0);
     }
@@ -77 +77 @@
     JSStringRef scriptRef;
     {
-        MutexLocker locker(javaScriptThreadsMutex());
+        DeprecatedMutexLocker locker(javaScriptThreadsMutex());
         scriptRef = JSStringCreateWithUTF8CString(script);
     }
@@ -83 +83 @@
     while (true) {
         {
-            MutexLocker locker(javaScriptThreadsMutex());
+            DeprecatedMutexLocker locker(javaScriptThreadsMutex());
             JSValueRef exception = 0;
             JSEvaluateScript(ctx, scriptRef, 0, 0, 1, &exception);
@@ -90 +90 @@
 
         {
-            MutexLocker locker(javaScriptThreadsMutex());
+            DeprecatedMutexLocker locker(javaScriptThreadsMutex());
             const size_t valuesCount = 1024;
             JSValueRef values[valuesCount];
@@ -98 +98 @@
 
         {
-            MutexLocker locker(javaScriptThreadsMutex());
+            DeprecatedMutexLocker locker(javaScriptThreadsMutex());
             if (javaScriptThreadsShouldTerminate)
                 break;
@@ -107 +107 @@
             continue;
 
-        MutexLocker locker(javaScriptThreadsMutex());
+        DeprecatedMutexLocker locker(javaScriptThreadsMutex());
         ThreadIdentifier thread = currentThread();
         detachThread(thread);
@@ -115 +115 @@
     }
 
-    MutexLocker locker(javaScriptThreadsMutex());
+    DeprecatedMutexLocker locker(javaScriptThreadsMutex());
     JSStringRelease(scriptRef);
     JSGarbageCollect(ctx);
@@ -125 +125 @@
     javaScriptThreadsGroup = JSContextGroupCreate();
 
-    MutexLocker locker(javaScriptThreadsMutex());
+    DeprecatedMutexLocker locker(javaScriptThreadsMutex());
 
     for (size_t i = 0; i < javaScriptThreadsCount; ++i)
@@ -134 +134 @@
 {
     {
-        MutexLocker locker(javaScriptThreadsMutex());
+        DeprecatedMutexLocker locker(javaScriptThreadsMutex());
         javaScriptThreadsShouldTerminate = true;
     }
@@ -140 +140 @@
     Vector<ThreadIdentifier, javaScriptThreadsCount> threads;
     {
-        MutexLocker locker(javaScriptThreadsMutex());
+        DeprecatedMutexLocker locker(javaScriptThreadsMutex());
         copyToVector(javaScriptThreads(), threads);
         ASSERT(threads.size() == javaScriptThreadsCount);
@@ -149 +149 @@
 
     {
-        MutexLocker locker(javaScriptThreadsMutex());
+        DeprecatedMutexLocker locker(javaScriptThreadsMutex());
         javaScriptThreads().clear();
     }

trunk/Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp

@@ -41 +41 @@
 TEST(WTF_WorkQueue, Simple)
 {
-    Mutex m_lock;
+    DeprecatedMutex m_lock;
     ThreadCondition m_testCompleted;
     Vector<std::string> m_functionCallOrder;
@@ -57 +57 @@
     EXPECT_EQ(1, initialRefCount);
 
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     queue->dispatch([&](void) {
         m_functionCallOrder.append(simpleTestLabel);
@@ -70 +70 @@
 
     queue->dispatch([&](void) {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         m_functionCallOrder.append(thirdTestLabel);
         calledThirdTest = true;
@@ -97 +97 @@
 TEST(WTF_WorkQueue, TwoQueues)
 {
-    Mutex m_lock;
+    DeprecatedMutex m_lock;
     ThreadCondition m_testQueue1Completed, m_testQueue2Completed;
     Vector<std::string> m_functionCallOrder;
@@ -111 +111 @@
     EXPECT_EQ(1, queue2->refCount());
 
-    MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
     
     queue1->dispatch([&](void) {
@@ -121 +121 @@
         std::this_thread::sleep_for(std::chrono::milliseconds(50));
 
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
 
         // Will fail if queue2 took the mutex before queue1.
@@ -132 +132 @@
 
     queue1->dispatch([&](void) {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         m_functionCallOrder.append(thirdTestLabel);
         calledThirdTest = true;
@@ -159 +159 @@
 TEST(WTF_WorkQueue, DispatchAfter)
 {
-    Mutex m_lock;
+    DeprecatedMutex m_lock;
     ThreadCondition m_testCompleted, m_dispatchAfterTestCompleted;
     Vector<std::string> m_functionCallOrder;
@@ -168 +168 @@
     auto queue = WorkQueue::create("com.apple.WebKit.Test.dispatchAfter");
 
-    MutexLocker locker(m_lock);
-
-    queue->dispatch([&](void) {
-        MutexLocker locker(m_lock);
+    DeprecatedMutexLocker locker(m_lock);
+
+    queue->dispatch([&](void) {
+        DeprecatedMutexLocker locker(m_lock);
         m_functionCallOrder.append(simpleTestLabel);
         calledSimpleTest = true;
@@ -178 +178 @@
 
     queue->dispatchAfter(std::chrono::milliseconds(500), [&](void) {
-        MutexLocker locker(m_lock);
+        DeprecatedMutexLocker locker(m_lock);
         m_functionCallOrder.append(dispatchAfterLabel);
         calledDispatchAfterTest = true;

trunk/Tools/TestWebKitAPI/Tests/WTF/glib/WorkQueueGLib.cpp

@@ -38 +38 @@
 {
     struct TestingContext {
-        Mutex m_lock;
+        DeprecatedMutex m_lock;
         ThreadCondition m_testCompleted;
         GMainContext* m_mainContext;
@@ -50 +50 @@
     GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(currentDirectory.get()));
 
-    MutexLocker locker(context.m_lock);
+    DeprecatedMutexLocker locker(context.m_lock);
     queue->dispatch([&](void) {
         EXPECT_TRUE(g_main_context_get_thread_default());
@@ -58 +58 @@
             [](GObject*, GAsyncResult*, gpointer userData) {
                 TestingContext* context = static_cast<TestingContext*>(userData);
-                MutexLocker locker(context->m_lock);
+                DeprecatedMutexLocker locker(context->m_lock);
                 EXPECT_EQ(g_main_context_get_thread_default(), context->m_mainContext);
                 context->m_testCompleted.signal();