Move GeolocationDispatcher into blink.

third_party/WebKit/Source/modules/geolocation/GeolocationController.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "modules/geolocation/GeolocationController.h"
 
+#include "content/public/common/mojo_geoposition.mojom.h"
+#include "core/dom/Document.h"
 #include "core/page/Page.h"
-#include "modules/geolocation/GeolocationClient.h"
 #include "modules/geolocation/GeolocationError.h"
 #include "modules/geolocation/GeolocationPosition.h"
+#include "mojo/application/public/cpp/connect.h"
+#include "mojo/application/public/interfaces/service_provider.mojom.h"
+#include "platform/UserGestureIndicator.h"
 
 namespace blink {
 
-GeolocationController::GeolocationController(LocalFrame& frame, GeolocationClient* client)
-    : PageLifecycleObserver(frame.page())
-    , m_client(client)
-    , m_hasClientForTest(false)
-    , m_isClientUpdating(false)
+GeolocationController::GeolocationController(Geolocation* geolocation)
+    : PageLifecycleObserver(geolocation->document()->page())
+    , m_geolocation(geolocation)
 {
-    if (!frame.isMainFrame() && frame.page()->mainFrame()->isLocalFrame()) {
-        // internals.setGeolocationClientMock is per page.
-        GeolocationController* mainController = GeolocationController::from(frame.page()->deprecatedLocalMainFrame());
-        if (mainController->hasClientForTest())
-            setClientForTest(mainController->client());
-    }
 }
 
 void GeolocationController::startUpdatingIfNeeded()
 {
-    if (m_isClientUpdating)
+    if (m_geolocationService || !serviceProvider())
         return;
-    m_isClientUpdating = true;
-    m_client->startUpdating();
+    mojo::ConnectToService(serviceProvider(), &m_geolocationService);
+    if (m_enableHighAccuracy)
+        m_geolocationService->SetHighAccuracy(true);
+    QueryNextPosition();
 }
 
 void GeolocationController::stopUpdatingIfNeeded()
 {
-    if (!m_isClientUpdating)
-        return;
-    m_isClientUpdating = false;
-    m_client->stopUpdating();
+    m_geolocationService.reset();
 }
 
-GeolocationController::~GeolocationController()
+void GeolocationController::setEnableHighAccuracy(bool enableHighAccuracy)
 {
-    ASSERT(m_observers.isEmpty());
-#if !ENABLE(OILPAN)
-    if (m_hasClientForTest) {
-        m_client->controllerForTestRemoved(this);
-        m_hasClientForTest = false;
+    if (m_geolocationService && enableHighAccuracy != m_enableHighAccuracy) {
+        m_geolocationService->SetHighAccuracy(enableHighAccuracy);
     }
-#endif
+    m_enableHighAccuracy = enableHighAccuracy;
 }
 
-PassOwnPtrWillBeRawPtr<GeolocationController> GeolocationController::create(LocalFrame& frame, GeolocationClient* client)
+void GeolocationController::QueryNextPosition()
 {
-    return adoptPtrWillBeNoop(new GeolocationController(frame, client));
+    m_geolocationService->QueryNextPosition(
+        [this](content::MojoGeopositionPtr geoposition)
+        {
+            onQueryNextPositionDone(geoposition.Pass());
+        });
 }
 
-void GeolocationController::addObserver(Geolocation* observer, bool enableHighAccuracy)
+void GeolocationController::onQueryNextPositionDone(content::MojoGeopositionPtr geoposition)
 {
-    // This may be called multiple times with the same observer, though removeObserver()
-    // is called only once with each.
-    bool wasEmpty = m_observers.isEmpty();
-    m_observers.add(observer);
-    if (enableHighAccuracy)
-        m_highAccuracyObservers.add(observer);
-
-    if (m_client) {
-        if (enableHighAccuracy)
-            m_client->setEnableHighAccuracy(true);
-        if (wasEmpty && page() && page()->visibilityState() == PageVisibilityStateVisible)
-            startUpdatingIfNeeded();
+    auto geolocationService = m_geolocationService.get();
+    if (geoposition->valid) {
+        positionChanged(GeolocationPosition::create(
+            geoposition->timestamp,
+            geoposition->latitude,
+            geoposition->longitude,
+            geoposition->accuracy,
+            // Lowest point on land is at approximately -400 meters.
+            geoposition->altitude > -10000.,
+            geoposition->altitude,
+            geoposition->altitude_accuracy >= 0.,
+            geoposition->altitude_accuracy,
+            geoposition->heading >= 0. && geoposition->heading <= 360.,
+            geoposition->heading,
+            geoposition->speed >= 0.,
+            geoposition->speed));
+    } else {
+        GeolocationError::ErrorCode code;
+        switch (geoposition->error_code) {
+        case content::MojoGeoposition::ERROR_CODE_ERROR_CODE_NONE:
+            return;
+        case content::MojoGeoposition::ERROR_CODE_ERROR_CODE_PERMISSION_DENIED:
+            code = GeolocationError::PermissionDenied;
+            break;
+        case content::MojoGeoposition::ERROR_CODE_ERROR_CODE_POSITION_UNAVAILABLE:
+            code = GeolocationError::PositionUnavailable;
+            break;
+        case content::MojoGeoposition::ERROR_CODE_ERROR_CODE_TIMEOUT:
+            return;
+        }
+        errorOccurred(GeolocationError::create(
+            code, String::fromUTF8(geoposition->error_message.data(), geoposition->error_message.size())));
     }
+    if (m_geolocationService && m_geolocationService.get() == geolocationService)
+        QueryNextPosition();
 }
 
-void GeolocationController::removeObserver(Geolocation* observer)
+GeolocationController::~GeolocationController() = default;
+
+void GeolocationController::startUpdating(bool enableHighAccuracy)
 {
-    if (!m_observers.contains(observer))
-        return;
-
-    m_observers.remove(observer);
-    m_highAccuracyObservers.remove(observer);
-
-    if (m_client) {
-        if (m_observers.isEmpty())
-            stopUpdatingIfNeeded();
-        else if (m_highAccuracyObservers.isEmpty())
-            m_client->setEnableHighAccuracy(false);
-    }
+    // This may be called multiple times, though stopUpdating() is called only
+    // once.
+    m_updating = true;
+    if (enableHighAccuracy)
+        setEnableHighAccuracy(true);
+    if (page() && page()->visibilityState() == PageVisibilityStateVisible)
+        startUpdatingIfNeeded();
 }
 
-void GeolocationController::requestPermission(Geolocation* geolocation)
+void GeolocationController::stopUpdating()
 {
-    if (m_client)
-        m_client->requestPermission(geolocation);
+    m_updating = false;
+    stopUpdatingIfNeeded();
+    m_enableHighAccuracy = false;
 }
 
-void GeolocationController::cancelPermissionRequest(Geolocation* geolocation)
+void GeolocationController::requestPermission()
 {
-    if (m_client)
-        m_client->cancelPermissionRequest(geolocation);
+    if (!m_permissionService) {
+        if (!serviceProvider()) {
+            m_geolocation->setIsAllowed(false);
+            return;
+        }
+        mojo::ConnectToService(serviceProvider(), &m_permissionService);
+    }
+    m_permissionService->RequestPermission(content::PERMISSION_NAME_GEOLOCATION,
+        // FIXME: Add a type converter for WTF::String.
+        m_geolocation->executionContext()->securityOrigin()->toString().utf8().data(),
+        UserGestureIndicator::processingUserGesture(),
+        [this](content::PermissionStatus status)
+        {
+            onRequestPermissionDone(status);
+        });
+}
+
+void GeolocationController::cancelPermissionRequest()
+{
+    m_permissionService.reset();
+}
+
+void GeolocationController::onRequestPermissionDone(content::PermissionStatus status)
+{
+    m_geolocation->setIsAllowed(status == content::PERMISSION_STATUS_GRANTED);
+    m_permissionService.reset();
 }
 
 void GeolocationController::positionChanged(GeolocationPosition* position)
 {
     if (!position) {
         errorOccurred(GeolocationError::create(GeolocationError::PositionUnavailable, "PositionUnavailable"));
         return;
     }
     m_lastPosition = position;
-    HeapVector<Member<Geolocation>> observersVector;
-    copyToVector(m_observers, observersVector);
-    for (size_t i = 0; i < observersVector.size(); ++i)
-        observersVector[i]->positionChanged();
+    m_geolocation->positionChanged();
 }
 
 void GeolocationController::errorOccurred(GeolocationError* error)
 {
-    HeapVector<Member<Geolocation>> observersVector;
-    copyToVector(m_observers, observersVector);
-    for (size_t i = 0; i < observersVector.size(); ++i)
-        observersVector[i]->setError(error);
+    m_geolocation->setError(error);
 }
 
 GeolocationPosition* GeolocationController::lastPosition()
 {
     if (m_lastPosition.get())
         return m_lastPosition.get();
 
-    if (!m_client)
-        return 0;
-
-    return m_client->lastPosition();
-}
-
-void GeolocationController::setClientForTest(GeolocationClient* client)
-{
-    if (m_hasClientForTest)
-        m_client->controllerForTestRemoved(this);
-    m_client = client;
-    m_hasClientForTest = true;
-
-    client->controllerForTestAdded(this);
+    return nullptr;
 }
 
 void GeolocationController::pageVisibilityChanged()
 {
-    if (m_observers.isEmpty() || !m_client)
-        return;
-
-    if (page() && page()->visibilityState() == PageVisibilityStateVisible)
+    if (page() && page()->visibilityState() == PageVisibilityStateVisible && m_updating)
         startUpdatingIfNeeded();
     else
         stopUpdatingIfNeeded();
 }
 
-const char* GeolocationController::supplementName()
+mojo::ServiceProvider* GeolocationController::serviceProvider() const
 {
-    return "GeolocationController";
+    return m_geolocation->executionContext()->serviceProvider();
 }
 
 DEFINE_TRACE(GeolocationController)
 {
-    visitor->trace(m_client);
     visitor->trace(m_lastPosition);
-    visitor->trace(m_observers);
-    visitor->trace(m_highAccuracyObservers);
-    WillBeHeapSupplement<LocalFrame>::trace(visitor);
     PageLifecycleObserver::trace(visitor);
 }
 
-void provideGeolocationTo(LocalFrame& frame, GeolocationClient* client)
-{
-    WillBeHeapSupplement<LocalFrame>::provideTo(frame, GeolocationController::supplementName(), GeolocationController::create(frame, client));
-}
-
 } // namespace blink