Remove size_t from audio IPC code.

The change got to this size because I had to modify the surrounding code (I didn't want to just cast at the last minute).
Review URL: http://codereview.chromium.org/577006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@38192 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 76 insertions, 67 deletions

diff --git a/chrome/renderer/audio_message_filter.cc b/chrome/renderer/audio_message_filter.cc
index d5cd323..31c1df4 100644
--- a/chrome/renderer/audio_message_filter.cc
+++ b/chrome/renderer/audio_message_filter.cc
@@ -1,10 +1,11 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
+#include "chrome/renderer/audio_message_filter.h"
+
 #include "base/message_loop.h"
 #include "chrome/common/render_messages.h"
-#include "chrome/renderer/audio_message_filter.h"
 #include "ipc/ipc_logging.h"
 
 AudioMessageFilter::AudioMessageFilter(int32 route_id)
@@ -58,7 +59,7 @@ void AudioMessageFilter::OnChannelClosing() {
 
 void AudioMessageFilter::OnRequestPacket(const IPC::Message& msg,
                                          int stream_id,
-                                         size_t bytes_in_buffer,
+                                         uint32 bytes_in_buffer,
                                          int64 message_timestamp) {
   Delegate* delegate = delegates_.Lookup(stream_id);
   if (!delegate) {
@@ -73,7 +74,7 @@ void AudioMessageFilter::OnRequestPacket(const IPC::Message& msg,
 
 void AudioMessageFilter::OnStreamCreated(int stream_id,
                                          base::SharedMemoryHandle handle,
-                                         int length) {
+                                         uint32 length) {
   Delegate* delegate = delegates_.Lookup(stream_id);
   if (!delegate) {
     DLOG(WARNING) << "Got audio stream event for a non-existent or removed"
@@ -83,8 +84,9 @@ void AudioMessageFilter::OnStreamCreated(int stream_id,
   delegate->OnCreated(handle, length);
 }
 
-void AudioMessageFilter::OnStreamStateChanged(int stream_id,
-                                              ViewMsg_AudioStreamState state) {
+void AudioMessageFilter::OnStreamStateChanged(
+    int stream_id,
+    const ViewMsg_AudioStreamState_Params& state) {
   Delegate* delegate = delegates_.Lookup(stream_id);
   if (!delegate) {
     DLOG(WARNING) << "Got audio stream event for a non-existent or removed"
diff --git a/chrome/renderer/audio_message_filter.h b/chrome/renderer/audio_message_filter.h
index 8d1a0b5..3dfacdc 100644
--- a/chrome/renderer/audio_message_filter.h
+++ b/chrome/renderer/audio_message_filter.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 //
@@ -12,22 +12,26 @@
 
 #include "base/id_map.h"
 #include "base/shared_memory.h"
+#include "base/time.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
+struct ViewMsg_AudioStreamState_Params;
+
 class AudioMessageFilter : public IPC::ChannelProxy::MessageFilter {
  public:
   class Delegate {
    public:
     // Called when an audio packet is requested from the browser process.
-    virtual void OnRequestPacket(size_t bytes_in_buffer,
+    virtual void OnRequestPacket(uint32 bytes_in_buffer,
                                  const base::Time& message_timestamp) = 0;
 
     // Called when state of an audio stream has changed in the browser process.
-    virtual void OnStateChanged(ViewMsg_AudioStreamState state) = 0;
+    virtual void OnStateChanged(
+        const ViewMsg_AudioStreamState_Params& state) = 0;
 
     // Called when an audio stream has been created in the browser process.
-    virtual void OnCreated(base::SharedMemoryHandle handle, size_t length) = 0;
+    virtual void OnCreated(base::SharedMemoryHandle handle, uint32 length) = 0;
 
     // Called when notification of stream volume is received from the browser
     // process.
@@ -66,15 +70,16 @@ class AudioMessageFilter : public IPC::ChannelProxy::MessageFilter {
 
   // Received when browser process wants more audio packet.
   void OnRequestPacket(const IPC::Message& msg, int stream_id,
-                       size_t bytes_in_buffer, int64 message_timestamp);
+                       uint32 bytes_in_buffer, int64 message_timestamp);
 
   // Received when browser process has created an audio output stream.
   void OnStreamCreated(int stream_id, base::SharedMemoryHandle handle,
-                       int length);
+                       uint32 length);
 
   // Received when internal state of browser process' audio output device has
   // changed.
-  void OnStreamStateChanged(int stream_id, ViewMsg_AudioStreamState state);
+  void OnStreamStateChanged(int stream_id,
+                            const ViewMsg_AudioStreamState_Params& state);
 
   // Notification of volume property of an audio output stream.
   void OnStreamVolume(int stream_id, double volume);
diff --git a/chrome/renderer/audio_message_filter_unittest.cc b/chrome/renderer/audio_message_filter_unittest.cc
index 878b284..3dce864 100644
--- a/chrome/renderer/audio_message_filter_unittest.cc
+++ b/chrome/renderer/audio_message_filter_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -16,19 +16,19 @@ class MockAudioDelegate : public AudioMessageFilter::Delegate {
     Reset();
   }
 
-  virtual void OnRequestPacket(size_t bytes_in_buffer,
+  virtual void OnRequestPacket(uint32 bytes_in_buffer,
                                const base::Time& message_timestamp) {
     request_packet_received_ = true;
     bytes_in_buffer_ = bytes_in_buffer;
     message_timestamp_ = message_timestamp;
   }
 
-  virtual void OnStateChanged(ViewMsg_AudioStreamState state) {
+  virtual void OnStateChanged(const ViewMsg_AudioStreamState_Params& state) {
     state_changed_received_ = true;
     state_ = state;
   }
 
-  virtual void OnCreated(base::SharedMemoryHandle handle, size_t length) {
+  virtual void OnCreated(base::SharedMemoryHandle handle, uint32 length) {
     created_received_ = true;
     handle_ = handle;
     length_ = length;
@@ -45,7 +45,7 @@ class MockAudioDelegate : public AudioMessageFilter::Delegate {
     message_timestamp_ = base::Time();
 
     state_changed_received_ = false;
-    state_.state = ViewMsg_AudioStreamState::kError;
+    state_.state = ViewMsg_AudioStreamState_Params::kError;
 
     created_received_ = false;
     handle_ = base::SharedMemory::NULLHandle();
@@ -56,30 +56,30 @@ class MockAudioDelegate : public AudioMessageFilter::Delegate {
   }
 
   bool request_packet_received() { return request_packet_received_; }
-  size_t bytes_in_buffer() { return bytes_in_buffer_; }
+  uint32 bytes_in_buffer() { return bytes_in_buffer_; }
   const base::Time& message_timestamp() { return message_timestamp_; }
 
   bool state_changed_received() { return state_changed_received_; }
-  ViewMsg_AudioStreamState state() { return state_; }
+  ViewMsg_AudioStreamState_Params state() { return state_; }
 
   bool created_received() { return created_received_; }
   base::SharedMemoryHandle handle() { return handle_; }
-  size_t length() { return length_; }
+  uint32 length() { return length_; }
 
   bool volume_received() { return volume_received_; }
   double volume() { return volume_; }
 
  private:
   bool request_packet_received_;
-  size_t bytes_in_buffer_;
+  uint32 bytes_in_buffer_;
   base::Time message_timestamp_;
 
   bool state_changed_received_;
-  ViewMsg_AudioStreamState state_;
+  ViewMsg_AudioStreamState_Params state_;
 
   bool created_received_;
   base::SharedMemoryHandle handle_;
-  size_t length_;
+  uint32 length_;
 
   bool volume_received_;
   double volume_;
@@ -99,7 +99,7 @@ TEST(AudioMessageFilterTest, Basic) {
   int stream_id = filter->AddDelegate(&delegate);
 
   // ViewMsg_RequestAudioPacket
-  const size_t kSizeInBuffer = 1024;
+  const uint32 kSizeInBuffer = 1024;
   const int64 kMessageTimestamp = 99;
   EXPECT_FALSE(delegate.request_packet_received());
   filter->OnMessageReceived(ViewMsg_RequestAudioPacket(kRouteId,
@@ -112,8 +112,8 @@ TEST(AudioMessageFilterTest, Basic) {
   delegate.Reset();
 
   // ViewMsg_NotifyAudioStreamStateChanged
-  const ViewMsg_AudioStreamState kState =
-      { ViewMsg_AudioStreamState::kPlaying };
+  const ViewMsg_AudioStreamState_Params kState =
+      { ViewMsg_AudioStreamState_Params::kPlaying };
   EXPECT_FALSE(delegate.state_changed_received());
   filter->OnMessageReceived(
       ViewMsg_NotifyAudioStreamStateChanged(kRouteId, stream_id, kState));
@@ -122,7 +122,7 @@ TEST(AudioMessageFilterTest, Basic) {
   delegate.Reset();
 
   // ViewMsg_NotifyAudioStreamCreated
-  const size_t kLength = 1024;
+  const uint32 kLength = 1024;
   EXPECT_FALSE(delegate.created_received());
   filter->OnMessageReceived(
       ViewMsg_NotifyAudioStreamCreated(kRouteId,
diff --git a/chrome/renderer/media/audio_renderer_impl.cc b/chrome/renderer/media/audio_renderer_impl.cc
index f10ff37..3aba1c1 100644
--- a/chrome/renderer/media/audio_renderer_impl.cc
+++ b/chrome/renderer/media/audio_renderer_impl.cc
@@ -1,12 +1,13 @@
-// 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.
+// 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.
+
+#include "chrome/renderer/media/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/audio_message_filter.h"
-#include "chrome/renderer/media/audio_renderer_impl.h"
 #include "chrome/renderer/render_view.h"
 #include "chrome/renderer/render_thread.h"
 #include "media/base/filter_host.h"
@@ -76,8 +77,8 @@ bool AudioRendererImpl::OnInitialize(const media::MediaFormat& media_format) {
 
   // Create the audio output stream in browser process.
   bytes_per_second_ = sample_rate_ * channels_ * sample_bits_ / 8;
-  size_t packet_size = bytes_per_second_ * kMillisecondsPerPacket / 1000;
-  size_t buffer_capacity = packet_size * kPacketsInBuffer;
+  uint32 packet_size = bytes_per_second_ * kMillisecondsPerPacket / 1000;
+  uint32 buffer_capacity = packet_size * kPacketsInBuffer;
 
   // Calculate the amount for prerolling.
   preroll_bytes_ = bytes_per_second_ * kMillisecondsPreroll / 1000;
@@ -161,7 +162,7 @@ void AudioRendererImpl::SetVolume(float volume) {
 }
 
 void AudioRendererImpl::OnCreated(base::SharedMemoryHandle handle,
-                                  size_t length) {
+                                  uint32 length) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   AutoLock auto_lock(lock_);
@@ -173,7 +174,7 @@ void AudioRendererImpl::OnCreated(base::SharedMemoryHandle handle,
   shared_memory_size_ = length;
 }
 
-void AudioRendererImpl::OnRequestPacket(size_t bytes_in_buffer,
+void AudioRendererImpl::OnRequestPacket(uint32 bytes_in_buffer,
                                         const base::Time& message_timestamp) {
   DCHECK(MessageLoop::current() == io_loop_);
 
@@ -192,7 +193,8 @@ void AudioRendererImpl::OnRequestPacket(size_t bytes_in_buffer,
   OnNotifyPacketReady();
 }
 
-void AudioRendererImpl::OnStateChanged(ViewMsg_AudioStreamState state) {
+void AudioRendererImpl::OnStateChanged(
+    const ViewMsg_AudioStreamState_Params& state) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   AutoLock auto_lock(lock_);
@@ -200,7 +202,7 @@ void AudioRendererImpl::OnStateChanged(ViewMsg_AudioStreamState state) {
     return;
 
   switch (state.state) {
-    case ViewMsg_AudioStreamState::kError:
+    case ViewMsg_AudioStreamState_Params::kError:
       // We receive this error if we counter an hardware error on the browser
       // side. We can proceed with ignoring the audio stream.
       // TODO(hclam): We need more handling of these kind of error. For example
@@ -209,8 +211,8 @@ void AudioRendererImpl::OnStateChanged(ViewMsg_AudioStreamState state) {
       host()->BroadcastMessage(media::kMsgDisableAudio);
       break;
     // TODO(hclam): handle these events.
-    case ViewMsg_AudioStreamState::kPlaying:
-    case ViewMsg_AudioStreamState::kPaused:
+    case ViewMsg_AudioStreamState_Params::kPlaying:
+    case ViewMsg_AudioStreamState_Params::kPaused:
       break;
     default:
       NOTREACHED();
@@ -225,7 +227,7 @@ void AudioRendererImpl::OnVolume(double volume) {
 
 void AudioRendererImpl::OnCreateStream(
     AudioManager::Format format, int channels, int sample_rate,
-    int bits_per_sample, size_t packet_size, size_t buffer_capacity) {
+    int bits_per_sample, uint32 packet_size, uint32 buffer_capacity) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   AutoLock auto_lock(lock_);
@@ -237,7 +239,7 @@ void AudioRendererImpl::OnCreateStream(
   stream_id_ = filter_->AddDelegate(this);
   io_loop_->AddDestructionObserver(this);
 
-  ViewHostMsg_Audio_CreateStream params;
+  ViewHostMsg_Audio_CreateStream_Params params;
   params.format = format;
   params.channels = channels;
   params.sample_rate = sample_rate;
@@ -324,7 +326,7 @@ void AudioRendererImpl::OnNotifyPacketReady() {
                                   GetPlaybackRate())));
     }
 
-    size_t filled = FillBuffer(static_cast<uint8*>(shared_memory_->memory()),
+    uint32 filled = FillBuffer(static_cast<uint8*>(shared_memory_->memory()),
                                shared_memory_size_,
                                request_delay);
     // TODO(hclam): we should try to fill in the buffer as much as possible.
diff --git a/chrome/renderer/media/audio_renderer_impl.h b/chrome/renderer/media/audio_renderer_impl.h
index 01885be..2c4d990 100644
--- a/chrome/renderer/media/audio_renderer_impl.h
+++ b/chrome/renderer/media/audio_renderer_impl.h
@@ -1,6 +1,6 @@
-// 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.
+// 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.
 //
 // Audio rendering unit utilizing audio output stream provided by browser
 // process through IPC.
@@ -118,10 +118,10 @@ class AudioRendererImpl : public media::AudioRendererBase,
 
   // Methods called on IO thread ----------------------------------------------
   // AudioMessageFilter::Delegate methods, called by AudioMessageFilter.
-  void OnRequestPacket(size_t bytes_in_buffer,
+  void OnRequestPacket(uint32 bytes_in_buffer,
                        const base::Time& message_timestamp);
-  void OnStateChanged(ViewMsg_AudioStreamState state);
-  void OnCreated(base::SharedMemoryHandle handle, size_t length);
+  void OnStateChanged(const ViewMsg_AudioStreamState_Params& state);
+  void OnCreated(base::SharedMemoryHandle handle, uint32 length);
   void OnVolume(double volume);
 
   // Methods called on pipeline thread ----------------------------------------
@@ -163,7 +163,7 @@ class AudioRendererImpl : public media::AudioRendererBase,
   // sends IPC messages on that thread.
   void OnCreateStream(AudioManager::Format format, int channels,
                       int sample_rate, int bits_per_sample,
-                      size_t packet_size, size_t buffer_capacity);
+                      uint32 packet_size, uint32 buffer_capacity);
   void OnPlay();
   void OnPause();
   void OnSetVolume(double volume);
@@ -177,7 +177,7 @@ class AudioRendererImpl : public media::AudioRendererBase,
   int channels_;
   int sample_rate_;
   int sample_bits_;
-  size_t bytes_per_second_;
+  uint32 bytes_per_second_;
 
   scoped_refptr<AudioMessageFilter> filter_;
 
@@ -186,7 +186,7 @@ class AudioRendererImpl : public media::AudioRendererBase,
 
   // Memory shared by the browser process for audio buffer.
   scoped_ptr<base::SharedMemory> shared_memory_;
-  size_t shared_memory_size_;
+  uint32 shared_memory_size_;
 
   // Message loop for the IO thread.
   MessageLoop* io_loop_;
@@ -214,7 +214,7 @@ class AudioRendererImpl : public media::AudioRendererBase,
   bool prerolling_;
 
   // Remaining bytes for prerolling to complete.
-  size_t preroll_bytes_;
+  uint32 preroll_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererImpl);
 };
diff --git a/chrome/renderer/media/audio_renderer_impl_unittest.cc b/chrome/renderer/media/audio_renderer_impl_unittest.cc
index 1dda05d..5b823e8 100644
--- a/chrome/renderer/media/audio_renderer_impl_unittest.cc
+++ b/chrome/renderer/media/audio_renderer_impl_unittest.cc
@@ -100,12 +100,12 @@ TEST_F(AudioRendererImplTest, SetVolume) {
 
 TEST_F(AudioRendererImplTest, Stop) {
   // Declare some state messages.
-  const ViewMsg_AudioStreamState kError =
-      { ViewMsg_AudioStreamState::kError };
-  const ViewMsg_AudioStreamState kPlaying =
-      { ViewMsg_AudioStreamState::kPlaying };
-  const ViewMsg_AudioStreamState kPaused =
-      { ViewMsg_AudioStreamState::kPaused };
+  const ViewMsg_AudioStreamState_Params kError =
+      { ViewMsg_AudioStreamState_Params::kError };
+  const ViewMsg_AudioStreamState_Params kPlaying =
+      { ViewMsg_AudioStreamState_Params::kPlaying };
+  const ViewMsg_AudioStreamState_Params kPaused =
+      { ViewMsg_AudioStreamState_Params::kPaused };
 
   // Execute Stop() codepath to create an IPC message.
   renderer_->Stop();
diff --git a/chrome/renderer/pepper_devices.cc b/chrome/renderer/pepper_devices.cc
index ff39088..3b14d16 100644
--- a/chrome/renderer/pepper_devices.cc
+++ b/chrome/renderer/pepper_devices.cc
@@ -107,7 +107,7 @@ NPError AudioDeviceContext::Initialize(
   DCHECK_EQ(0, stream_id_);
   stream_id_ = filter_->AddDelegate(this);
 
-  ViewHostMsg_Audio_CreateStream params;
+  ViewHostMsg_Audio_CreateStream_Params params;
   params.format = AudioManager::AUDIO_PCM_LINEAR;
   params.channels = config->outputChannelMap;
   params.sample_rate = config->sampleRate;
@@ -146,18 +146,18 @@ void AudioDeviceContext::OnDestroy() {
 }
 
 void AudioDeviceContext::OnRequestPacket(
-    size_t bytes_in_buffer, const base::Time& message_timestamp) {
+    uint32 bytes_in_buffer, const base::Time& message_timestamp) {
   context_->config.callback(context_);
   filter_->Send(new ViewHostMsg_NotifyAudioPacketReady(0, stream_id_,
                                                         shared_memory_size_));
 }
 
 void AudioDeviceContext::OnStateChanged(
-    ViewMsg_AudioStreamState state) {
+    const ViewMsg_AudioStreamState_Params& state) {
 }
 
 void AudioDeviceContext::OnCreated(
-    base::SharedMemoryHandle handle, size_t length) {
+    base::SharedMemoryHandle handle, uint32 length) {
   shared_memory_.reset(new base::SharedMemory(handle, false));
   shared_memory_->Map(length);
   shared_memory_size_ = length;
diff --git a/chrome/renderer/pepper_devices.h b/chrome/renderer/pepper_devices.h
index 1abd554..31a2d11 100644
--- a/chrome/renderer/pepper_devices.h
+++ b/chrome/renderer/pepper_devices.h
@@ -58,10 +58,10 @@ class AudioDeviceContext : public AudioMessageFilter::Delegate {
                      NPDeviceContextAudio* context);
 
   // AudioMessageFilter::Delegate implementation
-  virtual void OnRequestPacket(size_t bytes_in_buffer,
+  virtual void OnRequestPacket(uint32 bytes_in_buffer,
                                const base::Time& message_timestamp);
-  virtual void OnStateChanged(ViewMsg_AudioStreamState state);
-  virtual void OnCreated(base::SharedMemoryHandle handle, size_t length);
+  virtual void OnStateChanged(const ViewMsg_AudioStreamState_Params& state);
+  virtual void OnCreated(base::SharedMemoryHandle handle, uint32 length);
   virtual void OnVolume(double volume);
   // End of AudioMessageFilter::Delegate implementation
 
@@ -74,7 +74,7 @@ class AudioDeviceContext : public AudioMessageFilter::Delegate {
   scoped_refptr<AudioMessageFilter> filter_;
   int32 stream_id_;
   scoped_ptr<base::SharedMemory> shared_memory_;
-  size_t shared_memory_size_;
+  uint32 shared_memory_size_;
 };
 
 #endif  // CHROME_RENDERER_PEPPER_DEVICES_H_