Decouple c/b/cros/audio from c/b/speech.

chrome/browser/chromeos/audio/audio_mixer_alsa.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/audio/audio_mixer_alsa.h"
 
 #include <unistd.h>
 
 #include <alsa/asoundlib.h>
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
-#include "chrome/browser/speech/extension_api/tts_extension_api_chromeos.h"
 #include "content/public/browser/browser_thread.h"
 
 typedef long alsa_long_t;  // 'long' is required for ALSA API calls.
 
 using content::BrowserThread;
 using std::string;
 
 namespace chromeos {
 
 namespace {
@@ skipping 65 matching lines @@
     // http://crbug.com/125206
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
     disconnected_event_.Wait();
   }
 
   base::ThreadRestrictions::ScopedAllowIO allow_io_for_thread_join;
   thread_->Stop();
   thread_.reset();
 }
 
-void AudioMixerAlsa::Init() {
+void AudioMixerAlsa::Init(const base::Closure& on_connected) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!thread_.get()) << "Init() called twice";
   thread_.reset(new base::Thread("AudioMixerAlsa"));
   CHECK(thread_->Start());
   thread_->message_loop()->PostTask(
-      FROM_HERE, base::Bind(&AudioMixerAlsa::Connect, base::Unretained(this)));
+      FROM_HERE, base::Bind(&AudioMixerAlsa::Connect,
+                            base::Unretained(this),
+                            on_connected));
 }
 
 double AudioMixerAlsa::GetVolumePercent() {
   base::AutoLock lock(lock_);
   return !alsa_mixer_ ?
       initial_volume_percent_ :
       DbToPercent(volume_db_);
 }
 
 void AudioMixerAlsa::SetVolumePercent(double percent) {
@@ skipping 59 matching lines @@
   base::AutoLock lock(lock_);
   return is_capture_mute_locked_;
 }
 
 void AudioMixerAlsa::SetCaptureMuteLocked(bool locked) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
   is_capture_mute_locked_ = locked;
 }
 
-void AudioMixerAlsa::Connect() {
+void AudioMixerAlsa::Connect(const base::Closure& on_connected) {
   DCHECK(MessageLoop::current() == thread_->message_loop());
   DCHECK(!alsa_mixer_);
 
   if (disconnected_event_.IsSignaled())
     return;
 
   // Do not attempt to connect if we're not on the device.
   if (!base::chromeos::IsRunningOnChromeOS())
     return;
 
-  if (!ConnectInternal()) {
-    thread_->message_loop()->PostDelayedTask(FROM_HERE,
-        base::Bind(&AudioMixerAlsa::Connect, base::Unretained(this)),
+  if (!ConnectInternal(on_connected)) {
+    thread_->message_loop()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&AudioMixerAlsa::Connect,
+                   base::Unretained(this),
+                   on_connected),
         base::TimeDelta::FromSeconds(kConnectionRetrySleepSec));
   }
 }
 
-bool AudioMixerAlsa::ConnectInternal() {
+bool AudioMixerAlsa::ConnectInternal(const base::Closure& on_connected) {
   DCHECK(MessageLoop::current() == thread_->message_loop());
   num_connection_attempts_++;
   int err;
   snd_mixer_t* handle = NULL;
 
   if ((err = snd_mixer_open(&handle, 0)) < 0) {
     if (num_connection_attempts_ == kConnectionAttemptToLogFailure)
       LOG(WARNING) << "Mixer open error: " << snd_strerror(err);
     return false;
   }
@@ skipping 96 matching lines @@
     alsa_mixer_ = handle;
     master_element_ = master_element;
     pcm_element_ = pcm_element;
     mic_element_ = mic_element;
     front_mic_element_ = front_mic_element;
     min_volume_db_ = min_volume_db;
     max_volume_db_ = max_volume_db;
     volume_db_ = PercentToDb(initial_volume_percent_);
   }
 
-  // The speech synthesis service shouldn't be initialized until after
-  // we get to this point, so we call this function to tell it that it's
-  // safe to do TTS now.  NotificationService would be cleaner,
-  // but it's not available at this point.
-  EnableChromeOsTts();
+  on_connected.Run();
 
   ApplyState();
   return true;
 }
 
 void AudioMixerAlsa::Disconnect() {
   DCHECK(MessageLoop::current() == thread_->message_loop());
   if (alsa_mixer_) {
     snd_mixer_close(alsa_mixer_);
     alsa_mixer_ = NULL;
@@ skipping 155 matching lines @@
 void AudioMixerAlsa::ApplyStateIfNeeded() {
   lock_.AssertAcquired();
   if (!apply_is_pending_) {
     thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&AudioMixerAlsa::ApplyState, base::Unretained(this)));
   }
 }
 
 }  // namespace chromeos