Add a mojo implementation of AudioOutputIPC.

content/renderer/media/audio_ipc_factory.h

+// Copyright 2017 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.
+
+#ifndef CONTENT_RENDERER_MEDIA_AUDIO_IPC_FACTORY_H_
+#define CONTENT_RENDERER_MEDIA_AUDIO_IPC_FACTORY_H_
+
+#include <memory>
+
+#include "base/containers/flat_map.h"
+#include "base/memory/ref_counted.h"
+#include "content/common/media/renderer_audio_output_stream_factory.mojom.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
+
+namespace media {
+class AudioOutputIPC;
+}
+
+namespace content {
+
+class AudioMessageFilter;
+
+// This is a factory for AudioOutputIPC objects. It has two modes, using either
+// AudioMessageFilter or Mojo RendererAudioOutputStreamFactory objects.
+class AudioIPCFactory {
+ public:
+  AudioIPCFactory(
+      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
+      AudioMessageFilter* audio_message_filter);
+  ~AudioIPCFactory();
+
+  // The following functions may be called on any thread:

[o1ka, 2017/05/11 10:58:40]

All public functions? Then move it to the class-level comment?

[Max Morin, 2017/05/11 15:31:17]

Done.

+
+  static AudioIPCFactory* get() { return instance_; }
+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner() const {

[o1ka, 2017/05/11 10:58:40]

Return a pointer?

[Max Morin, 2017/05/11 15:31:17]

I prefer this, since it clearly show the ownership is being shared with the
caller.

[o1ka, 2017/05/15 13:27:08]

It's up to the caller do decide if there is a need to share ownership, right?
Why to mess up with refs if the caller just wants to post a message?

[Max Morin, 2017/05/16 15:51:35]

In general, converting from * to an owning pointer is unexpected. If an API
returns a raw pointer, it looks like it doesn't share ownership, so if someone
takes ownership through that API anyways it could cause issues if the
implementation expects to not share the object. In this case, performance gains
are 0, since all callers of this method take ownership of the task runner.

+    return io_task_runner_;
+  }
+
+  // Indicates whether mojo factories are used. In this case, frames have to
+  // call Register/UnregisterRemoteFactory.
+  bool UsingMojoFactories() const;
+
+  // Enables |this| to create MojoAudioOutputIPCs for the specified frame.
+  // Should only be called when UsingMojoFactories().
+  void RegisterRemoteFactory(
+      int frame_id,
+      mojom::RendererAudioOutputStreamFactoryPtr factory);
+
+  // Every call to the above method must be matched by a call to this one when
+  // the frame is destroyed.
+  void MaybeDeregisterRemoteFactory(int frame_id);
+
+  // The returned object may only be used on |io_task_runner()|.
+  std::unique_ptr<media::AudioOutputIPC> CreateAudioOutputIPC(
+      int frame_id) const;
+
+ private:
+  using StreamFactoryMap =
+      base::flat_map<int, mojom::RendererAudioOutputStreamFactoryPtr>;
+
+  mojom::RendererAudioOutputStreamFactory* GetRemoteFactory(int frame_id) const;
+
+  void RegisterRemoteFactoryOnIOThread(
+      int frame_id,
+      mojom::RendererAudioOutputStreamFactoryPtrInfo factory_ptr_info);
+
+  // Maps frame id to the corresponding factory.
+  StreamFactoryMap factory_ptrs_;
+
+  // If this is non-null, it will be used rather than using mojo implementation.
+  AudioMessageFilter* audio_message_filter_;

[o1ka, 2017/05/11 10:58:40]

const?

[Max Morin, 2017/05/11 15:31:17]

Done.

+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+
+  // Global instance, set in constructor and unset in destructor.
+  static AudioIPCFactory* instance_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_MEDIA_AUDIO_IPC_FACTORY_H_