Decouple GamepadSharedMemoryReader from RendererGamepadProvider

This change prepares GamepadSharedMemoryReader for the move to blink
by removing its inheritance from RendererGamepadProvider and moving
listener-related logic to GamepadSharedMemeoryReader.
Since the GamepadSharedMemoryReader instance can no longer be stored
in RendererBlinkPlatformImpl::platform_event_observers_, a separate
variable has been added temporarily that will be moved to
GamepadDispatcher along with the logic when the
GamepadSharedMemoryReader class is moved to blink.

Bug: 612330
Change-Id: I4a6e2dd1af5afb52f7f6a980eb8aace7642426ac
Reviewed-on: https://chromium-review.googlesource.com/1096349
Commit-Queue: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#567091}

content/renderer/gamepad_shared_memory_reader.cc

@@ -6,21 +6,13 @@
 
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
-#include "content/public/common/service_names.mojom.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
-#include "ipc/ipc_sync_message_filter.h"
-#include "services/service_manager/public/cpp/connector.h"
 #include "third_party/blink/public/platform/interface_provider.h"
 #include "third_party/blink/public/platform/platform.h"
-#include "third_party/blink/public/platform/web_gamepad_listener.h"
-#include "third_party/blink/public/platform/web_platform_event_listener.h"
 
 namespace content {
 
-GamepadSharedMemoryReader::GamepadSharedMemoryReader()
-    : gamepad_hardware_buffer_(nullptr),
-      ever_interacted_with_(false),
-      binding_(this) {
+GamepadSharedMemoryReader::GamepadSharedMemoryReader() : binding_(this) {
   blink::Platform::Current()->GetInterfaceProvider()->GetInterface(
       mojo::MakeRequest(&gamepad_monitor_));
   device::mojom::GamepadObserverPtr observer;
@@ -40,9 +32,11 @@ void GamepadSharedMemoryReader::SendStopMessage() {
   }
 }
 
-void GamepadSharedMemoryReader::Start(
-    blink::WebPlatformEventListener* listener) {
-  PlatformEventObserver::Start(listener);
+void GamepadSharedMemoryReader::Start(blink::WebGamepadListener* listener) {
+  DCHECK(!listener_);
+  listener_ = listener;
+
+  SendStartMessage();
 
   // 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).
@@ -60,9 +54,16 @@ void GamepadSharedMemoryReader::Start(
       static_cast<device::GamepadHardwareBuffer*>(memory);
 }
 
+void GamepadSharedMemoryReader::Stop() {
+  DCHECK(listener_);
+  listener_ = nullptr;
+
+  SendStopMessage();
+}
+
 void GamepadSharedMemoryReader::SampleGamepads(device::Gamepads& gamepads) {
-  // Blink should have started observing at that point.
-  CHECK(is_observing());
+  // Blink should have started observing at this point.
+  CHECK(listener_);
 
   // ==========
   //   DANGER
@@ -113,7 +114,8 @@ void GamepadSharedMemoryReader::SampleGamepads(device::Gamepads& gamepads) {
 }
 
 GamepadSharedMemoryReader::~GamepadSharedMemoryReader() {
-  StopIfObserving();
+  if (listener_)
+    Stop();
 }
 
 void GamepadSharedMemoryReader::GamepadConnected(
@@ -122,15 +124,15 @@ void GamepadSharedMemoryReader::GamepadConnected(
   // The browser already checks if the user actually interacted with a device.
   ever_interacted_with_ = true;
 
-  if (listener())
-    listener()->DidConnectGamepad(index, gamepad);
+  if (listener_)
+    listener_->DidConnectGamepad(index, gamepad);
 }
 
 void GamepadSharedMemoryReader::GamepadDisconnected(
     int index,
     const device::Gamepad& gamepad) {
-  if (listener())
-    listener()->DidDisconnectGamepad(index, gamepad);
+  if (listener_)
+    listener_->DidDisconnectGamepad(index, gamepad);
 }
 
 } // namespace content

content/renderer/gamepad_shared_memory_reader.h

@@ -8,30 +8,28 @@
 #include <memory>
 
 #include "base/macros.h"
-#include "content/public/renderer/renderer_gamepad_provider.h"
 #include "device/base/synchronization/shared_memory_seqlock_buffer.h"
 #include "device/gamepad/public/cpp/gamepads.h"
 #include "device/gamepad/public/mojom/gamepad.mojom.h"
 #include "device/gamepad/public/mojom/gamepad_hardware_buffer.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/system/buffer.h"
+#include "third_party/blink/public/platform/web_gamepad_listener.h"
 
 namespace content {
 
-class GamepadSharedMemoryReader : public RendererGamepadProvider,
-                                  public device::mojom::GamepadObserver {
+class GamepadSharedMemoryReader : public device::mojom::GamepadObserver {
  public:
   GamepadSharedMemoryReader();
   ~GamepadSharedMemoryReader() override;
 
-  // RendererGamepadProvider implementation.
-  void SampleGamepads(device::Gamepads& gamepads) override;
-  void Start(blink::WebPlatformEventListener* listener) override;
+  void SampleGamepads(device::Gamepads& gamepads);
+  void Start(blink::WebGamepadListener* listener);
+  void Stop();
 
  protected:
-  // PlatformEventObserver protected methods.
-  void SendStartMessage() override;
-  void SendStopMessage() override;
+  void SendStartMessage();
+  void SendStopMessage();
 
  private:
   // device::mojom::GamepadObserver methods.
@@ -40,12 +38,13 @@ class GamepadSharedMemoryReader : public RendererGamepadProvider,
 
   mojo::ScopedSharedBufferHandle renderer_shared_buffer_handle_;
   mojo::ScopedSharedBufferMapping renderer_shared_buffer_mapping_;
-  device::GamepadHardwareBuffer* gamepad_hardware_buffer_;
+  device::GamepadHardwareBuffer* gamepad_hardware_buffer_ = nullptr;
 
-  bool ever_interacted_with_;
+  bool ever_interacted_with_ = false;
 
   mojo::Binding<device::mojom::GamepadObserver> binding_;
   device::mojom::GamepadMonitorPtr gamepad_monitor_;
+  blink::WebGamepadListener* listener_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(GamepadSharedMemoryReader);
 };

content/renderer/renderer_blink_platform_impl.cc

@@ -40,6 +40,7 @@
 #include "content/public/common/webplugininfo.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/media_stream_utils.h"
+#include "content/public/renderer/platform_event_observer.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/blob_storage/webblobregistry_impl.h"
 #include "content/renderer/dom_storage/local_storage_cached_areas.h"
@@ -833,11 +834,8 @@ WebBlobRegistry* RendererBlinkPlatformImpl::GetBlobRegistry() {
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::SampleGamepads(device::Gamepads& gamepads) {
-  PlatformEventObserverBase* observer =
-      platform_event_observers_.Lookup(blink::kWebPlatformEventTypeGamepad);
-  if (!observer)
-    return;
-  static_cast<RendererGamepadProvider*>(observer)->SampleGamepads(gamepads);
+  if (gamepad_shared_memory_reader_)
+    gamepad_shared_memory_reader_->SampleGamepads(gamepads);
 }
 
 //------------------------------------------------------------------------------
@@ -1111,25 +1109,6 @@ void RendererBlinkPlatformImpl::RecordRapporURL(const char* metric,
   GetContentClient()->renderer()->RecordRapporURL(metric, url);
 }
 
-//------------------------------------------------------------------------------
-
-// static
-std::unique_ptr<PlatformEventObserverBase>
-RendererBlinkPlatformImpl::CreatePlatformEventObserverFromType(
-    blink::WebPlatformEventType type) {
-  switch (type) {
-    case blink::kWebPlatformEventTypeGamepad:
-      return std::make_unique<GamepadSharedMemoryReader>();
-    default:
-      // A default statement is required to prevent compilation errors when
-      // Blink adds a new type.
-      DVLOG(1) << "RendererBlinkPlatformImpl::startListening() with "
-                  "unknown type.";
-  }
-
-  return nullptr;
-}
-
 void RendererBlinkPlatformImpl::SetPlatformEventObserverForTesting(
     blink::WebPlatformEventType type,
     std::unique_ptr<PlatformEventObserverBase> observer) {
@@ -1207,19 +1186,16 @@ void RendererBlinkPlatformImpl::StartListening(
     // this method creates DeviceSensorEventPump instances if necessary and
     // calls Start() on them
     InitDeviceSensorEventPump(type, listener);
-  } else {
-    PlatformEventObserverBase* observer =
-        platform_event_observers_.Lookup(type);
-    if (!observer) {
-      std::unique_ptr<PlatformEventObserverBase> new_observer =
-          CreatePlatformEventObserverFromType(type);
-      if (!new_observer)
-        return;
-      observer = new_observer.get();
-      platform_event_observers_.AddWithID(std::move(new_observer),
-                                          static_cast<int32_t>(type));
+  } else if (type == blink::kWebPlatformEventTypeGamepad) {
+    if (!gamepad_shared_memory_reader_) {
+      gamepad_shared_memory_reader_ =
+          std::make_unique<GamepadSharedMemoryReader>();
     }
-    observer->Start(listener);
+    gamepad_shared_memory_reader_->Start(
+        static_cast<blink::WebGamepadListener*>(listener));
+  } else {
+    DVLOG(1) << "RendererBlinkPlatformImpl::startListening() with "
+                "unknown type.";
   }
 }
 
@@ -1229,12 +1205,9 @@ void RendererBlinkPlatformImpl::StopListening(
       type == blink::kWebPlatformEventTypeDeviceOrientation ||
       type == blink::kWebPlatformEventTypeDeviceOrientationAbsolute) {
     StopDeviceSensorEventPump(type);
-  } else {
-    PlatformEventObserverBase* observer =
-        platform_event_observers_.Lookup(type);
-    if (!observer)
-      return;
-    observer->Stop();
+  } else if (type == blink::kWebPlatformEventTypeGamepad) {
+    if (gamepad_shared_memory_reader_)
+      gamepad_shared_memory_reader_->Stop();
   }
 }
 

content/renderer/renderer_blink_platform_impl.h

@@ -59,6 +59,7 @@ class SharedURLLoaderFactory;
 
 namespace content {
 class BlinkInterfaceProviderImpl;
+class GamepadSharedMemoryReader;
 class ChildURLLoaderFactoryBundle;
 class LocalStorageCachedAreas;
 class PlatformEventObserverBase;
@@ -263,11 +264,6 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
  private:
   bool CheckPreparsedJsCachingEnabled() const;
 
-  // Factory that takes a type and return PlatformEventObserverBase that matches
-  // it.
-  static std::unique_ptr<PlatformEventObserverBase>
-  CreatePlatformEventObserverFromType(blink::WebPlatformEventType type);
-
   // TODO(crbug.com/850997): Remove when Device*EventPump classes are
   // moved to blink
   void InitDeviceSensorEventPump(blink::WebPlatformEventType type,
@@ -325,6 +321,10 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
   std::unique_ptr<DeviceOrientationEventPump> orientation_event_pump_;
   std::unique_ptr<DeviceOrientationEventPump> absolute_orientation_event_pump_;
 
+  // TODO(crbug.com/612330): Remove when GamepadSharedMemoryReader class is
+  // moved to blink
+  std::unique_ptr<GamepadSharedMemoryReader> gamepad_shared_memory_reader_;
+
   // NOT OWNED
   blink::scheduler::WebThreadScheduler* main_thread_scheduler_;