Audio Directive Handler cleanup

components/copresence/handlers/audio/audio_directive_handler.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/copresence/handlers/audio/audio_directive_handler.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
@@ skipping 63 matching lines @@
                                            const std::string& op_id,
                                            base::TimeDelta ttl) {
   switch (instruction.token_instruction_type()) {
     case TRANSMIT:
       DVLOG(2) << "Audio Transmit Directive received. Token: "
                << instruction.token_id()
                << " with TTL=" << ttl.InMilliseconds();
       switch (instruction.medium()) {
         case AUDIO_ULTRASOUND_PASSBAND:
           transmits_list_inaudible_.AddDirective(op_id, ttl);
-          HandleToken(instruction.token_id(), false);
+          PlayToken(instruction.token_id(), false);
           break;
         case AUDIO_AUDIBLE_DTMF:
           transmits_list_audible_.AddDirective(op_id, ttl);
-          HandleToken(instruction.token_id(), true);
+          PlayToken(instruction.token_id(), true);
           break;
         default:
           NOTREACHED();
       }
       break;
     case RECEIVE:
       DVLOG(2) << "Audio Receive Directive received. TTL="
                << ttl.InMilliseconds();
       receives_list_.AddDirective(op_id, ttl);
+      ProcessNextReceive();
       break;
     case UNKNOWN_TOKEN_INSTRUCTION_TYPE:
     default:
       LOG(WARNING) << "Unknown Audio Transmit Directive received.";
   }
-  // ExecuteNextTransmit will be called by directive_list_ when Add is done.
-  ProcessNextReceive();
 }
 
 void AudioDirectiveHandler::RemoveInstructions(const std::string& op_id) {
   transmits_list_audible_.RemoveDirective(op_id);
   transmits_list_inaudible_.RemoveDirective(op_id);
   receives_list_.RemoveDirective(op_id);
 
   ProcessNextTransmit();
   ProcessNextReceive();
 }
@@ skipping 53 matching lines @@
                                 receive->end_time - base::Time::Now(),
                                 this,
                                 &AudioDirectiveHandler::ProcessNextReceive);
   } else if (!receive && recorder_->IsRecording()) {
     DVLOG(3) << "Stopping Recording";
     stop_recording_timer_.Stop();
     recorder_->Stop();
   }
 }
 
-void AudioDirectiveHandler::HandleToken(const std::string token, bool audible) {
+void AudioDirectiveHandler::PlayToken(const std::string token, bool audible) {
   std::string valid_token = FromUrlSafe(token);
 
+  // If the token has been encoded already, use the cached samples.
   if (audible && samples_cache_audible_.HasKey(valid_token)) {
     current_token_audible_ = token;
     ProcessNextTransmit();
-    return;
-  }
-
-  if (!audible && samples_cache_inaudible_.HasKey(valid_token)) {
+  } else if (!audible && samples_cache_inaudible_.HasKey(valid_token)) {
     current_token_inaudible_ = token;
     ProcessNextTransmit();
-    return;
+  } else {
+    // Otherwise, encode the token and then play it.
+    encode_cb_.Run(valid_token,
+                   audible,
+                   base::Bind(&AudioDirectiveHandler::PlayEncodedToken,
+                              base::Unretained(this)));
   }
-
-  encode_cb_.Run(valid_token,
-                 audible,
-                 base::Bind(&AudioDirectiveHandler::OnTokenEncoded,
-                            base::Unretained(this)));
 }
 
-void AudioDirectiveHandler::OnTokenEncoded(
+void AudioDirectiveHandler::PlayEncodedToken(
     const std::string& token,
     bool audible,
     const scoped_refptr<media::AudioBusRefCounted>& samples) {
-  DVLOG(3) << "Token: " << token << "[audible:" << audible << "] encoded.";
+  DVLOG(3) << "Token " << token << "[audible:" << audible << "] encoded.";
   if (audible) {
     samples_cache_audible_.Add(token, samples);
     current_token_audible_ = token;
     // Force process transmits to pick up the new token.
     if (player_audible_->IsPlaying())
       player_audible_->Stop();
   } else {
     samples_cache_inaudible_.Add(token, samples);
     current_token_inaudible_ = token;
     // Force process transmits to pick up the new token.
     if (player_inaudible_->IsPlaying())
       player_inaudible_->Stop();
   }
 
   ProcessNextTransmit();
 }
 
 }  // namespace copresence