Fix PulseAudio compile failures when use_pulseaudio=1.

media/audio/pulse/pulse_output.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 "media/audio/pulse/pulse_output.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/audio_util.h"
@@ skipping 110 matching lines @@
   *state = pa_context_get_state(context);
 }
 
 // static
 void PulseAudioOutputStream::WriteRequestCallback(pa_stream* playback_handle,
                                                   size_t length,
                                                   void* stream_addr) {
   PulseAudioOutputStream* stream =
       reinterpret_cast<PulseAudioOutputStream*>(stream_addr);
 
-  DCHECK_EQ(stream->manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(stream->manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   stream->write_callback_handled_ = true;
 
   // Fulfill write request.
   stream->FulfillWriteRequest(length);
 }
 
 PulseAudioOutputStream::PulseAudioOutputStream(const AudioParameters& params,
                                                AudioManagerPulse* manager)
-    : channel_layout_(params.channel_layout),
+    : channel_layout_(params.channel_layout()),
       channel_count_(ChannelLayoutToChannelCount(channel_layout_)),
-      sample_format_(BitsToPASampleFormat(params.bits_per_sample)),
-      sample_rate_(params.sample_rate),
-      bytes_per_frame_(params.channels * params.bits_per_sample / 8),
+      sample_format_(BitsToPASampleFormat(params.bits_per_sample())),
+      sample_rate_(params.sample_rate()),
+      bytes_per_frame_(params.GetBytesPerFrame()),
       manager_(manager),
       pa_context_(NULL),
       pa_mainloop_(NULL),
       playback_handle_(NULL),
-      packet_size_(params.GetPacketSize()),
+      packet_size_(params.GetBytesPerBuffer()),
       frames_per_packet_(packet_size_ / bytes_per_frame_),
       client_buffer_(NULL),
       volume_(1.0f),
       stream_stopped_(true),
       write_callback_handled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       source_callback_(NULL) {
-  DCHECK_EQ(manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   // TODO(slock): Sanity check input values.
 }
 
 PulseAudioOutputStream::~PulseAudioOutputStream() {
   // All internal structures should already have been freed in Close(),
   // which calls AudioManagerPulse::Release which deletes this object.
   DCHECK(!playback_handle_);
   DCHECK(!pa_context_);
   DCHECK(!pa_mainloop_);
 }
 
 bool PulseAudioOutputStream::Open() {
-  DCHECK_EQ(manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   // TODO(slock): Possibly move most of this to an OpenPlaybackDevice function
   // in a new class 'pulse_util', like alsa_util.
 
   // Create a mainloop API and connect to the default server.
   pa_mainloop_ = pa_mainloop_new();
   pa_mainloop_api* pa_mainloop_api = pa_mainloop_get_api(pa_mainloop_);
   pa_context_ = pa_context_new(pa_mainloop_api, "Chromium");
   pa_context_state_t pa_context_state = PA_CONTEXT_UNCONNECTED;
   pa_context_connect(pa_context_, NULL, PA_CONTEXT_NOFLAGS, NULL);
@@ skipping 82 matching lines @@
   if (pa_mainloop_) {
     pa_mainloop_free(pa_mainloop_);
     pa_mainloop_ = NULL;
   }
 
   // Release internal buffer.
   client_buffer_.reset();
 }
 
 void PulseAudioOutputStream::Close() {
-  DCHECK_EQ(manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   Reset();
 
   // Signal to the manager that we're closed and can be removed.
   // This should be the last call in the function as it deletes "this".
   manager_->ReleaseOutputStream(this);
 }
 
 void PulseAudioOutputStream::WaitForWriteRequest() {
-  DCHECK_EQ(manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   if (stream_stopped_)
     return;
 
   // Iterate the PulseAudio mainloop.  If PulseAudio doesn't request a write,
   // post a task to iterate the mainloop again.
   write_callback_handled_ = false;
   pa_mainloop_iterate(pa_mainloop_, 1, NULL);
   if (!write_callback_handled_) {
     manager_->GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
@@ skipping 34 matching lines @@
 }
 
 void PulseAudioOutputStream::FulfillWriteRequest(size_t requested_bytes) {
   // If we have enough data to fulfill the request, we can finish the write.
   if (stream_stopped_)
     return;
 
   // Request more data from the source until we can fulfill the request or
   // fail to receive anymore data.
   bool buffering_successful = true;
-  while (client_buffer_->forward_bytes() < requested_bytes &&
-         buffering_successful) {
+  size_t forward_bytes = static_cast<size_t>(client_buffer_->forward_bytes());
+  while (forward_bytes < requested_bytes && buffering_successful) {
     buffering_successful = BufferPacketFromSource();
   }
 
   size_t bytes_written = 0;
   if (client_buffer_->forward_bytes() > 0) {
     // Try to fulfill the request by writing as many of the requested bytes to
     // the stream as we can.
     WriteToStream(requested_bytes, &bytes_written);
   }
 
@@ skipping 10 matching lines @@
         &PulseAudioOutputStream::WaitForWriteRequest,
         weak_factory_.GetWeakPtr()));
   }
 }
 
 void PulseAudioOutputStream::WriteToStream(size_t bytes_to_write,
                                            size_t* bytes_written) {
   *bytes_written = 0;
   while (*bytes_written < bytes_to_write) {
     const uint8* chunk;
-    size_t chunk_size;
+    int chunk_size;
 
     // Stop writing if there is no more data available.
     if (!client_buffer_->GetCurrentChunk(&chunk, &chunk_size))
       break;
 
     // Write data to stream.
     pa_stream_write(playback_handle_, chunk, chunk_size,
                     NULL, 0LL, PA_SEEK_RELATIVE);
     client_buffer_->Seek(chunk_size);
     *bytes_written += chunk_size;
   }
 }
 
 void PulseAudioOutputStream::Start(AudioSourceCallback* callback) {
-  DCHECK_EQ(manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
   CHECK(callback);
   DLOG_IF(ERROR, !playback_handle_)
       << "Open() has not been called successfully";
   if (!playback_handle_)
     return;
 
   source_callback_ = callback;
 
   // Clear buffer, it might still have data in it.
   client_buffer_->Clear();
   stream_stopped_ = false;
 
   // Start playback.
   manager_->GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
       &PulseAudioOutputStream::WaitForWriteRequest,
       weak_factory_.GetWeakPtr()));
 }
 
 void PulseAudioOutputStream::Stop() {
-  DCHECK_EQ(manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   stream_stopped_ = true;
 }
 
 void PulseAudioOutputStream::SetVolume(double volume) {
-  DCHECK_EQ(manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   volume_ = static_cast<float>(volume);
 }
 
 void PulseAudioOutputStream::GetVolume(double* volume) {
-  DCHECK_EQ(manager_->GetMessageLoop(), MessageLoop::current());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   *volume = volume_;
 }
 
 uint32 PulseAudioOutputStream::RunDataCallback(
     uint8* dest, uint32 max_size, AudioBuffersState buffers_state) {
   if (source_callback_)
     return source_callback_->OnMoreData(dest, max_size, buffers_state);
 
   return 0;
 }
 
 }  // namespace media