Merge AssociateStreamWithProducer message into CreateStream message for both audio output and input.

content/browser/renderer_host/media/audio_renderer_host.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 "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/process.h"
@@ skipping 24 matching lines @@
              scoped_ptr<media::AudioOutputController::SyncReader> reader);
   virtual ~AudioEntry();
 
   int stream_id() const {
     return stream_id_;
   }
 
   int render_view_id() const {
     return render_view_id_;
   }
-  // TODO(miu): Remove this setter once my IPC clean-up change (in code review)
-  // lands!
-  void set_render_view_id(int render_view_id) {
-    render_view_id_ = render_view_id;
-  }
 
   media::AudioOutputController* controller() const {
     return controller_;
   }
 
   base::SharedMemory* shared_memory() {
     return shared_memory_.get();
   }
 
   media::AudioOutputController::SyncReader* reader() const {
     return reader_.get();
   }
 
  private:
   // media::AudioOutputController::EventHandler implementation.
   virtual void OnCreated() OVERRIDE;
   virtual void OnPlaying() OVERRIDE;
   virtual void OnAudible(bool is_audible) OVERRIDE;
   virtual void OnPaused() OVERRIDE;
   virtual void OnError() OVERRIDE;
   virtual void OnDeviceChange(int new_buffer_size, int new_sample_rate)
       OVERRIDE;
 
   AudioRendererHost* const host_;
   const int stream_id_;
 
   // The routing ID of the source render view.
-  int render_view_id_;
+  const int render_view_id_;
 
   // The AudioOutputController that manages the audio stream.
   const scoped_refptr<media::AudioOutputController> controller_;
 
   // Shared memory for transmission of the audio data.
   const scoped_ptr<base::SharedMemory> shared_memory_;
 
   // The synchronous reader to be used by the controller.
   const scoped_ptr<media::AudioOutputController::SyncReader> reader_;
 };
@@ skipping 162 matching lines @@
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // IPC Messages handler
 bool AudioRendererHost::OnMessageReceived(const IPC::Message& message,
                                           bool* message_was_ok) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(AudioRendererHost, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(AudioHostMsg_CreateStream, OnCreateStream)
-    IPC_MESSAGE_HANDLER(AudioHostMsg_AssociateStreamWithProducer,
-                        OnAssociateStreamWithProducer)
     IPC_MESSAGE_HANDLER(AudioHostMsg_PlayStream, OnPlayStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_PauseStream, OnPauseStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_CloseStream, OnCloseStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_SetVolume, OnSetVolume)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   return handled;
 }
 
 void AudioRendererHost::OnCreateStream(
-    int stream_id, const media::AudioParameters& params) {
+    int stream_id, int render_view_id, const media::AudioParameters& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  DVLOG(1) << "AudioRendererHost@" << this
+           << "::OnCreateStream(stream_id=" << stream_id
+           << ", render_view_id=" << render_view_id << ")";
+  DCHECK_GT(render_view_id, 0);
+
   // media::AudioParameters is validated in the deserializer.
   int input_channels = params.input_channels();
   if (input_channels < 0 ||
       input_channels > media::limits::kMaxChannels ||
       LookupById(stream_id) != NULL) {
     SendErrorMessage(stream_id);
     return;
   }
 
   // Calculate output and input memory size.
@@ skipping 14 matching lines @@
     return;
   }
 
   scoped_ptr<AudioSyncReader> reader(
       new AudioSyncReader(shared_memory.get(), params, input_channels));
   if (!reader->Init()) {
     SendErrorMessage(stream_id);
     return;
   }
 
-  audio_entries_.insert(std::make_pair(stream_id, new AudioEntry(
-      this, stream_id, MSG_ROUTING_NONE, params, shared_memory.Pass(),
-      reader.PassAs<media::AudioOutputController::SyncReader>())));
-
+  scoped_ptr<AudioEntry> entry(new AudioEntry(
+      this, stream_id, render_view_id, params, shared_memory.Pass(),
+      reader.PassAs<media::AudioOutputController::SyncReader>()));
+  if (mirroring_manager_) {
+    mirroring_manager_->AddDiverter(
+        render_process_id_, entry->render_view_id(), entry->controller());
+  }
+  audio_entries_.insert(std::make_pair(stream_id, entry.release()));
   if (media_internals_)
     media_internals_->OnSetAudioStreamStatus(this, stream_id, "created");
 }
 
-void AudioRendererHost::OnAssociateStreamWithProducer(int stream_id,
-                                                      int render_view_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  DVLOG(1) << "AudioRendererHost@" << this
-           << "::OnAssociateStreamWithProducer(stream_id=" << stream_id
-           << ", render_view_id=" << render_view_id << ")";
-
-  AudioEntry* const entry = LookupById(stream_id);
-  if (!entry) {
-    SendErrorMessage(stream_id);
-    return;
-  }
-
-  if (entry->render_view_id() == render_view_id)
-    return;
-
-  // TODO(miu): Merge "AssociateWithProducer" message into "CreateStream"
-  // message so AudioRendererHost can assume a simpler "render_view_id is set
-  // once" scheme. http://crbug.com/166779
-  if (mirroring_manager_) {
-    mirroring_manager_->RemoveDiverter(
-        render_process_id_, entry->render_view_id(), entry->controller());
-  }
-  entry->set_render_view_id(render_view_id);
-  if (mirroring_manager_) {
-    mirroring_manager_->AddDiverter(
-        render_process_id_, entry->render_view_id(), entry->controller());
-  }
-}
-
 void AudioRendererHost::OnPlayStream(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntry* entry = LookupById(stream_id);
   if (!entry) {
     SendErrorMessage(stream_id);
     return;
   }
 
   entry->controller()->Play();
@@ skipping 96 matching lines @@
 }
 
 AudioRendererHost::AudioEntry* AudioRendererHost::LookupById(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntryMap::const_iterator i = audio_entries_.find(stream_id);
   return i != audio_entries_.end() ? i->second : NULL;
 }
 
 }  // namespace content