[OnionSoup] Moving VR service from content to Blink

third_party/WebKit/Source/modules/vr/VRController.cpp

 // Copyright 2015 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 "modules/vr/VRController.h"
 
 #include "core/frame/LocalFrame.h"
+#include "modules/vr/VRGetDevicesCallback.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/mojo/MojoHelper.h"
+#include "public/platform/ServiceRegistry.h"
 
 namespace blink {
 
 VRController::~VRController()
 {
 }
 
-void VRController::provideTo(LocalFrame& frame, WebVRClient* client)
+void VRController::provideTo(LocalFrame& frame, ServiceRegistry* registry)
 {
     ASSERT(RuntimeEnabledFeatures::webVREnabled());
 
-    VRController* controller = new VRController(frame, client);
+    VRController* controller = new VRController(frame, registry);
     Supplement<LocalFrame>::provideTo(frame, supplementName(), controller);
 }
 
 VRController* VRController::from(LocalFrame& frame)
 {
     return static_cast<VRController*>(Supplement<LocalFrame>::from(frame, supplementName()));
 }
 
-VRController::VRController(LocalFrame& frame, WebVRClient* client)
+VRController::VRController(LocalFrame& frame, ServiceRegistry* registry)
     : LocalFrameLifecycleObserver(&frame)
-    , m_client(client)
 {
+    ASSERT(!m_service.is_bound());
+    ASSERT(registry);
+    registry->connectToRemoteService(mojo::GetProxy(&m_service));
 }
 
 const char* VRController::supplementName()
 {
     return "VRController";
 }
 
-void VRController::getDevices(WebVRGetDevicesCallback* callback)
+void VRController::getDevices(VRGetDevicesCallback* callback)
 {
-    // When detached, the client is no longer valid.
-    if (!m_client) {
+    if (!m_service) {
         callback->onError();
         delete callback;
         return;
     }
 
-    // Client is expected to take ownership of the callback
-    m_client->getDevices(callback);
+    VRGetDevicesRequest* deviceRequest = new VRGetDevicesRequest(callback);
+    m_pendingRequests.add(adoptPtr(deviceRequest));
+    m_service->GetDevices(
+        sameThreadBindForMojoWithBoundArgs(&VRController::OnGetDevices, this, deviceRequest));
 }
 
 void VRController::getSensorState(unsigned index, WebHMDSensorState& into)
 {
-    // When detached, the client is no longer valid.
-    if (!m_client)
+    if (!m_service)
         return;
-    m_client->getSensorState(index, into);
+
+    m_service->GetSensorState(
+        index,
+        sameThreadBindForMojoWithBoundArgs(&VRController::OnGetSensorState, this, &into));
+
+    // This call needs to return results synchronously in order to be useful and
+    // provide the lowest latency results possible.
+    m_service.WaitForIncomingResponse();
 }
 
 void VRController::resetSensor(unsigned index)
 {
-    // When detached, the client is no longer valid.
-    if (!m_client)
+    if (!m_service)
         return;
-    m_client->resetSensor(index);
+    m_service->ResetSensor(index);
 }
 
 void VRController::willDetachFrameHost()
 {
-    m_client = nullptr;
+    resetSensor(0);
+}
+
+void VRController::OnGetDevices(VRGetDevicesRequest* deviceRequest, const mojo::Array<mojom::VRDeviceInfoPtr>& devices)
+{
+    WebVector<WebVRDevice> webDevices(devices.size());
+
+    VRGetDevicesCallback* callback = deviceRequest->getDevicesCallback();
+    if (!callback)
+        return;
+
+    for (size_t i = 0; i < devices.size(); ++i) {
+        webDevices[i] = devices[i].To<WebVRDevice>();
+    }
+
+    callback->onSuccess(webDevices);
+    ASSERT(m_pendingRequests.contains(deviceRequest));
+    m_pendingRequests.remove(deviceRequest);

[haraken, 2016/04/27 06:51:07]

BTW, why do you need m_pendingRequests? If it's used just to keep alive the
VRGetDevicesCallback, it shouldn't be needed. Alternately you can pass the
OwnPtr<VRGetDevicesCallback> to VRGetDevicesRequest and ask the
VRGetDevicesRequest to keep alive the VRGetDevicesCallback.

[RaviKasibhatla, 2016/04/27 14:33:49]

I have removed this entire logic. I am now simply storing the callback in
WTF::Deque and processing the callback in the same order. Please let me know if
you feel there is a concern in this approach.

+}
+
+void VRController::OnGetSensorState(WebHMDSensorState* state, const mojom::VRSensorStatePtr& mojoState)
+{
+    *state = mojoState.To<WebHMDSensorState>();
 }
 
 DEFINE_TRACE(VRController)
 {
     Supplement<LocalFrame>::trace(visitor);
     LocalFrameLifecycleObserver::trace(visitor);
 }
 
+VRGetDevicesRequest::VRGetDevicesRequest(VRGetDevicesCallback* callback)
+{
+    m_getDevicesCallback = adoptPtr(callback);

[haraken, 2016/04/27 06:51:07]

It's nasty to call adoptPtr for a raw pointer... VRGetDevicesRequest should take
PassOwnPtr<VRGetDevicesCallback>.

+}
+
+VRGetDevicesRequest::~VRGetDevicesRequest()
+{
+    m_getDevicesCallback.clear();

[haraken, 2016/04/27 06:51:07]

This won't be needed, since the destructor will automatically clear the
m_getDevicesCallback.

+}
+
+VRGetDevicesCallback* VRGetDevicesRequest::getDevicesCallback() const
+{
+    return m_getDevicesCallback.get();
+}
+
 } // namespace blink