Creating the audio_modem component

components/copresence/handlers/directive_handler_impl.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/directive_handler_impl.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 17 matching lines @@
                                update_directives_callback))) {}
 
 DirectiveHandlerImpl::DirectiveHandlerImpl(
     const DirectivesCallback& update_directives_callback,
     scoped_ptr<AudioDirectiveHandler> audio_handler)
     : audio_handler_(audio_handler.Pass()),
       is_started_(false) {}
 
 DirectiveHandlerImpl::~DirectiveHandlerImpl() {}
 
-void DirectiveHandlerImpl::Start(WhispernetClient* whispernet_client,
-                                 const TokensCallback& tokens_cb) {
+void DirectiveHandlerImpl::Start(
+    audio_modem::WhispernetClient* whispernet_client,
+    const audio_modem::TokensCallback& tokens_cb) {
   audio_handler_->Initialize(whispernet_client, tokens_cb);
   DVLOG(2) << "Directive handler starting";
 
   is_started_ = true;
 
   // Run all the queued directives.
   for (const auto& op_id : pending_directives_) {
     for (const Directive& directive : op_id.second)
       StartDirective(op_id.first, directive);
   }
@@ skipping 36 matching lines @@
 
 void DirectiveHandlerImpl::RemoveDirectives(const std::string& op_id) {
   // If whispernet_client_ is null, audio_handler_ hasn't been Initialized.
   if (is_started_) {
     audio_handler_->RemoveInstructions(op_id);
   } else {
     pending_directives_.erase(op_id);
   }
 }
 
-const std::string DirectiveHandlerImpl::GetCurrentAudioToken(AudioType type)
-    const {
+const std::string DirectiveHandlerImpl::GetCurrentAudioToken(
+    audio_modem::AudioType type) const {
   // If whispernet_client_ is null, audio_handler_ hasn't been Initialized.
   return is_started_ ? audio_handler_->PlayingToken(type) : "";
 }
 
-bool DirectiveHandlerImpl::IsAudioTokenHeard(AudioType type) const {
+bool DirectiveHandlerImpl::IsAudioTokenHeard(
+    audio_modem::AudioType type) const {
   return is_started_ ? audio_handler_->IsPlayingTokenHeard(type) : false;
 }
 
 
 // Private functions.
 
 void DirectiveHandlerImpl::StartDirective(const std::string& op_id,
                                           const Directive& directive) {
   DCHECK(is_started_);
   DLOG_IF(WARNING, directive.delay_millis() > 0)
       << "Ignoring " << directive.delay_millis() << " delay for directive";
   const TokenMedium& medium = directive.token_instruction().medium();
   DCHECK(medium == AUDIO_ULTRASOUND_PASSBAND || medium == AUDIO_AUDIBLE_DTMF)
       << "Received directive for unimplemented medium " << medium;
   audio_handler_->AddInstruction(directive, op_id);
 }
 
 }  // namespace copresence