Convert Gamepad IPC messages into mojo interface.

content/renderer/gamepad_shared_memory_reader.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/renderer/gamepad_shared_memory_reader.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gamepad_hardware_buffer.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "ipc/ipc_sync_message_filter.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebGamepadListener.h"
 #include "third_party/WebKit/public/platform/WebPlatformEventListener.h"
 
 namespace content {
 
 GamepadSharedMemoryReader::GamepadSharedMemoryReader(RenderThread* thread)
     : RendererGamepadProvider(thread),
       gamepad_hardware_buffer_(NULL),
-      ever_interacted_with_(false) {
+      ever_interacted_with_(false),
+      binding_(this) {
+  if (thread) {
+    thread->GetRemoteInterfaces()->GetInterface(
+        mojo::GetProxy(&gamepad_monitor_));
+    gamepad_monitor_->SetObserver(binding_.CreateInterfacePtrAndBind());
+  }
 }
 
 void GamepadSharedMemoryReader::SendStartMessage() {
-  CHECK(RenderThread::Get()->Send(new GamepadHostMsg_StartPolling(
-      &renderer_shared_memory_handle_)));
+  if (gamepad_monitor_) {
+    mojo::ScopedSharedBufferHandle buffer_handle;
+    gamepad_monitor_->GamepadStartPolling(&buffer_handle);
+    MojoResult result = mojo::UnwrapSharedMemoryHandle(
+        std::move(buffer_handle), &renderer_shared_memory_handle_, nullptr,
+        nullptr);
+    DCHECK_EQ(MOJO_RESULT_OK, result);
+  }
 }
 
 void GamepadSharedMemoryReader::SendStopMessage() {
-    RenderThread::Get()->Send(new GamepadHostMsg_StopPolling());
+  if (gamepad_monitor_) {
+    gamepad_monitor_->GamepadStopPolling();
+  }
 }
 
 void GamepadSharedMemoryReader::Start(
     blink::WebPlatformEventListener* listener) {
   PlatformEventObserver::Start(listener);
 
   // If we don't get a valid handle from the browser, don't try to Map (we're
   // probably out of memory or file handles).
   bool valid_handle = base::SharedMemory::IsHandleValid(
       renderer_shared_memory_handle_);
@@ skipping 59 matching lines @@
     // gamepads so this is sufficient.
     for (unsigned i = 0; i < blink::WebGamepads::itemsLengthCap; i++)
       gamepads.items[i].connected = false;
   }
 }
 
 GamepadSharedMemoryReader::~GamepadSharedMemoryReader() {
   StopIfObserving();
 }
 
-bool GamepadSharedMemoryReader::OnControlMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(GamepadSharedMemoryReader, message)
-    IPC_MESSAGE_HANDLER(GamepadMsg_GamepadConnected, OnGamepadConnected)
-    IPC_MESSAGE_HANDLER(GamepadMsg_GamepadDisconnected, OnGamepadDisconnected)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void GamepadSharedMemoryReader::OnGamepadConnected(
+void GamepadSharedMemoryReader::GamepadConnected(
     int index,
     const blink::WebGamepad& gamepad) {
   // The browser already checks if the user actually interacted with a device.
   ever_interacted_with_ = true;
 
   if (listener())
     listener()->didConnectGamepad(index, gamepad);
 }
 
-void GamepadSharedMemoryReader::OnGamepadDisconnected(
+void GamepadSharedMemoryReader::GamepadDisconnected(
     int index,
     const blink::WebGamepad& gamepad) {
   if (listener())
     listener()->didDisconnectGamepad(index, gamepad);
 }
 
 } // namespace content