Bug 1523351 - Part 1: GamepadTouch and GamepadLightIndicator WebAPI implementation. r=baku

Differential Revision: https://phabricator.services.mozilla.com/D20744

--HG--
extra : moz-landing-system : lando

Author: daoshengmu

dom/gamepad/Gamepad.cpp

@@ -22,7 +22,8 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Gamepad)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Gamepad, mParent, mButtons, mPose,
-                                      mHapticActuators)
+                                      mHapticActuators, mLightIndicators,
+                                      mTouchEvents)
 
 void Gamepad::UpdateTimestamp() {
   nsCOMPtr<nsPIDOMWindowInner> newWindow(do_QueryInterface(mParent));
@@ -37,12 +38,14 @@ void Gamepad::UpdateTimestamp() {
 Gamepad::Gamepad(nsISupports* aParent, const nsAString& aID, uint32_t aIndex,
                  uint32_t aHashKey, GamepadMappingType aMapping,
                  GamepadHand aHand, uint32_t aDisplayID, uint32_t aNumButtons,
-                 uint32_t aNumAxes, uint32_t aNumHaptics)
+                 uint32_t aNumAxes, uint32_t aNumHaptics,
+                 uint32_t aNumLightIndicator, uint32_t aNumTouchEvents)
     : mParent(aParent),
       mID(aID),
       mIndex(aIndex),
       mHashKey(aHashKey),
       mDisplayId(aDisplayID),
+      mTouchIdHashValue(0),
       mMapping(aMapping),
       mHand(aHand),
       mConnected(true),
@@ -58,6 +61,14 @@ Gamepad::Gamepad(nsISupports* aParent, const nsAString& aID, uint32_t aIndex,
     mHapticActuators.AppendElement(
         new GamepadHapticActuator(mParent, mHashKey, i));
   }
+  for (uint32_t i = 0; i < aNumLightIndicator; ++i) {
+    mLightIndicators.AppendElement(
+        new GamepadLightIndicator(mParent, mHashKey, i));
+  }
+  for (uint32_t i = 0; i < aNumTouchEvents; ++i) {
+    mTouchEvents.AppendElement(new GamepadTouch(mParent));
+  }
+
   UpdateTimestamp();
 }
 
@@ -88,11 +99,35 @@ void Gamepad::SetPose(const GamepadPoseState& aPose) {
   UpdateTimestamp();
 }
 
+void Gamepad::SetLightIndicatorType(uint32_t aLightIndex,
+                                    GamepadLightIndicatorType aType) {
+  mLightIndicators[aLightIndex]->SetType(aType);
+  UpdateTimestamp();
+}
+
+void Gamepad::SetTouchEvent(uint32_t aTouchIndex,
+                            const GamepadTouchState& aTouch) {
+  if (aTouchIndex >= mTouchEvents.Length()) {
+    MOZ_CRASH("Touch index exceeds the event array.");
+    return;
+  }
+
+  // Handling cross-origin tracking.
+  GamepadTouchState touchState(aTouch);
+  if (auto hashValue = mTouchIdHash.GetValue(touchState.touchId)) {
+    touchState.touchId = *hashValue;
+  } else {
+    touchState.touchId = mTouchIdHashValue;
+    mTouchIdHash.Put(aTouch.touchId, mTouchIdHashValue);
+    ++mTouchIdHashValue;
+  }
+  mTouchEvents[aTouchIndex]->SetTouchState(touchState);
+  UpdateTimestamp();
+}
+
 void Gamepad::SetHand(GamepadHand aHand) { mHand = aHand; }
 
 void Gamepad::SyncState(Gamepad* aOther) {
-  const char* kGamepadExtEnabledPref = "dom.gamepad.extensions.enabled";
-
   if (mButtons.Length() != aOther->mButtons.Length() ||
       mAxes.Length() != aOther->mAxes.Length()) {
     return;
@@ -114,13 +149,24 @@ void Gamepad::SyncState(Gamepad* aOther) {
     Gamepad_Binding::ClearCachedAxesValue(this);
   }
 
-  if (Preferences::GetBool(kGamepadExtEnabledPref)) {
+  if (StaticPrefs::dom_gamepad_extensions_enabled()) {
     MOZ_ASSERT(aOther->GetPose());
     mPose->SetPoseState(aOther->GetPose()->GetPoseState());
     mHand = aOther->Hand();
     for (uint32_t i = 0; i < mHapticActuators.Length(); ++i) {
       mHapticActuators[i]->Set(aOther->mHapticActuators[i]);
     }
+
+    if (StaticPrefs::dom_gamepad_extensions_lightindicator()) {
+      for (uint32_t i = 0; i < mLightIndicators.Length(); ++i) {
+        mLightIndicators[i]->Set(aOther->mLightIndicators[i]);
+      }
+    }
+    if (StaticPrefs::dom_gamepad_extensions_multitouch()) {
+      for (uint32_t i = 0; i < mTouchEvents.Length(); ++i) {
+        mTouchEvents[i]->Set(aOther->mTouchEvents[i]);
+      }
+    }
   }
 
   UpdateTimestamp();
@@ -129,7 +175,8 @@ void Gamepad::SyncState(Gamepad* aOther) {
 already_AddRefed<Gamepad> Gamepad::Clone(nsISupports* aParent) {
   RefPtr<Gamepad> out =
       new Gamepad(aParent, mID, mIndex, mHashKey, mMapping, mHand, mDisplayId,
-                  mButtons.Length(), mAxes.Length(), mHapticActuators.Length());
+                  mButtons.Length(), mAxes.Length(), mHapticActuators.Length(),
+                  mLightIndicators.Length(), mTouchEvents.Length());
   out->SyncState(this);
   return out.forget();
 }

dom/gamepad/Gamepad.h

@@ -12,6 +12,8 @@
 #include "mozilla/dom/GamepadButton.h"
 #include "mozilla/dom/GamepadPose.h"
 #include "mozilla/dom/GamepadHapticActuator.h"
+#include "mozilla/dom/GamepadLightIndicator.h"
+#include "mozilla/dom/GamepadTouch.h"
 #include "mozilla/dom/Performance.h"
 #include <stdint.h>
 #include "nsCOMPtr.h"
@@ -40,7 +42,8 @@ class Gamepad final : public nsISupports, public nsWrapperCache {
   Gamepad(nsISupports* aParent, const nsAString& aID, uint32_t aIndex,
           uint32_t aHashKey, GamepadMappingType aMapping, GamepadHand aHand,
           uint32_t aDisplayID, uint32_t aNumButtons, uint32_t aNumAxes,
-          uint32_t aNumHaptics);
+          uint32_t aNumHaptics, uint32_t aNumLightIndicator,
+          uint32_t aNumTouchEvents);
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Gamepad)
@@ -50,6 +53,9 @@ class Gamepad final : public nsISupports, public nsWrapperCache {
   void SetAxis(uint32_t aAxis, double aValue);
   void SetIndex(uint32_t aIndex);
   void SetPose(const GamepadPoseState& aPose);
+  void SetLightIndicatorType(uint32_t aLightIndex,
+                             GamepadLightIndicatorType aType);
+  void SetTouchEvent(uint32_t aTouchIndex, const GamepadTouchState& aTouch);
   void SetHand(GamepadHand aHand);
 
   // Make the state of this gamepad equivalent to other.
@@ -93,6 +99,15 @@ class Gamepad final : public nsISupports, public nsWrapperCache {
     aHapticActuators = mHapticActuators;
   }
 
+  void GetLightIndicators(
+      nsTArray<RefPtr<GamepadLightIndicator>>& aLightIndicators) const {
+    aLightIndicators = mLightIndicators;
+  }
+
+  void GetTouchEvents(nsTArray<RefPtr<GamepadTouch>>& aTouchEvents) const {
+    aTouchEvents = mTouchEvents;
+  }
+
  private:
   virtual ~Gamepad() {}
   void UpdateTimestamp();
@@ -104,6 +119,7 @@ class Gamepad final : public nsISupports, public nsWrapperCache {
   // the gamepad hash key in GamepadManager
   uint32_t mHashKey;
   uint32_t mDisplayId;
+  uint32_t mTouchIdHashValue;
   // The mapping in use.
   GamepadMappingType mMapping;
   GamepadHand mHand;
@@ -117,6 +133,9 @@ class Gamepad final : public nsISupports, public nsWrapperCache {
   DOMHighResTimeStamp mTimestamp;
   RefPtr<GamepadPose> mPose;
   nsTArray<RefPtr<GamepadHapticActuator>> mHapticActuators;
+  nsTArray<RefPtr<GamepadLightIndicator>> mLightIndicators;
+  nsTArray<RefPtr<GamepadTouch>> mTouchEvents;
+  nsDataHashtable<nsUint32HashKey, uint32_t> mTouchIdHash;
 };
 
 }  // namespace dom

dom/gamepad/GamepadLightIndicator.cpp

@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/GamepadLightIndicator.h"
+#include "mozilla/dom/GamepadManager.h"
+#include "mozilla/dom/Promise.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(GamepadLightIndicator)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(GamepadLightIndicator)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(GamepadLightIndicator)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(GamepadLightIndicator, mParent)
+
+GamepadLightIndicator::GamepadLightIndicator(nsISupports* aParent,
+                                             uint32_t aGamepadId,
+                                             uint32_t aIndex)
+    : mParent(aParent),
+      mType(DefaultType()),
+      mGamepadId(aGamepadId),
+      mIndex(aIndex) {}
+
+GamepadLightIndicator::~GamepadLightIndicator() {
+  mozilla::DropJSObjects(this);
+}
+
+/* virtual */ JSObject* GamepadLightIndicator::WrapObject(
+    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+  return GamepadLightIndicator_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+nsISupports* GamepadLightIndicator::GetParentObject() const { return mParent; }
+
+already_AddRefed<Promise> GamepadLightIndicator::SetColor(
+    const GamepadLightColor& color, ErrorResult& aRv) {
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
+  MOZ_ASSERT(global);
+
+  RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
+  MOZ_ASSERT(gamepadManager);
+
+  RefPtr<Promise> promise = gamepadManager->SetLightIndicatorColor(
+      mGamepadId, mIndex, color.mRed, color.mGreen, color.mBlue, global, aRv);
+  if (!promise) {
+    return nullptr;
+  }
+  return promise.forget();
+}
+
+GamepadLightIndicatorType GamepadLightIndicator::Type() const { return mType; }
+
+void GamepadLightIndicator::Set(const GamepadLightIndicator* aOther) {
+  MOZ_ASSERT(aOther);
+  mGamepadId = aOther->mGamepadId;
+  mType = aOther->mType;
+  mIndex = aOther->mIndex;
+}
+
+}  // namespace dom
+}  // namespace mozilla

dom/gamepad/GamepadLightIndicator.h

@@ -0,0 +1,53 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_gamepad_GamepadLightIndicator_h
+#define mozilla_dom_gamepad_GamepadLightIndicator_h
+
+#include "mozilla/dom/GamepadLightIndicatorBinding.h"
+
+namespace mozilla {
+namespace dom {
+
+class GamepadLightIndicator final : public nsISupports, public nsWrapperCache {
+ public:
+  GamepadLightIndicator(nsISupports* aParent, uint32_t aGamepadId,
+                        uint32_t aIndex);
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(GamepadLightIndicator)
+
+  static GamepadLightIndicatorType DefaultType() {
+    return GamepadLightIndicatorType::Rgb;
+  }
+
+  nsISupports* GetParentObject() const;
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  already_AddRefed<Promise> SetColor(const GamepadLightColor& color,
+                                     ErrorResult& aRv);
+
+  void SetType(GamepadLightIndicatorType aType) { mType = aType; }
+
+  GamepadLightIndicatorType Type() const;
+
+  void Set(const GamepadLightIndicator* aOther);
+
+ private:
+  virtual ~GamepadLightIndicator();
+
+  nsCOMPtr<nsISupports> mParent;
+  GamepadLightIndicatorType mType;
+  uint32_t mGamepadId;
+  uint32_t mIndex;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_gamepad_GamepadLightIndicator_h

dom/gamepad/GamepadTouch.cpp

@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/GamepadTouch.h"
+#include "mozilla/dom/GamepadManager.h"
+#include "mozilla/dom/Promise.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(GamepadTouch)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(GamepadTouch)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+  tmp->mPosition = nullptr;
+  tmp->mSurfaceDimensions = nullptr;
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(GamepadTouch)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(GamepadTouch)
+  NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
+  NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mPosition)
+  NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mSurfaceDimensions)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(GamepadTouch, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(GamepadTouch, Release)
+
+GamepadTouch::GamepadTouch(nsISupports* aParent)
+    : mParent(aParent), mPosition(nullptr), mSurfaceDimensions(nullptr) {
+  mozilla::HoldJSObjects(this);
+  mTouchState = GamepadTouchState();
+}
+
+GamepadTouch::~GamepadTouch() { mozilla::DropJSObjects(this); }
+
+/* virtual */ JSObject* GamepadTouch::WrapObject(
+    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+  return GamepadTouch_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void GamepadTouch::GetPosition(JSContext* aCx,
+                               JS::MutableHandle<JSObject*> aRetval,
+                               ErrorResult& aRv) {
+  mPosition = Float32Array::Create(aCx, this, 2, mTouchState.position);
+  if (!mPosition) {
+    aRv.NoteJSContextException(aCx);
+    return;
+  }
+
+  aRetval.set(mPosition);
+}
+
+void GamepadTouch::GetSurfaceDimensions(JSContext* aCx,
+                                        JS::MutableHandle<JSObject*> aRetval,
+                                        ErrorResult& aRv) {
+  mSurfaceDimensions = Uint32Array::Create(aCx, this, 2,
+                                           mTouchState.isSurfaceDimensionsValid
+                                               ? mTouchState.surfaceDimensions
+                                               : nullptr);
+
+  if (!mSurfaceDimensions) {
+    aRv.NoteJSContextException(aCx);
+    return;
+  }
+
+  aRetval.set(mSurfaceDimensions);
+}
+
+void GamepadTouch::SetTouchState(const GamepadTouchState& aTouch) {
+  mTouchState = aTouch;
+}
+
+void GamepadTouch::Set(const GamepadTouch* aOther) {
+  MOZ_ASSERT(aOther);
+  mTouchState = aOther->mTouchState;
+}
+
+}  // namespace dom
+}  // namespace mozilla