mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 21:55:31 +00:00
8733310923
--HG-- extra : rebase_source : 8e04725e80467a17d1a1a775f791782abe842c1b
279 lines
7.1 KiB
C++
279 lines
7.1 KiB
C++
/* -*- 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 "GamepadServiceTest.h"
|
|
|
|
#include "mozilla/ErrorResult.h"
|
|
#include "mozilla/unused.h"
|
|
|
|
#include "mozilla/dom/GamepadManager.h"
|
|
#include "mozilla/dom/GamepadPlatformService.h"
|
|
#include "mozilla/dom/GamepadServiceTestBinding.h"
|
|
#include "mozilla/dom/GamepadTestChannelChild.h"
|
|
|
|
#include "mozilla/ipc/BackgroundChild.h"
|
|
#include "mozilla/ipc/PBackgroundChild.h"
|
|
|
|
#include "mozilla/unused.h"
|
|
|
|
#include "nsIObserver.h"
|
|
#include "nsIObserverService.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
/*
|
|
* Implementation of the test service. This is just to provide a simple binding
|
|
* of the GamepadService to JavaScript via WebIDL so that we can write Mochitests
|
|
* that add and remove fake gamepads, avoiding the platform-specific backends.
|
|
*/
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(GamepadServiceTest)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(GamepadServiceTest,
|
|
DOMEventTargetHelper)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(GamepadServiceTest,
|
|
DOMEventTargetHelper)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(GamepadServiceTest)
|
|
NS_INTERFACE_MAP_ENTRY(nsIIPCBackgroundChildCreateCallback)
|
|
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(GamepadServiceTest, DOMEventTargetHelper)
|
|
NS_IMPL_RELEASE_INHERITED(GamepadServiceTest, DOMEventTargetHelper)
|
|
|
|
// static
|
|
already_AddRefed<GamepadServiceTest>
|
|
GamepadServiceTest::CreateTestService(nsPIDOMWindowInner* aWindow)
|
|
{
|
|
MOZ_ASSERT(aWindow);
|
|
RefPtr<GamepadServiceTest> service = new GamepadServiceTest(aWindow);
|
|
service->InitPBackgroundActor();
|
|
return service.forget();
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::Shutdown()
|
|
{
|
|
MOZ_ASSERT(!mShuttingDown);
|
|
mShuttingDown = true;
|
|
DestroyPBackgroundActor();
|
|
mWindow = nullptr;
|
|
}
|
|
|
|
GamepadServiceTest::GamepadServiceTest(nsPIDOMWindowInner* aWindow)
|
|
: mService(GamepadManager::GetService()),
|
|
mWindow(aWindow),
|
|
mEventNumber(0),
|
|
mShuttingDown(false),
|
|
mChild(nullptr)
|
|
{}
|
|
|
|
GamepadServiceTest::~GamepadServiceTest() {}
|
|
|
|
void
|
|
GamepadServiceTest::InitPBackgroundActor()
|
|
{
|
|
MOZ_ASSERT(!mChild);
|
|
PBackgroundChild *actor = BackgroundChild::GetForCurrentThread();
|
|
//Try to get the PBackground Child actor
|
|
if (actor) {
|
|
ActorCreated(actor);
|
|
} else {
|
|
Unused << BackgroundChild::GetOrCreateForCurrentThread(this);
|
|
}
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::DestroyPBackgroundActor()
|
|
{
|
|
if (mChild) {
|
|
// If mChild exists, which means that IPDL channel
|
|
// has been created, our pending operations should
|
|
// be empty.
|
|
MOZ_ASSERT(mPendingOperations.IsEmpty());
|
|
mChild->SendShutdownChannel();
|
|
mChild = nullptr;
|
|
} else {
|
|
// If the IPDL channel has not been created and we
|
|
// want to destroy it now, just cancel all pending
|
|
// operations.
|
|
mPendingOperations.Clear();
|
|
}
|
|
}
|
|
|
|
already_AddRefed<Promise>
|
|
GamepadServiceTest::AddGamepad(const nsAString& aID,
|
|
uint32_t aMapping,
|
|
uint32_t aNumButtons,
|
|
uint32_t aNumAxes,
|
|
ErrorResult& aRv)
|
|
{
|
|
if (mShuttingDown) {
|
|
return nullptr;
|
|
}
|
|
|
|
GamepadAdded a(nsString(aID), 0,
|
|
(uint32_t)aMapping, aNumButtons, aNumAxes);
|
|
GamepadChangeEvent e(a);
|
|
nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(mWindow);
|
|
|
|
RefPtr<Promise> p = Promise::Create(go, aRv);
|
|
if (aRv.Failed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t id = ++mEventNumber;
|
|
if (mChild) {
|
|
mChild->AddPromise(id, p);
|
|
mChild->SendGamepadTestEvent(id, e);
|
|
} else {
|
|
PendingOperation op(id, e, p);
|
|
mPendingOperations.AppendElement(op);
|
|
}
|
|
return p.forget();
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::RemoveGamepad(uint32_t aIndex)
|
|
{
|
|
if (mShuttingDown) {
|
|
return;
|
|
}
|
|
|
|
GamepadRemoved a(aIndex);
|
|
GamepadChangeEvent e(a);
|
|
|
|
uint32_t id = ++mEventNumber;
|
|
if (mChild) {
|
|
mChild->SendGamepadTestEvent(id, e);
|
|
} else {
|
|
PendingOperation op(id, e);
|
|
mPendingOperations.AppendElement(op);
|
|
}
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::NewButtonEvent(uint32_t aIndex,
|
|
uint32_t aButton,
|
|
bool aPressed)
|
|
{
|
|
if (mShuttingDown) {
|
|
return;
|
|
}
|
|
|
|
GamepadButtonInformation a(aIndex, aButton, aPressed, aPressed ? 1.0 : 0);
|
|
GamepadChangeEvent e(a);
|
|
|
|
uint32_t id = ++mEventNumber;
|
|
if (mChild) {
|
|
mChild->SendGamepadTestEvent(id, e);
|
|
} else {
|
|
PendingOperation op(id, e);
|
|
mPendingOperations.AppendElement(op);
|
|
}
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::NewButtonValueEvent(uint32_t aIndex,
|
|
uint32_t aButton,
|
|
bool aPressed,
|
|
double aValue)
|
|
{
|
|
if (mShuttingDown) {
|
|
return;
|
|
}
|
|
|
|
GamepadButtonInformation a(aIndex, aButton, aPressed, aValue);
|
|
GamepadChangeEvent e(a);
|
|
|
|
uint32_t id = ++mEventNumber;
|
|
if (mChild) {
|
|
mChild->SendGamepadTestEvent(id, e);
|
|
} else {
|
|
PendingOperation op(id, e);
|
|
mPendingOperations.AppendElement(op);
|
|
}
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::NewAxisMoveEvent(uint32_t aIndex,
|
|
uint32_t aAxis,
|
|
double aValue)
|
|
{
|
|
if (mShuttingDown) {
|
|
return;
|
|
}
|
|
|
|
GamepadAxisInformation a(aIndex, aAxis, aValue);
|
|
GamepadChangeEvent e(a);
|
|
|
|
uint32_t id = ++mEventNumber;
|
|
if (mChild) {
|
|
mChild->SendGamepadTestEvent(id, e);
|
|
} else {
|
|
PendingOperation op(id, e);
|
|
mPendingOperations.AppendElement(op);
|
|
}
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::FlushPendingOperations()
|
|
{
|
|
for (uint32_t i=0; i < mPendingOperations.Length(); ++i) {
|
|
PendingOperation op = mPendingOperations[i];
|
|
if (op.mPromise) {
|
|
mChild->AddPromise(op.mID, op.mPromise);
|
|
}
|
|
mChild->SendGamepadTestEvent(op.mID, op.mEvent);
|
|
}
|
|
mPendingOperations.Clear();
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::ActorCreated(PBackgroundChild* aActor)
|
|
{
|
|
MOZ_ASSERT(aActor);
|
|
// If we are shutting down, we don't need to create the
|
|
// IPDL child/parent pair anymore.
|
|
if (mShuttingDown) {
|
|
// mPendingOperations should be cleared in
|
|
// DestroyPBackgroundActor()
|
|
MOZ_ASSERT(mPendingOperations.IsEmpty());
|
|
return;
|
|
}
|
|
|
|
mChild = new GamepadTestChannelChild();
|
|
PGamepadTestChannelChild* initedChild =
|
|
aActor->SendPGamepadTestChannelConstructor(mChild);
|
|
if (NS_WARN_IF(!initedChild)) {
|
|
ActorFailed();
|
|
return;
|
|
}
|
|
FlushPendingOperations();
|
|
}
|
|
|
|
void
|
|
GamepadServiceTest::ActorFailed()
|
|
{
|
|
MOZ_CRASH("Failed to create background child actor!");
|
|
}
|
|
|
|
JSObject*
|
|
GamepadServiceTest::WrapObject(JSContext* aCx, JS::HandleObject aGivenProto)
|
|
{
|
|
return GamepadServiceTestBinding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
} // dom
|
|
} // mozilla
|