Implements AudioMessageFilter as member in RenderThread

content/renderer/pepper_plugin_delegate_impl.cc

 // Copyright (c) 2011 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/renderer/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <queue>
 
 #include "base/callback.h"
@@ skipping 141 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PlatformImage2DImpl);
 };
 
 
 class PlatformAudioImpl
     : public webkit::ppapi::PluginDelegate::PlatformAudio,
       public AudioMessageFilter::Delegate,
       public base::RefCountedThreadSafe<PlatformAudioImpl> {
  public:
-  explicit PlatformAudioImpl(scoped_refptr<AudioMessageFilter> filter)
+  enum RoutingID {
+    DEFAULT_ROUTING_ID = 2,
+  };
+
+  explicit PlatformAudioImpl(AudioMessageFilter* filter)
       : client_(NULL), filter_(filter), stream_id_(0),
         main_message_loop_(MessageLoop::current()) {
     DCHECK(filter_);
+    if (!filter_->RoutingIDHasBeenSet()) {
+      // Ensure that first user sets a valid routing ID.
+      // This routing ID will remain during the lifetime of the audio message
+      // filter (which is a singleton).
+      filter_->SetRoutingID(DEFAULT_ROUTING_ID);

[jam, 2011/06/21 19:02:04]

you can't just pick a routing a id in the renderer process, since this is most
likely already used by a renderer.

stepping back a bit, it's not clear to me why a routing_id is needed.  It looks
like this logic was copied from RenderView.  That's a different situation, and
is used because it's convenient for code to call RenderView's Send() without
knowing the RenderView's routing id.  The IPC message needs a routing id though,
because that's how it's matched to a unique RenderViewHost in the browser
process.

In the case of a singleton in the renderer that only talks to one object in the
browser per renderer process, there's no need to have routing IDs.  You should
use control messages.  Please have a look at
http://dev.chromium.org/developers/design-documents/inter-process-communication.

+    }
   }
 
   virtual ~PlatformAudioImpl() {
     // Make sure we have been shut down. Warning: this will usually happen on
     // the I/O thread!
     DCHECK_EQ(0, stream_id_);
     DCHECK(!client_);
   }
 
   // Initialize this audio context. StreamCreated() will be called when the
@@ skipping 28 matching lines @@
                                    uint32 length);
 
   virtual void OnVolume(double volume) {}
 
   // The client to notify when the stream is created. THIS MUST ONLY BE
   // ACCESSED ON THE MAIN THREAD.
   webkit::ppapi::PluginDelegate::PlatformAudio::Client* client_;
 
   // MessageFilter used to send/receive IPC. THIS MUST ONLY BE ACCESSED ON THE
   // I/O thread except to send messages and get the message loop.
-  scoped_refptr<AudioMessageFilter> filter_;
+  // Cached result of Singleton<AudioMessageFilter>::get() to reduce overhead.
+  AudioMessageFilter* filter_;
 
   // Our ID on the MessageFilter. THIS MUST ONLY BE ACCESSED ON THE I/O THREAD
   // or else you could race with the initialize function which sets it.
   int32 stream_id_;
 
   MessageLoop* main_message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAudioImpl);
 };
 
@@ skipping 618 matching lines @@
                                                          int index) {
   render_view_->reportFindInPageSelection(
       identifier, index + 1, WebKit::WebRect());
 }
 
 webkit::ppapi::PluginDelegate::PlatformAudio*
 PepperPluginDelegateImpl::CreateAudio(
     uint32_t sample_rate, uint32_t sample_count,
     webkit::ppapi::PluginDelegate::PlatformAudio::Client* client) {
   scoped_refptr<PlatformAudioImpl> audio(
-      new PlatformAudioImpl(render_view_->audio_message_filter()));
+      new PlatformAudioImpl(AudioMessageFilter::GetInstance()));

[scherkus (not reviewing), 2011/06/21 17:24:00]

since you have render_view object, why not use its routing_id() ?

   if (audio->Initialize(sample_rate, sample_count, client)) {
     // Balanced by Release invoked in PlatformAudioImpl::ShutDownOnIOThread().
     return audio.release();
   } else {
     return NULL;
   }
 }
 
 // If a broker has not already been created for this plugin, creates one.
 webkit::ppapi::PluginDelegate::PpapiBroker*
@@ skipping 118 matching lines @@
 }
 
 bool PepperPluginDelegateImpl::ReadDirectory(
     const GURL& directory_path,
     fileapi::FileSystemCallbackDispatcher* dispatcher) {
   FileSystemDispatcher* file_system_dispatcher =
       ChildThread::current()->file_system_dispatcher();
   return file_system_dispatcher->ReadDirectory(directory_path, dispatcher);
 }
 
-class AsyncOpenFileSystemURLCallbackTranslator :
-    public fileapi::FileSystemCallbackDispatcher {
-public:
+class AsyncOpenFileSystemURLCallbackTranslator
+    : public fileapi::FileSystemCallbackDispatcher {
+ public:
   AsyncOpenFileSystemURLCallbackTranslator(
       webkit::ppapi::PluginDelegate::AsyncOpenFileCallback* callback)
     : callback_(callback) {
   }
 
   virtual ~AsyncOpenFileSystemURLCallbackTranslator() {}
 
   virtual void DidSucceed() {
     NOTREACHED();
   }
@@ skipping 323 matching lines @@
   if (!base::SharedMemory::IsHandleValid(handle)) {
     DLOG(WARNING) << "Browser failed to allocate shared memory";
     return NULL;
   }
   return new base::SharedMemory(handle, false);
 }
 
 ppapi::Preferences PepperPluginDelegateImpl::GetPreferences() {
   return ppapi::Preferences(render_view_->webkit_preferences());
 }