Fix a bug in AudioRendererHost and add hooks for test

chrome/browser/renderer_host/audio_renderer_host.cc

-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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 "base/histogram.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
 #include "base/waitable_event.h"
 #include "chrome/browser/renderer_host/audio_renderer_host.h"
@@ skipping 51 matching lines @@
     : host_(host),
       process_id_(process_id),
       route_id_(route_id),
       stream_id_(stream_id),
       stream_(stream),
       hardware_packet_size_(hardware_packet_size),
       decoded_packet_size_(decoded_packet_size),
       buffer_capacity_(buffer_capacity),
       state_(AudioOutputStream::STATE_CREATED),
       push_source_(hardware_packet_size),
-      outstanding_request_(false) {
+      outstanding_request_(false),
+      last_copied_bytes_(0) {
 }
 
 AudioRendererHost::IPCAudioSource::~IPCAudioSource() {
+  DCHECK_EQ(AudioOutputStream::STATE_STOPPED, state_);
 }
 
 // static
 AudioRendererHost::IPCAudioSource*
     AudioRendererHost::IPCAudioSource::CreateIPCAudioSource(
         AudioRendererHost* host,
         int process_id,
         int route_id,
         int stream_id,
         base::ProcessHandle process_handle,
@@ skipping 159 matching lines @@
   host_->DestroySource(this);
 }
 
 void AudioRendererHost::IPCAudioSource::NotifyPacketReady(
     size_t decoded_packet_size) {
   bool ok = true;
   {
     AutoLock auto_lock(lock_);
     outstanding_request_ = false;
 #ifdef IPC_MESSAGE_LOG_ENABLED
-    if (IPC::Logging::current()->Enabled()) {
+    if (IPC::Logging::current() && IPC::Logging::current()->Enabled()) {
       RecordRoundTripLatency(base::Time::Now() - outstanding_request_time_);
     }
 #endif
     // If reported size is greater than capacity of the shared memory, we have
     // an error.
     if (decoded_packet_size <= decoded_packet_size_) {
       for (size_t i = 0; i < decoded_packet_size; i += hardware_packet_size_) {
         size_t size = std::min(decoded_packet_size - i, hardware_packet_size_);
         ok &= push_source_.Write(
             static_cast<char*>(shared_memory_.memory()) + i, size);
@@ skipping 65 matching lines @@
       process_handle_(0),
       ipc_sender_(NULL),
       io_loop_(message_loop) {
   // Make sure we perform actual initialization operations in the thread where
   // this object should live.
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioRendererHost::OnInitialized));
 }
 
 AudioRendererHost::~AudioRendererHost() {
+  DCHECK(sources_.empty());
 }
 
 void AudioRendererHost::Destroy() {
   // Post a message to the thread where this object should live and do the
   // actual operations there.
   io_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &AudioRendererHost::OnDestroyed));
 }
 
 // Event received when IPC channel is connected to the renderer process.
@@ skipping 132 matching lines @@
 void AudioRendererHost::OnNotifyPacketReady(const IPC::Message& msg,
                                             int stream_id, size_t packet_size) {
   DCHECK(MessageLoop::current() == io_loop_);
   IPCAudioSource* source = Lookup(msg.routing_id(), stream_id);
   if (source) {
     source->NotifyPacketReady(packet_size);
   } else {
     SendErrorMessage(msg.routing_id(), stream_id, 0);
   }
 #ifdef IPC_MESSAGE_LOG_ENABLED
-  if (IPC::Logging::current()->Enabled()) {
+  if (IPC::Logging::current() && IPC::Logging::current()->Enabled()) {
     RecordReceiveLatency(base::Time::FromInternalValue(msg.received_time()) -
                          base::Time::FromInternalValue(msg.sent_time()));
     RecordProcessTime(base::Time::Now() -
                       base::Time::FromInternalValue(msg.received_time()));
   }
 #endif
 }
 
 void AudioRendererHost::OnInitialized() {
   DCHECK(MessageLoop::current() == io_loop_);
@@ skipping 71 matching lines @@
   if (MessageLoop::current() == io_loop_) {
     OnDestroySource(source);
   } else {
     // TODO(hclam): make sure it's always safe to post a task to IO loop.
     // It is possible that IO message loop is destroyed but there's still some
     // dangling audio hardware threads that try to call this method.
     io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &AudioRendererHost::OnDestroySource, source));
   }
 }