Add mojo interface+impl for audio stream control.

media/mojo/services/mojo_audio_output_stream.cc

Index: media/mojo/services/mojo_audio_output_stream.cc
diff --git a/media/mojo/services/mojo_audio_output_stream.cc b/media/mojo/services/mojo_audio_output_stream.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1be3171295cd7ef8c92b82afaf84dbbd656be57d
--- /dev/null
+++ b/media/mojo/services/mojo_audio_output_stream.cc
@@ -0,0 +1,94 @@
+// 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.
+
+#include "media/mojo/services/mojo_audio_output_stream.h"
+
+#include <memory>
+#include <utility>
+
+#include "base/callback_helpers.h"
+#include "base/memory/shared_memory.h"
+#include "base/sync_socket.h"
+#include "mojo/public/cpp/system/platform_handle.h"
+
+namespace media {
+
+MojoAudioOutputStream::MojoAudioOutputStream(
+    mojom::AudioOutputStreamRequest request,
+    CreateDelegateCallback create_delegate_callback,
+    StreamCreatedCallback stream_created_callback,
+    base::OnceClosure deleter_callback)
+    : stream_created_callback_(std::move(stream_created_callback)),
+      deleter_callback_(std::move(deleter_callback)),
+      binding_(this, std::move(request)) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(deleter_callback_);
+  // |this| owns |binding_|, so unretained is safe.
+  binding_.set_connection_error_handler(
+      base::Bind(&MojoAudioOutputStream::OnError, base::Unretained(this)));
+  delegate_ = std::move(create_delegate_callback).Run(this);
+}
+
+MojoAudioOutputStream::~MojoAudioOutputStream() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+void MojoAudioOutputStream::Play() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  delegate_->OnPlayStream();
+}
+
+void MojoAudioOutputStream::Pause() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  delegate_->OnPauseStream();
+}
+
+void MojoAudioOutputStream::SetVolume(double volume) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (volume < 0 || volume > 1) {
+    LOG(ERROR) << "MojoAudioOutputStream::SetVolume(" << volume
+               << ") out of range.";
+    OnError();
+    return;
+  }
+  delegate_->OnSetVolume(volume);
+}
+
+void MojoAudioOutputStream::OnStreamCreated(
+    int stream_id,
+    base::SharedMemory* shared_memory,
+    base::CancelableSyncSocket* foreign_socket) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(stream_created_callback_);
+  DCHECK(shared_memory);
+  DCHECK(foreign_socket);
+
+  base::SharedMemoryHandle foreign_memory_handle =
+      base::SharedMemory::DuplicateHandle(shared_memory->handle());
+  DCHECK(base::SharedMemory::IsHandleValid(foreign_memory_handle));
+
+  mojo::ScopedSharedBufferHandle buffer_handle = mojo::WrapSharedMemoryHandle(
+      foreign_memory_handle, shared_memory->requested_size(), false);
+  mojo::ScopedHandle socket_handle =
+      mojo::WrapPlatformFile(foreign_socket->handle());
+
+  DCHECK(buffer_handle.is_valid());
+  DCHECK(socket_handle.is_valid());
+
+  base::ResetAndReturn(&stream_created_callback_)
+      .Run(std::move(buffer_handle), std::move(socket_handle));
+}
+
+void MojoAudioOutputStream::OnStreamError(int stream_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  OnError();
+}
+
+void MojoAudioOutputStream::OnError() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(deleter_callback_);
+  std::move(deleter_callback_).Run();  // Deletes |this|.
+}
+
+}  // namespace media