Fixed ended event when playing audio on linux.

media/audio/linux/alsa_output.cc

 // Copyright (c) 2010 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.
 //
 // THREAD SAFETY
 //
 // The AlsaPcmOutputStream object's internal state is accessed by two threads:
 //
 //   client thread - creates the object and calls the public APIs.
 //   message loop thread - executes all the internal tasks including querying
@@ skipping 468 matching lines @@
     return;
   }
 
   *source_exhausted = false;
 
   // Request more data if we have capacity.
   if (buffer_->forward_capacity() > buffer_->forward_bytes()) {
     // Before making a request to source for data. We need to determine the
     // delay (in bytes) for the requested data to be played.
     snd_pcm_sframes_t delay = buffer_->forward_bytes() * bytes_per_frame_ /
-        bytes_per_output_frame_ + GetCurrentDelay() * bytes_per_output_frame_;
+        bytes_per_output_frame_;
 
     scoped_refptr<media::DataBuffer> packet =
         new media::DataBuffer(packet_size_);
     size_t packet_size =
         shared_data_.OnMoreData(this, packet->GetWritableData(),
                                 packet->GetBufferSize(), delay);
     CHECK(packet_size <= packet->GetBufferSize()) <<
         "Data source overran buffer.";
 
-    // This should not happen, but incase it does, drop any trailing bytes
+    // This should not happen, but in case it does, drop any trailing bytes
     // that aren't large enough to make a frame.  Without this, packet writing
     // may stall because the last few bytes in the packet may never get used by
     // WritePacket.
     DCHECK(packet_size % bytes_per_frame_ == 0);
     packet_size = (packet_size / bytes_per_frame_) * bytes_per_frame_;
 
     if (should_downmix_) {
       if (media::FoldChannels(packet->GetWritableData(),
                               packet_size,
                               channels_,
@@ skipping 284 matching lines @@
   }
   if (available_frames < 0) {
     LOG(ERROR) << "Failed querying available frames. Assuming 0: "
                << wrapper_->StrError(available_frames);
     return 0;
   }
 
   return available_frames;
 }
 
-snd_pcm_sframes_t AlsaPcmOutputStream::GetCurrentDelay() {
-  snd_pcm_sframes_t delay = 0;
-
-  // Don't query ALSA's delay if we have underrun since it'll be jammed at
-  // some non-zero value and potentially even negative!
-  if (wrapper_->PcmState(playback_handle_) != SND_PCM_STATE_XRUN) {
-    int error = wrapper_->PcmDelay(playback_handle_, &delay);
-    if (error < 0) {
-      // Assume a delay of zero and attempt to recover the device.
-      delay = 0;
-      error = wrapper_->PcmRecover(playback_handle_,
-                                   error,
-                                   kPcmRecoverIsSilent);
-      if (error < 0) {
-        LOG(ERROR) << "Failed querying delay: " << wrapper_->StrError(error);
-      }
-    }
-    if (delay < 0)
-      delay = 0;
-  }
-  return delay;
-}
-
 snd_pcm_t* AlsaPcmOutputStream::AutoSelectDevice(unsigned int latency) {
   // For auto-selection:
   //   1) Attempt to open a device that best matches the number of channels
   //      requested.
   //   2) If that fails, attempt the "plug:" version of it incase ALSA can
   //      remap do some software conversion to make it work.
   //   3) Fallback to kDefaultDevice.
   //   4) If that fails too, try the "plug:" version of kDefaultDevice.
   //   5) Give up.
   snd_pcm_t* handle = NULL;
@@ skipping 145 matching lines @@
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::SharedData::set_source_callback(
     AudioSourceCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), state_transition_loop_);
   AutoLock l(lock_);
   source_callback_ = callback;
 }