Convert audo::UserInputMonitor from WrapReadOnlySharedMemoryRegion to the mojom type.

Bug: 778325
Change-Id: I2ab991daf1eac20daed33feb6009b3cebe4c446e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2065590Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Commit-Queue: Robert Sesek <rsesek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#743173}

content/browser/media/audio_input_stream_broker.cc

@@ -23,7 +23,6 @@
 #include "media/audio/audio_logging.h"
 #include "media/base/media_switches.h"
 #include "media/base/user_input_monitor.h"
-#include "mojo/public/cpp/system/platform_handle.h"
 
 #if defined(OS_CHROMEOS)
 #include "content/browser/media/keyboard_mic_registration.h"
@@ -173,8 +172,7 @@ void AudioInputStreamBroker::CreateStream(
           media::AudioLogFactory::AudioComponent::AUDIO_INPUT_CONTROLLER,
           log_component_id, render_process_id(), render_frame_id()),
       device_id_, params_, shared_memory_count_, enable_agc_,
-      mojo::WrapReadOnlySharedMemoryRegion(std::move(key_press_count_buffer)),
-      std::move(processing_config_),
+      std::move(key_press_count_buffer), std::move(processing_config_),
       base::BindOnce(&AudioInputStreamBroker::StreamCreated,
                      weak_ptr_factory_.GetWeakPtr(), std::move(stream)));
 }

content/browser/media/audio_input_stream_broker_unittest.cc

@@ -15,7 +15,6 @@
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
-#include "mojo/public/cpp/system/platform_handle.h"
 #include "services/audio/public/cpp/fake_stream_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -100,7 +99,7 @@ class MockStreamFactory : public audio::FakeStreamFactory {
     const media::AudioParameters params;
     uint32_t shared_memory_count;
     bool enable_agc;
-    mojo::ScopedSharedBufferHandle key_press_count_buffer;
+    base::ReadOnlySharedMemoryRegion key_press_count_buffer;
     CreateInputStreamCallback created_callback;
   };
 
@@ -118,7 +117,7 @@ class MockStreamFactory : public audio::FakeStreamFactory {
       const media::AudioParameters& params,
       uint32_t shared_memory_count,
       bool enable_agc,
-      mojo::ScopedSharedBufferHandle key_press_count_buffer,
+      base::ReadOnlySharedMemoryRegion key_press_count_buffer,
       audio::mojom::AudioProcessingConfigPtr processing_config,
       CreateInputStreamCallback created_callback) override {
     // No way to cleanly exit the test here in case of failure, so use CHECK.

content/browser/renderer_host/media/render_frame_audio_input_stream_factory_unittest.cc

@@ -106,7 +106,7 @@ class MAYBE_RenderFrameAudioInputStreamFactoryTest
         const media::AudioParameters& params,
         uint32_t shared_memory_count,
         bool enable_agc,
-        mojo::ScopedSharedBufferHandle key_press_count_buffer,
+        base::ReadOnlySharedMemoryRegion key_press_count_buffer,
         audio::mojom::AudioProcessingConfigPtr processing_config,
         CreateInputStreamCallback created_callback) override {
       last_created_callback = std::move(created_callback);

services/audio/input_stream_unittest.cc

@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/read_only_shared_memory_region.h"
 #include "base/test/task_environment.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/mock_audio_manager.h"
@@ -144,8 +145,8 @@ class AudioServiceInputStreamTest : public testing::Test {
         remote_stream.InitWithNewPipeAndPassReceiver(), client_.MakeRemote(),
         observer_.MakeRemote(), log_.MakeRemote(), kDefaultDeviceId,
         media::AudioParameters::UnavailableDeviceParams(),
-        kDefaultSharedMemoryCount, enable_agc, mojo::ScopedSharedBufferHandle(),
-        nullptr,
+        kDefaultSharedMemoryCount, enable_agc,
+        base::ReadOnlySharedMemoryRegion(), nullptr,
         base::BindOnce(&AudioServiceInputStreamTest::OnCreated,
                        base::Unretained(this)));
     return remote_stream;
@@ -158,7 +159,7 @@ class AudioServiceInputStreamTest : public testing::Test {
         remote_stream.InitWithNewPipeAndPassReceiver(), client_.MakeRemote(),
         observer_.MakeRemote(), mojo::NullRemote(), kDefaultDeviceId,
         media::AudioParameters::UnavailableDeviceParams(),
-        kDefaultSharedMemoryCount, false, mojo::ScopedSharedBufferHandle(),
+        kDefaultSharedMemoryCount, false, base::ReadOnlySharedMemoryRegion(),
         nullptr,
         base::BindOnce(&AudioServiceInputStreamTest::OnCreated,
                        base::Unretained(this)));
@@ -172,7 +173,7 @@ class AudioServiceInputStreamTest : public testing::Test {
         remote_stream.InitWithNewPipeAndPassReceiver(), client_.MakeRemote(),
         mojo::NullRemote(), log_.MakeRemote(), kDefaultDeviceId,
         media::AudioParameters::UnavailableDeviceParams(),
-        kDefaultSharedMemoryCount, false, mojo::ScopedSharedBufferHandle(),
+        kDefaultSharedMemoryCount, false, base::ReadOnlySharedMemoryRegion(),
         nullptr,
         base::BindOnce(&AudioServiceInputStreamTest::OnCreated,
                        base::Unretained(this)));

services/audio/public/cpp/fake_stream_factory.h

@@ -50,7 +50,7 @@ class FakeStreamFactory : public mojom::StreamFactory {
       const media::AudioParameters& params,
       uint32_t shared_memory_count,
       bool enable_agc,
-      mojo::ScopedSharedBufferHandle key_press_count_buffer,
+      base::ReadOnlySharedMemoryRegion key_press_count_buffer,
       mojom::AudioProcessingConfigPtr processing_config,
       CreateInputStreamCallback callback) override {}
 

services/audio/public/cpp/input_ipc.cc

@@ -8,9 +8,9 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/memory/read_only_shared_memory_region.h"
 #include "media/mojo/mojom/audio_data_pipe.mojom.h"
 #include "mojo/public/cpp/bindings/remote.h"
-#include "mojo/public/cpp/system/platform_handle.h"
 #include "services/audio/public/mojom/audio_processing.mojom.h"
 
 namespace audio {
@@ -47,7 +47,7 @@ void InputIPC::CreateStream(media::AudioInputIPCDelegate* delegate,
       base::BindOnce(&InputIPC::OnError, base::Unretained(this)));
 
   // For now we don't care about key presses, so we pass a invalid buffer.
-  mojo::ScopedSharedBufferHandle invalid_key_press_count_buffer;
+  base::ReadOnlySharedMemoryRegion invalid_key_press_count_buffer;
 
   mojo::PendingRemote<media::mojom::AudioLog> log;
   if (log_)

services/audio/public/cpp/input_ipc_unittest.cc

@@ -50,7 +50,7 @@ class TestStreamFactory : public audio::FakeStreamFactory {
       const media::AudioParameters& params,
       uint32_t shared_memory_count,
       bool enable_agc,
-      mojo::ScopedSharedBufferHandle key_press_count_buffer,
+      base::ReadOnlySharedMemoryRegion key_press_count_buffer,
       mojom::AudioProcessingConfigPtr processing_config,
       CreateInputStreamCallback created_callback) {
     if (should_fail_) {
@@ -69,7 +69,6 @@ class TestStreamFactory : public audio::FakeStreamFactory {
 
     base::SyncSocket socket1, socket2;
     base::SyncSocket::CreatePair(&socket1, &socket2);
-    auto h = mojo::SharedBufferHandle::Create(kShMemSize);
     std::move(created_callback)
         .Run({base::in_place,
               base::ReadOnlySharedMemoryRegion::Create(kShMemSize).region,

services/audio/public/mojom/stream_factory.mojom

@@ -9,6 +9,7 @@ import "media/mojo/mojom/audio_input_stream.mojom";
 import "media/mojo/mojom/audio_logging.mojom";
 import "media/mojo/mojom/audio_output_stream.mojom";
 import "media/mojo/mojom/audio_parameters.mojom";
+import "mojo/public/mojom/base/shared_memory.mojom";
 import "mojo/public/mojom/base/unguessable_token.mojom";
 import "services/audio/public/mojom/audio_processing.mojom";
 
@@ -45,7 +46,7 @@ interface StreamFactory {
     pending_remote<media.mojom.AudioLog>? log,
     string device_id, media.mojom.AudioParameters params,
     uint32 shared_memory_count, bool enable_agc,
-    handle<shared_buffer>? key_press_count_buffer,
+    mojo_base.mojom.ReadOnlySharedMemoryRegion? key_press_count_buffer,
     audio.mojom.AudioProcessingConfig? processing_config)
       => (media.mojom.ReadOnlyAudioDataPipe? data_pipe, bool initially_muted,
           mojo_base.mojom.UnguessableToken? stream_id);

services/audio/stream_factory.cc

@@ -50,7 +50,7 @@ void StreamFactory::CreateInputStream(
     const media::AudioParameters& params,
     uint32_t shared_memory_count,
     bool enable_agc,
-    mojo::ScopedSharedBufferHandle key_press_count_buffer,
+    base::ReadOnlySharedMemoryRegion key_press_count_buffer,
     mojom::AudioProcessingConfigPtr processing_config,
     CreateInputStreamCallback created_callback) {
   CHECK_EQ(magic_bytes_, 0x600DC0DEu);

services/audio/stream_factory.h

@@ -60,7 +60,7 @@ class StreamFactory final : public mojom::StreamFactory {
       const media::AudioParameters& params,
       uint32_t shared_memory_count,
       bool enable_agc,
-      mojo::ScopedSharedBufferHandle key_press_count_buffer,
+      base::ReadOnlySharedMemoryRegion key_press_count_buffer,
       mojom::AudioProcessingConfigPtr processing_config,
       CreateInputStreamCallback created_callback) final;
 

services/audio/user_input_monitor.cc

@@ -6,15 +6,11 @@
 
 #include <utility>
 
-#include "mojo/public/cpp/system/platform_handle.h"
-
 namespace audio {
 
 // static
 std::unique_ptr<UserInputMonitor> UserInputMonitor::Create(
-    mojo::ScopedSharedBufferHandle handle) {
-  base::ReadOnlySharedMemoryRegion memory =
-      mojo::UnwrapReadOnlySharedMemoryRegion(std::move(handle));
+    base::ReadOnlySharedMemoryRegion memory) {
   if (memory.IsValid())
     return std::make_unique<UserInputMonitor>(memory.Map());
 

services/audio/user_input_monitor.h

@@ -7,9 +7,8 @@
 
 #include <memory>
 
-#include "base/memory/shared_memory_mapping.h"
+#include "base/memory/read_only_shared_memory_region.h"
 #include "media/base/user_input_monitor.h"
-#include "mojo/public/cpp/system/buffer.h"
 
 namespace audio {
 
@@ -22,7 +21,7 @@ class UserInputMonitor : public media::UserInputMonitor {
 
   // Returns nullptr for invalid handle.
   static std::unique_ptr<UserInputMonitor> Create(
-      mojo::ScopedSharedBufferHandle keypress_count_buffer);
+      base::ReadOnlySharedMemoryRegion keypress_count_buffer);
 
   void EnableKeyPressMonitoring() override;
   void DisableKeyPressMonitoring() override;

services/audio/user_input_monitor_unittest.cc

@@ -8,7 +8,6 @@
 #include <utility>
 
 #include "media/base/user_input_monitor.h"
-#include "mojo/public/cpp/system/platform_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace audio {
@@ -23,14 +22,12 @@ TEST(AudioServiceUserInputMonitorTest, CreateWithValidHandle) {
           base::ReadOnlySharedMemoryRegion::Create(sizeof(uint32_t)));
   ASSERT_TRUE(shmem->IsValid());
 
-  mojo::ScopedSharedBufferHandle handle =
-      mojo::WrapReadOnlySharedMemoryRegion(shmem->region.Duplicate());
-  EXPECT_TRUE(UserInputMonitor::Create(std::move(handle)));
+  EXPECT_TRUE(UserInputMonitor::Create(shmem->region.Duplicate()));
 }
 
 TEST(AudioServiceUserInputMonitorTest, CreateWithInvalidHandle_ReturnsNullptr) {
   EXPECT_EQ(nullptr,
-            UserInputMonitor::Create(mojo::ScopedSharedBufferHandle()));
+            UserInputMonitor::Create(base::ReadOnlySharedMemoryRegion()));
 }
 
 TEST(AudioServiceUserInputMonitorTest, GetKeyPressCount) {
@@ -39,10 +36,8 @@ TEST(AudioServiceUserInputMonitorTest, GetKeyPressCount) {
           base::ReadOnlySharedMemoryRegion::Create(sizeof(uint32_t)));
   ASSERT_TRUE(shmem->IsValid());
 
-  mojo::ScopedSharedBufferHandle handle =
-      mojo::WrapReadOnlySharedMemoryRegion(shmem->region.Duplicate());
   std::unique_ptr<UserInputMonitor> monitor =
-      UserInputMonitor::Create(std::move(handle));
+      UserInputMonitor::Create(shmem->region.Duplicate());
   EXPECT_TRUE(monitor);
 
   media::WriteKeyPressMonitorCount(shmem->mapping, kKeyPressCount);
@@ -55,10 +50,8 @@ TEST(AudioServiceUserInputMonitorTest, GetKeyPressCountAfterMemoryUnmap) {
           base::ReadOnlySharedMemoryRegion::Create(sizeof(uint32_t)));
   ASSERT_TRUE(shmem->IsValid());
 
-  mojo::ScopedSharedBufferHandle handle =
-      mojo::WrapReadOnlySharedMemoryRegion(shmem->region.Duplicate());
   std::unique_ptr<UserInputMonitor> monitor =
-      UserInputMonitor::Create(std::move(handle));
+      UserInputMonitor::Create(shmem->region.Duplicate());
   EXPECT_TRUE(monitor);
 
   media::WriteKeyPressMonitorCount(shmem->mapping, kKeyPressCount);