src/third_party/WebKit/Source/modules/gamepad/NavigatorGamepad.cpp

   1 /*
   2  * Copyright (C) 2011, Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  19  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  20  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  23  * DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "modules/gamepad/NavigatorGamepad.h"
  28
  29 #include "RuntimeEnabledFeatures.h"
  30 #include "core/dom/Document.h"
  31 #include "core/frame/DOMWindow.h"
  32 #include "core/frame/LocalFrame.h"
  33 #include "core/frame/Navigator.h"
  34 #include "core/page/Page.h"
  35 #include "modules/gamepad/GamepadDispatcher.h"
  36 #include "modules/gamepad/GamepadEvent.h"
  37 #include "modules/gamepad/GamepadList.h"
  38 #include "modules/gamepad/WebKitGamepadList.h"
  39
  40 namespace WebCore {
  41
  42 template<typename T>
  43 static void sampleGamepad(unsigned index, T& gamepad, const blink::WebGamepad& webGamepad)
  44 {
  45     gamepad.setId(webGamepad.id);
  46     gamepad.setIndex(index);
  47     gamepad.setConnected(webGamepad.connected);
  48     gamepad.setTimestamp(webGamepad.timestamp);
  49     gamepad.setMapping(webGamepad.mapping);
  50     gamepad.setAxes(webGamepad.axesLength, webGamepad.axes);
  51     gamepad.setButtons(webGamepad.buttonsLength, webGamepad.buttons);
  52 }
  53
  54 template<typename GamepadType, typename ListType>
  55 static void sampleGamepads(ListType* into)
  56 {
  57     blink::WebGamepads gamepads;
  58
  59     GamepadDispatcher::instance().sampleGamepads(gamepads);
  60
  61     for (unsigned i = 0; i < blink::WebGamepads::itemsLengthCap; ++i) {
  62         blink::WebGamepad& webGamepad = gamepads.items[i];
  63         if (i < gamepads.length && webGamepad.connected) {
  64             GamepadType* gamepad = into->item(i);
  65             if (!gamepad)
  66                 gamepad = GamepadType::create();
  67             sampleGamepad(i, *gamepad, webGamepad);
  68             into->set(i, gamepad);
  69         } else {
  70             into->set(i, 0);
  71         }
  72     }
  73 }
  74
  75 NavigatorGamepad* NavigatorGamepad::from(Document& document)
  76 {
  77     if (!document.frame() || !document.frame()->domWindow())
  78         return 0;
  79     Navigator& navigator = document.frame()->domWindow()->navigator();
  80     return &from(navigator);
  81 }
  82
  83 NavigatorGamepad& NavigatorGamepad::from(Navigator& navigator)
  84 {
  85     NavigatorGamepad* supplement = static_cast<NavigatorGamepad*>(WillBeHeapSupplement<Navigator>::from(navigator, supplementName()));
  86     if (!supplement) {
  87         supplement = new NavigatorGamepad(navigator.frame());
  88         provideTo(navigator, supplementName(), adoptPtrWillBeNoop(supplement));
  89     }
  90     return *supplement;
  91 }
  92
  93 WebKitGamepadList* NavigatorGamepad::webkitGetGamepads(Navigator& navigator)
  94 {
  95     return NavigatorGamepad::from(navigator).webkitGamepads();
  96 }
  97
  98 GamepadList* NavigatorGamepad::getGamepads(Navigator& navigator)
  99 {
 100     return NavigatorGamepad::from(navigator).gamepads();
 101 }
 102
 103 WebKitGamepadList* NavigatorGamepad::webkitGamepads()
 104 {
 105     if (!m_webkitGamepads)
 106         m_webkitGamepads = WebKitGamepadList::create();
 107     if (window()) {
 108         startUpdating();
 109         sampleGamepads<WebKitGamepad>(m_webkitGamepads.get());
 110     }
 111     return m_webkitGamepads.get();
 112 }
 113
 114 GamepadList* NavigatorGamepad::gamepads()
 115 {
 116     if (!m_gamepads)
 117         m_gamepads = GamepadList::create();
 118     if (window()) {
 119         startUpdating();
 120         sampleGamepads<Gamepad>(m_gamepads.get());
 121     }
 122     return m_gamepads.get();
 123 }
 124
 125 void NavigatorGamepad::trace(Visitor* visitor)
 126 {
 127     visitor->trace(m_gamepads);
 128     visitor->trace(m_webkitGamepads);
 129     WillBeHeapSupplement<Navigator>::trace(visitor);
 130 }
 131
 132 void NavigatorGamepad::didConnectOrDisconnectGamepad(unsigned index, const blink::WebGamepad& webGamepad, bool connected)
 133 {
 134     ASSERT(index < blink::WebGamepads::itemsLengthCap);
 135     ASSERT(connected == webGamepad.connected);
 136
 137     // We should stop listening once we detached.
 138     ASSERT(window());
 139
 140     // We register to the dispatcher before sampling gamepads so we need to check if we actually have an event listener.
 141     if (!m_hasEventListener)
 142         return;
 143
 144     if (window()->document()->activeDOMObjectsAreStopped() || window()->document()->activeDOMObjectsAreSuspended())
 145         return;
 146
 147     if (!m_gamepads)
 148         m_gamepads = GamepadList::create();
 149
 150     Gamepad* gamepad = m_gamepads->item(index);
 151     if (!gamepad)
 152         gamepad = Gamepad::create();
 153     sampleGamepad(index, *gamepad, webGamepad);
 154     m_gamepads->set(index, gamepad);
 155
 156     const AtomicString& eventName = connected ? EventTypeNames::gamepadconnected : EventTypeNames::gamepaddisconnected;
 157     RefPtrWillBeRawPtr<GamepadEvent> event = GamepadEvent::create(eventName, false, true, gamepad);
 158     window()->dispatchEvent(event);
 159 }
 160
 161 NavigatorGamepad::NavigatorGamepad(LocalFrame* frame)
 162     : DOMWindowProperty(frame)
 163     , DeviceSensorEventController(frame ? frame->page() : 0)
 164     , DOMWindowLifecycleObserver(frame ? frame->domWindow() : 0)
 165 {
 166 }
 167
 168 NavigatorGamepad::~NavigatorGamepad()
 169 {
 170 }
 171
 172 const char* NavigatorGamepad::supplementName()
 173 {
 174     return "NavigatorGamepad";
 175 }
 176
 177 void NavigatorGamepad::willDestroyGlobalObjectInFrame()
 178 {
 179     stopUpdating();
 180     DOMWindowProperty::willDestroyGlobalObjectInFrame();
 181 }
 182
 183 void NavigatorGamepad::willDetachGlobalObjectFromFrame()
 184 {
 185     stopUpdating();
 186     DOMWindowProperty::willDetachGlobalObjectFromFrame();
 187 }
 188
 189 void NavigatorGamepad::registerWithDispatcher()
 190 {
 191     GamepadDispatcher::instance().addClient(this);
 192 }
 193
 194 void NavigatorGamepad::unregisterWithDispatcher()
 195 {
 196     GamepadDispatcher::instance().removeClient(this);
 197 }
 198
 199 bool NavigatorGamepad::hasLastData()
 200 {
 201     // Gamepad data is polled instead of pushed.
 202     return false;
 203 }
 204
 205 PassRefPtrWillBeRawPtr<Event> NavigatorGamepad::getLastEvent()
 206 {
 207     // This is called only when hasLastData() is true.
 208     ASSERT_NOT_REACHED();
 209     return nullptr;
 210 }
 211
 212 bool NavigatorGamepad::isNullEvent(Event*)
 213 {
 214     // This is called only when hasLastData() is true.
 215     ASSERT_NOT_REACHED();
 216     return false;
 217 }
 218
 219 Document* NavigatorGamepad::document()
 220 {
 221     return window() ? window()->document() : 0;
 222 }
 223
 224 static bool isGamepadEvent(const AtomicString& eventType)
 225 {
 226     return eventType == EventTypeNames::gamepadconnected || eventType == EventTypeNames::gamepaddisconnected;
 227 }
 228
 229 void NavigatorGamepad::didAddEventListener(DOMWindow*, const AtomicString& eventType)
 230 {
 231     if (RuntimeEnabledFeatures::gamepadEnabled() && isGamepadEvent(eventType)) {
 232         if (page() && page()->visibilityState() == PageVisibilityStateVisible)
 233             startUpdating();
 234         m_hasEventListener = true;
 235     }
 236 }
 237
 238 void NavigatorGamepad::didRemoveEventListener(DOMWindow*, const AtomicString& eventType)
 239 {
 240     if (isGamepadEvent(eventType))
 241         m_hasEventListener = false;
 242 }
 243
 244 void NavigatorGamepad::didRemoveAllEventListeners(DOMWindow*)
 245 {
 246     m_hasEventListener = false;
 247 }
 248
 249 } // namespace WebCore