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

third_party/WebKit/Source/modules/webaudio/AudioNode.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 75 matching lines @@
 }
 
 void AudioHandler::Uninitialize() {
   is_initialized_ = false;
 }
 
 void AudioHandler::ClearInternalStateWhenDisabled() {}
 
 void AudioHandler::Dispose() {
   DCHECK(IsMainThread());
-  ASSERT(Context()->IsGraphOwner());
+  DCHECK(Context()->IsGraphOwner());
 
   Context()->GetDeferredTaskHandler().RemoveChangedChannelCountMode(this);
   Context()->GetDeferredTaskHandler().RemoveChangedChannelInterpretation(this);
   Context()->GetDeferredTaskHandler().RemoveAutomaticPullNode(this);
   for (auto& output : outputs_)
     output->Dispose();
   node_ = nullptr;
 }
 
 AudioNode* AudioHandler::GetNode() const {
@@ skipping 39 matching lines @@
       return "ChannelMergerNode";
     case kNodeTypeAnalyser:
       return "AnalyserNode";
     case kNodeTypeDynamicsCompressor:
       return "DynamicsCompressorNode";
     case kNodeTypeWaveShaper:
       return "WaveShaperNode";
     case kNodeTypeUnknown:
     case kNodeTypeEnd:
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return "UnknownNode";
   }
 }
 
 void AudioHandler::SetNodeType(NodeType type) {
   // Don't allow the node type to be changed to a different node type, after
   // it's already been set.  And the new type can't be unknown or end.
   DCHECK_EQ(node_type_, kNodeTypeUnknown);
   DCHECK_NE(type, kNodeTypeUnknown);
   DCHECK_NE(type, kNodeTypeEnd);
@@ skipping 67 matching lines @@
   // rendering phase, we want to return the value that was set, not the actual
   // current mode.
   switch (new_channel_count_mode_) {
     case kMax:
       return "max";
     case kClampedMax:
       return "clamped-max";
     case kExplicit:
       return "explicit";
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return "";
 }
 
 void AudioHandler::SetChannelCountMode(const String& mode,
                                        ExceptionState& exception_state) {
   DCHECK(IsMainThread());
   BaseAudioContext::AutoLocker locker(Context());
 
   ChannelCountMode old_mode = channel_count_mode_;
 
   if (mode == "max") {
     new_channel_count_mode_ = kMax;
   } else if (mode == "clamped-max") {
     new_channel_count_mode_ = kClampedMax;
   } else if (mode == "explicit") {
     new_channel_count_mode_ = kExplicit;
   } else {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
   }
 
   if (new_channel_count_mode_ != old_mode)
     Context()->GetDeferredTaskHandler().AddChangedChannelCountMode(this);
 }
 
 String AudioHandler::ChannelInterpretation() {
   // Because we delay the actual setting of the interpreation to the pre or
   // post rendering phase, we want to return the value that was set, not the
   // actual current interpretation.
   switch (new_channel_interpretation_) {
     case AudioBus::kSpeakers:
       return "speakers";
     case AudioBus::kDiscrete:
       return "discrete";
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return "";
 }
 
 void AudioHandler::SetChannelInterpretation(const String& interpretation,
                                             ExceptionState& exception_state) {
   DCHECK(IsMainThread());
   BaseAudioContext::AutoLocker locker(Context());
 
   AudioBus::ChannelInterpretation old_mode = channel_interpretation_;
 
   if (interpretation == "speakers") {
     new_channel_interpretation_ = AudioBus::kSpeakers;
   } else if (interpretation == "discrete") {
     new_channel_interpretation_ = AudioBus::kDiscrete;
   } else {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
   }
 
   if (new_channel_interpretation_ != old_mode)
     Context()->GetDeferredTaskHandler().AddChangedChannelInterpretation(this);
 }
 
 void AudioHandler::UpdateChannelsForInputs() {
   for (auto& input : inputs_)
     input->ChangedOutputs();
 }
@@ skipping 36 matching lines @@
       // the downstream nodes.  (For example, a Gain node with a gain of 0 will
       // want to silence its output.)
       UnsilenceOutputs();
       Process(frames_to_process);
     }
   }
 }
 
 void AudioHandler::CheckNumberOfChannelsForInput(AudioNodeInput* input) {
   DCHECK(Context()->IsAudioThread());
-  ASSERT(Context()->IsGraphOwner());
+  DCHECK(Context()->IsGraphOwner());
 
   DCHECK(inputs_.Contains(input));
   if (!inputs_.Contains(input))
     return;
 
   input->UpdateInternalBus();
 }
 
 double AudioHandler::TailTime() const {
   return 0;
@@ skipping 604 matching lines @@
 }
 
 void AudioNode::DidAddOutput(unsigned number_of_outputs) {
   connected_nodes_.push_back(nullptr);
   DCHECK_EQ(number_of_outputs, connected_nodes_.size());
   connected_params_.push_back(nullptr);
   DCHECK_EQ(number_of_outputs, connected_params_.size());
 }
 
 }  // namespace blink