Update DEBUG_AUDIONODE_REFERENCES to new coding style

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 40 matching lines @@
       last_processing_time_(-1),
       last_non_silent_time_(-1),
       connection_ref_count_(0),
       is_disabled_(false),
       channel_count_(2) {
   SetNodeType(node_type);
   SetInternalChannelCountMode(kMax);
   SetInternalChannelInterpretation(AudioBus::kSpeakers);
 
 #if DEBUG_AUDIONODE_REFERENCES
-  if (!s_isNodeCountInitialized) {
-    s_isNodeCountInitialized = true;
-    atexit(AudioHandler::printNodeCounts);
+  if (!is_node_count_initialized_) {
+    is_node_count_initialized_ = true;
+    atexit(AudioHandler::PrintNodeCounts);
   }
 #endif
   InstanceCounters::IncrementCounter(InstanceCounters::kAudioHandlerCounter);
 }
 
 AudioHandler::~AudioHandler() {
   DCHECK(IsMainThread());
   // dispose() should be called.
   DCHECK(!GetNode());
   InstanceCounters::DecrementCounter(InstanceCounters::kAudioHandlerCounter);
 #if DEBUG_AUDIONODE_REFERENCES
-  --s_nodeCount[getNodeType()];
+  --node_count_[GetNodeType()];
   fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::~AudioHandler() %d [%d]\n",
-          context(), this, getNodeType(), m_connectionRefCount,
-          s_nodeCount[getNodeType()]);
+          Context(), this, GetNodeType(), connection_ref_count_,
+          node_count_[GetNodeType()]);
 #endif
 }
 
 void AudioHandler::Initialize() {
   DCHECK_EQ(new_channel_count_mode_, channel_count_mode_);
   DCHECK_EQ(new_channel_interpretation_, channel_interpretation_);
 
   is_initialized_ = true;
 }
 
@@ skipping 73 matching lines @@
 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);
 
   node_type_ = type;
 
 #if DEBUG_AUDIONODE_REFERENCES
-  ++s_nodeCount[type];
+  ++node_count_[type];
   fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::AudioHandler [%3d]\n",
-          context(), this, getNodeType(), s_nodeCount[getNodeType()]);
+          Context(), this, GetNodeType(), node_count_[GetNodeType()]);
 #endif
 }
 
 void AudioHandler::AddInput() {
   inputs_.push_back(AudioNodeInput::Create(*this));
 }
 
 void AudioHandler::AddOutput(unsigned number_of_channels) {
   DCHECK(IsMainThread());
   outputs_.push_back(AudioNodeOutput::Create(this, number_of_channels));
@@ skipping 262 matching lines @@
         output->Disable();
     }
   }
 }
 
 void AudioHandler::MakeConnection() {
   AtomicIncrement(&connection_ref_count_);
 
 #if DEBUG_AUDIONODE_REFERENCES
   fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::ref   %3d [%3d]\n",
-          context(), this, getNodeType(), m_connectionRefCount,
-          s_nodeCount[getNodeType()]);
+          Context(), this, GetNodeType(), connection_ref_count_,
+          node_count_[GetNodeType()]);
 #endif
   // See the disabling code in disableOutputsIfNecessary(). This handles
   // the case where a node is being re-connected after being used at least
   // once and disconnected. In this case, we need to re-enable.
   EnableOutputsIfNecessary();
 }
 
 void AudioHandler::BreakConnection() {
   // The actual work for deref happens completely within the audio context's
   // graph lock. In the case of the audio thread, we must use a tryLock to
@@ skipping 16 matching lines @@
     DCHECK(Context()->IsAudioThread());
     Context()->GetDeferredTaskHandler().AddDeferredBreakConnection(*this);
   }
 }
 
 void AudioHandler::BreakConnectionWithLock() {
   AtomicDecrement(&connection_ref_count_);
 
 #if DEBUG_AUDIONODE_REFERENCES
   fprintf(stderr, "[%16p]: %16p: %2d: AudioHandler::deref %3d [%3d]\n",
-          context(), this, getNodeType(), m_connectionRefCount,
-          s_nodeCount[getNodeType()]);
+          Context(), this, GetNodeType(), connection_ref_count_,
+          node_count_[GetNodeType()]);
 #endif
 
   if (!connection_ref_count_)
     DisableOutputsIfNecessary();
 }
 
 #if DEBUG_AUDIONODE_REFERENCES
 
-bool AudioHandler::s_isNodeCountInitialized = false;
-int AudioHandler::s_nodeCount[NodeTypeEnd];
+bool AudioHandler::is_node_count_initialized_ = false;
+int AudioHandler::node_count_[kNodeTypeEnd];
 
-void AudioHandler::printNodeCounts() {
+void AudioHandler::PrintNodeCounts() {
   fprintf(stderr, "\n\n");
   fprintf(stderr, "===========================\n");
   fprintf(stderr, "AudioNode: reference counts\n");
   fprintf(stderr, "===========================\n");
 
-  for (unsigned i = 0; i < NodeTypeEnd; ++i)
-    fprintf(stderr, "%2d: %d\n", i, s_nodeCount[i]);
+  for (unsigned i = 0; i < kNodeTypeEnd; ++i)
+    fprintf(stderr, "%2d: %d\n", i, node_count_[i]);
 
   fprintf(stderr, "===========================\n\n\n");
 }
 
 #endif  // DEBUG_AUDIONODE_REFERENCES
 
 void AudioHandler::UpdateChannelCountMode() {
   channel_count_mode_ = new_channel_count_mode_;
   UpdateChannelsForInputs();
 }
@@ skipping 13 matching lines @@
 }
 // ----------------------------------------------------------------
 
 AudioNode::AudioNode(BaseAudioContext& context)
     : context_(context), handler_(nullptr) {}
 
 void AudioNode::Dispose() {
   DCHECK(IsMainThread());
 #if DEBUG_AUDIONODE_REFERENCES
   fprintf(stderr, "[%16p]: %16p: %2d: AudioNode::dispose %16p\n", context(),
-          this, handler().getNodeType(), m_handler.get());
+          this, Handler().GetNodeType(), handler_.Get());
 #endif
   BaseAudioContext::AutoLocker locker(context());
   Handler().Dispose();
   if (context()->ContextState() == BaseAudioContext::kRunning)
     context()->GetDeferredTaskHandler().AddRenderingOrphanHandler(
         handler_.Release());
 }
 
 void AudioNode::SetHandler(PassRefPtr<AudioHandler> handler) {
   DCHECK(handler);
   handler_ = std::move(handler);
 
 #if DEBUG_AUDIONODE_REFERENCES
   fprintf(stderr, "[%16p]: %16p: %2d: AudioNode::AudioNode %16p\n", context(),
-          this, m_handler->getNodeType(), m_handler.get());
+          this, handler_->GetNodeType(), handler_.Get());
 #endif
 }
 
 AudioHandler& AudioNode::Handler() const {
   return *handler_;
 }
 
 DEFINE_TRACE(AudioNode) {
   visitor->Trace(context_);
   visitor->Trace(connected_nodes_);
@@ skipping 393 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