Replace ASSERT/ASSERT_NOT_REACHED with DCHECK/NOTREACHED in modules/webaudio

third_party/WebKit/Source/modules/webaudio/DeferredTaskHandler.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 64 matching lines @@
 #endif
 }
 
 void DeferredTaskHandler::AddDeferredBreakConnection(AudioHandler& node) {
   DCHECK(IsAudioThread());
   deferred_break_connection_list_.push_back(&node);
 }
 
 void DeferredTaskHandler::BreakConnections() {
   DCHECK(IsAudioThread());
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   for (unsigned i = 0; i < deferred_break_connection_list_.size(); ++i)
     deferred_break_connection_list_[i]->BreakConnectionWithLock();
   deferred_break_connection_list_.Clear();
 }
 
 void DeferredTaskHandler::MarkSummingJunctionDirty(
     AudioSummingJunction* summing_junction) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
   dirty_summing_junctions_.insert(summing_junction);
 }
 
 void DeferredTaskHandler::RemoveMarkedSummingJunction(
     AudioSummingJunction* summing_junction) {
   DCHECK(IsMainThread());
   AutoLocker locker(*this);
   dirty_summing_junctions_.erase(summing_junction);
 }
 
 void DeferredTaskHandler::MarkAudioNodeOutputDirty(AudioNodeOutput* output) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
   DCHECK(IsMainThread());
   dirty_audio_node_outputs_.insert(output);
 }
 
 void DeferredTaskHandler::RemoveMarkedAudioNodeOutput(AudioNodeOutput* output) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
   DCHECK(IsMainThread());
   dirty_audio_node_outputs_.erase(output);
 }
 
 void DeferredTaskHandler::HandleDirtyAudioSummingJunctions() {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   for (AudioSummingJunction* junction : dirty_summing_junctions_)
     junction->UpdateRenderingState();
   dirty_summing_junctions_.Clear();
 }
 
 void DeferredTaskHandler::HandleDirtyAudioNodeOutputs() {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   HashSet<AudioNodeOutput*> dirty_outputs;
   dirty_audio_node_outputs_.Swap(dirty_outputs);
 
   // Note: the updating of rendering state may cause output nodes
   // further down the chain to be marked as dirty. These will not
   // be processed in this render quantum.
   for (AudioNodeOutput* output : dirty_outputs)
     output->UpdateRenderingState();
 }
 
 void DeferredTaskHandler::AddAutomaticPullNode(AudioHandler* node) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   if (!automatic_pull_nodes_.Contains(node)) {
     automatic_pull_nodes_.insert(node);
     automatic_pull_nodes_need_updating_ = true;
   }
 }
 
 void DeferredTaskHandler::RemoveAutomaticPullNode(AudioHandler* node) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   if (automatic_pull_nodes_.Contains(node)) {
     automatic_pull_nodes_.erase(node);
     automatic_pull_nodes_need_updating_ = true;
   }
 }
 
 void DeferredTaskHandler::UpdateAutomaticPullNodes() {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   if (automatic_pull_nodes_need_updating_) {
     CopyToVector(automatic_pull_nodes_, rendering_automatic_pull_nodes_);
     automatic_pull_nodes_need_updating_ = false;
   }
 }
 
 void DeferredTaskHandler::ProcessAutomaticPullNodes(size_t frames_to_process) {
   DCHECK(IsAudioThread());
 
   for (unsigned i = 0; i < rendering_automatic_pull_nodes_.size(); ++i)
     rendering_automatic_pull_nodes_[i]->ProcessIfNecessary(frames_to_process);
 }
 
 void DeferredTaskHandler::AddChangedChannelCountMode(AudioHandler* node) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
   DCHECK(IsMainThread());
   deferred_count_mode_change_.insert(node);
 }
 
 void DeferredTaskHandler::RemoveChangedChannelCountMode(AudioHandler* node) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   deferred_count_mode_change_.erase(node);
 }
 
 void DeferredTaskHandler::AddChangedChannelInterpretation(AudioHandler* node) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
   DCHECK(IsMainThread());
   deferred_channel_interpretation_change_.insert(node);
 }
 
 void DeferredTaskHandler::RemoveChangedChannelInterpretation(
     AudioHandler* node) {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   deferred_channel_interpretation_change_.erase(node);
 }
 
 void DeferredTaskHandler::UpdateChangedChannelCountMode() {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   for (AudioHandler* node : deferred_count_mode_change_)
     node->UpdateChannelCountMode();
   deferred_count_mode_change_.Clear();
 }
 
 void DeferredTaskHandler::UpdateChangedChannelInterpretation() {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
 
   for (AudioHandler* node : deferred_channel_interpretation_change_)
     node->UpdateChannelInterpretation();
   deferred_channel_interpretation_change_.Clear();
 }
 
 DeferredTaskHandler::DeferredTaskHandler()
     : automatic_pull_nodes_need_updating_(false), audio_thread_(0) {}
 
 PassRefPtr<DeferredTaskHandler> DeferredTaskHandler::Create() {
@@ skipping 36 matching lines @@
 }
 
 void DeferredTaskHandler::AddRenderingOrphanHandler(
     PassRefPtr<AudioHandler> handler) {
   DCHECK(handler);
   DCHECK(!rendering_orphan_handlers_.Contains(handler));
   rendering_orphan_handlers_.push_back(handler);
 }
 
 void DeferredTaskHandler::RequestToDeleteHandlersOnMainThread() {
-  ASSERT(IsGraphOwner());
+  DCHECK(IsGraphOwner());
   DCHECK(IsAudioThread());
   if (rendering_orphan_handlers_.IsEmpty())
     return;
   deletable_orphan_handlers_.AppendVector(rendering_orphan_handlers_);
   rendering_orphan_handlers_.Clear();
   Platform::Current()->MainThread()->GetWebTaskRunner()->PostTask(
       BLINK_FROM_HERE,
       CrossThreadBind(&DeferredTaskHandler::DeleteHandlersOnMainThread,
                       PassRefPtr<DeferredTaskHandler>(this)));
 }
@@ skipping 11 matching lines @@
   deletable_orphan_handlers_.Clear();
 }
 
 void DeferredTaskHandler::SetAudioThreadToCurrentThread() {
   DCHECK(!IsMainThread());
   ThreadIdentifier thread = CurrentThread();
   ReleaseStore(&audio_thread_, thread);
 }
 
 }  // namespace blink