Changeset 223192 in webkit


Ignore:
Timestamp:
Oct 11, 2017 10:41:59 AM (7 years ago)
Author:
Chris Dumez
Message:

Modernize Geolocation code
​https://bugs.webkit.org/show_bug.cgi?id=178148

Reviewed by Ryosuke Niwa.

Source/WebCore:

Modernize Geolocation code:

  • Use std::optional<> instead of separate boolean members
  • Make GeolocationPosition a simple struct that can be passed via IPC
  • Replace WebGeolocationPosition::Data with GeolocationPosition
  • Move logic to construct a GeolocationPosition from a CLLocation on iOS in one place to avoid code duplication.
  • Modules/geolocation/Coordinates.cpp:

(WebCore::Coordinates::Coordinates):

  • Modules/geolocation/Coordinates.h:

(WebCore::Coordinates::create):
(WebCore::Coordinates::isolatedCopy const):
(WebCore::Coordinates::latitude const):
(WebCore::Coordinates::longitude const):
(WebCore::Coordinates::altitude const):
(WebCore::Coordinates::accuracy const):
(WebCore::Coordinates::altitudeAccuracy const):
(WebCore::Coordinates::heading const):
(WebCore::Coordinates::speed const):

  • Modules/geolocation/Geolocation.cpp:

(WebCore::createGeoposition):
(WebCore::Geolocation::lastPosition):

  • Modules/geolocation/GeolocationClient.h:
  • Modules/geolocation/GeolocationController.cpp:

(WebCore::GeolocationController::positionChanged):
(WebCore::GeolocationController::lastPosition):

  • Modules/geolocation/GeolocationController.h:
  • Modules/geolocation/GeolocationPosition.h:

(WebCore::GeolocationPosition::GeolocationPosition):
The default constructor is only needed by our IPC decoding code.

(WebCore::GeolocationPosition::encode const):
(WebCore::GeolocationPosition::decode):

  • Modules/geolocation/ios/GeolocationPositionIOS.mm: Copied from Source/WebCore/Modules/geolocation/Coordinates.cpp.

(WebCore::GeolocationPosition::GeolocationPosition):

  • WebCore.xcodeproj/project.pbxproj:
  • platform/mock/GeolocationClientMock.cpp:

(WebCore::GeolocationClientMock::lastPosition):
(WebCore::GeolocationClientMock::controllerTimerFired):

  • platform/mock/GeolocationClientMock.h:

Source/WebKit:

  • Shared/WebGeolocationPosition.cpp:

(WebKit::WebGeolocationPosition::create):
(WebKit::WebGeolocationPosition::~WebGeolocationPosition):

  • Shared/WebGeolocationPosition.h:

(WebKit::WebGeolocationPosition::timestamp const):
(WebKit::WebGeolocationPosition::latitude const):
(WebKit::WebGeolocationPosition::longitude const):
(WebKit::WebGeolocationPosition::accuracy const):
(WebKit::WebGeolocationPosition::altitude const):
(WebKit::WebGeolocationPosition::altitudeAccuracy const):
(WebKit::WebGeolocationPosition::heading const):
(WebKit::WebGeolocationPosition::speed const):
(WebKit::WebGeolocationPosition::corePosition const):
(WebKit::WebGeolocationPosition::WebGeolocationPosition):

  • UIProcess/API/C/WKGeolocationPosition.cpp:

(WKGeolocationPositionCreate_b):

  • UIProcess/API/Cocoa/_WKGeolocationPosition.mm:

(WebKit::wrapper):

  • UIProcess/API/glib/WebKitGeolocationProvider.cpp:

(WebKit::WebKitGeolocationProvider::notifyPositionChanged):

  • UIProcess/WebGeolocationManagerProxy.cpp:

(WebKit::WebGeolocationManagerProxy::providerDidChangePosition):

  • UIProcess/ios/WKGeolocationProviderIOS.mm:

(-[WKLegacyCoreLocationProvider positionChanged:]):

  • WebProcess/Geolocation/WebGeolocationManager.cpp:

(WebKit::WebGeolocationManager::didChangePosition):

  • WebProcess/Geolocation/WebGeolocationManager.h:
  • WebProcess/Geolocation/WebGeolocationManager.messages.in:
  • WebProcess/WebCoreSupport/WebGeolocationClient.cpp:

(WebKit::WebGeolocationClient::lastPosition):

  • WebProcess/WebCoreSupport/WebGeolocationClient.h:

Source/WebKitLegacy/ios:

  • Misc/WebGeolocationCoreLocationProvider.h:
  • Misc/WebGeolocationCoreLocationProvider.mm:

(-[WebGeolocationCoreLocationProvider sendLocation:]):

  • Misc/WebGeolocationProviderIOS.mm:

(-[_WebCoreLocationUpdateThreadingProxy positionChanged:]):

Source/WebKitLegacy/mac:

  • WebCoreSupport/WebGeolocationClient.h:
  • WebCoreSupport/WebGeolocationClient.mm:

(WebGeolocationClient::lastPosition):

  • WebView/WebGeolocationPosition.mm:

(-[WebGeolocationPositionInternal initWithCoreGeolocationPosition:]):
(core):
(-[WebGeolocationPosition initWithTimestamp:latitude:longitude:accuracy:]):
(-[WebGeolocationPosition initWithGeolocationPosition:]):

  • WebView/WebGeolocationPositionInternal.h:

Source/WebKitLegacy/win:

  • WebCoreSupport/WebGeolocationClient.cpp:

(WebGeolocationClient::lastPosition):

  • WebCoreSupport/WebGeolocationClient.h:
  • WebGeolocationPosition.cpp:

(WebGeolocationPosition::initWithTimestamp):
(core):

  • WebGeolocationPosition.h:

(WebGeolocationPosition::impl const):

Tools:

  • DumpRenderTree/mac/TestRunnerMac.mm:

(TestRunner::setMockGeolocationPosition):

Location:
trunk
Files:
1 added
40 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r223191 r223192  
     12017-10-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Modernize Geolocation code
     4        https://bugs.webkit.org/show_bug.cgi?id=178148
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        Modernize Geolocation code:
     9        - Use std::optional<> instead of separate boolean members
     10        - Make GeolocationPosition a simple struct that can be passed via IPC
     11        - Replace WebGeolocationPosition::Data with GeolocationPosition
     12        - Move logic to construct a GeolocationPosition from a CLLocation on iOS
     13          in one place to avoid code duplication.
     14
     15        * Modules/geolocation/Coordinates.cpp:
     16        (WebCore::Coordinates::Coordinates):
     17        * Modules/geolocation/Coordinates.h:
     18        (WebCore::Coordinates::create):
     19        (WebCore::Coordinates::isolatedCopy const):
     20        (WebCore::Coordinates::latitude const):
     21        (WebCore::Coordinates::longitude const):
     22        (WebCore::Coordinates::altitude const):
     23        (WebCore::Coordinates::accuracy const):
     24        (WebCore::Coordinates::altitudeAccuracy const):
     25        (WebCore::Coordinates::heading const):
     26        (WebCore::Coordinates::speed const):
     27        * Modules/geolocation/Geolocation.cpp:
     28        (WebCore::createGeoposition):
     29        (WebCore::Geolocation::lastPosition):
     30        * Modules/geolocation/GeolocationClient.h:
     31        * Modules/geolocation/GeolocationController.cpp:
     32        (WebCore::GeolocationController::positionChanged):
     33        (WebCore::GeolocationController::lastPosition):
     34        * Modules/geolocation/GeolocationController.h:
     35        * Modules/geolocation/GeolocationPosition.h:
     36        (WebCore::GeolocationPosition::GeolocationPosition):
     37        The default constructor is only needed by our IPC decoding code.
     38
     39        (WebCore::GeolocationPosition::encode const):
     40        (WebCore::GeolocationPosition::decode):
     41        * Modules/geolocation/ios/GeolocationPositionIOS.mm: Copied from Source/WebCore/Modules/geolocation/Coordinates.cpp.
     42        (WebCore::GeolocationPosition::GeolocationPosition):
     43        * WebCore.xcodeproj/project.pbxproj:
     44        * platform/mock/GeolocationClientMock.cpp:
     45        (WebCore::GeolocationClientMock::lastPosition):
     46        (WebCore::GeolocationClientMock::controllerTimerFired):
     47        * platform/mock/GeolocationClientMock.h:
     48
    1492017-10-11  Brady Eidson  <beidson@apple.com>
    250

  • trunk/Source/WebCore/Modules/geolocation/Coordinates.cpp

    r208985 r223192  
    2929namespace WebCore {
    3030
    31 std::optional<double> Coordinates::altitude() const
     31Coordinates::Coordinates(GeolocationPosition&& position)
     32    : m_position(WTFMove(position))
    3233{
    33     if (!m_canProvideAltitude)
    34         return std::nullopt;
    35     return m_altitude;
     34    ASSERT(m_position.isValid());
    3635}
    3736
    38 std::optional<double> Coordinates::altitudeAccuracy() const
    39 {
    40     if (!m_canProvideAltitudeAccuracy)
    41         return std::nullopt;
    42     return m_altitudeAccuracy;
    43 }
    44 
    45 std::optional<double> Coordinates::heading() const
    46 {
    47     if (!m_canProvideHeading)
    48         return std::nullopt;
    49     return m_heading;
    50 }
    51 
    52 std::optional<double> Coordinates::speed() const
    53 {
    54     if (!m_canProvideSpeed)
    55         return std::nullopt;
    56     return m_speed;
    57 }
    58    
    5937} // namespace WebCore

  • trunk/Source/WebCore/Modules/geolocation/Coordinates.h

    r218803 r223192  
    11/*
    2  * Copyright (C) 2009 Apple Inc. All Rights Reserved.
     2 * Copyright (C) 2009-2017 Apple Inc. All Rights Reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2626#pragma once
    2727
     28#include "GeolocationPosition.h"
    2829#include <wtf/Optional.h>
    2930#include <wtf/Ref.h>
    … …  
    3435class Coordinates : public RefCounted<Coordinates> {
    3536public:
    36     static Ref<Coordinates> create(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed) { return adoptRef(*new Coordinates(latitude, longitude, providesAltitude, altitude, accuracy, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed)); }
     37    static Ref<Coordinates> create(GeolocationPosition&& position)
     38    {
     39        return adoptRef(*new Coordinates(WTFMove(position)));
     40    }
    3741
    3842    Ref<Coordinates> isolatedCopy() const
    3943    {
    40         return Coordinates::create(m_latitude, m_longitude, m_canProvideAltitude, m_altitude, m_accuracy, m_canProvideAltitudeAccuracy, m_altitudeAccuracy, m_canProvideHeading, m_heading, m_canProvideSpeed, m_speed);
     44        return Coordinates::create( GeolocationPosition { m_position });
    4145    }
    4246
    43     double latitude() const { return m_latitude; }
    44     double longitude() const { return m_longitude; }
    45     std::optional<double> altitude() const;
    46     double accuracy() const { return m_accuracy; }
    47     std::optional<double> altitudeAccuracy() const;
    48     std::optional<double> heading() const;
    49     std::optional<double> speed() const;
     47    double latitude() const { return m_position.latitude; }
     48    double longitude() const { return m_position.longitude; }
     49    std::optional<double> altitude() const { return m_position.altitude; }
     50    double accuracy() const { return m_position.accuracy; }
     51    std::optional<double> altitudeAccuracy() const { return m_position.altitudeAccuracy; }
     52    std::optional<double> heading() const { return m_position.heading; }
     53    std::optional<double> speed() const { return m_position.speed; }
    5054   
    5155private:
    52     Coordinates(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed)
    53         : m_latitude(latitude)
    54         , m_longitude(longitude)
    55         , m_altitude(altitude)
    56         , m_accuracy(accuracy)
    57         , m_altitudeAccuracy(altitudeAccuracy)
    58         , m_heading(heading)
    59         , m_speed(speed)
    60         , m_canProvideAltitude(providesAltitude)
    61         , m_canProvideAltitudeAccuracy(providesAltitudeAccuracy)
    62         , m_canProvideHeading(providesHeading)
    63         , m_canProvideSpeed(providesSpeed)
    64     {
    65     }
     56    explicit Coordinates(GeolocationPosition&&);
    6657
    67     double m_latitude;
    68     double m_longitude;
    69     double m_altitude;
    70     double m_accuracy;
    71     double m_altitudeAccuracy;
    72     double m_heading;
    73     double m_speed;
    74    
    75     bool m_canProvideAltitude;
    76     bool m_canProvideAltitudeAccuracy;
    77     bool m_canProvideHeading;
    78     bool m_canProvideSpeed;
     58    GeolocationPosition m_position;
    7959};
    8060   

  • trunk/Source/WebCore/Modules/geolocation/Geolocation.cpp

    r223149 r223192  
    5454static const char originCannotRequestGeolocationErrorMessage[] = "Origin does not have permission to use Geolocation service";
    5555
    56 static RefPtr<Geoposition> createGeoposition(GeolocationPosition* position)
     56static RefPtr<Geoposition> createGeoposition(std::optional<GeolocationPosition>&& position)
    5757{
    5858    if (!position)
    5959        return nullptr;
    6060   
    61     auto coordinates = Coordinates::create(position->latitude(), position->longitude(), position->canProvideAltitude(), position->altitude(),
    62         position->accuracy(), position->canProvideAltitudeAccuracy(), position->altitudeAccuracy(),
    63         position->canProvideHeading(), position->heading(), position->canProvideSpeed(), position->speed());
    64 
    65     return Geoposition::create(WTFMove(coordinates), convertSecondsToDOMTimeStamp(position->timestamp()));
     61    DOMTimeStamp timestamp = convertSecondsToDOMTimeStamp(position->timestamp);
     62    return Geoposition::create(Coordinates::create(WTFMove(position.value())), timestamp);
    6663}
    6764
    … …  
    297294    Page* page = this->page();
    298295    if (!page)
    299         return 0;
     296        return nullptr;
    300297
    301298    m_lastPosition = createGeoposition(GeolocationController::from(page)->lastPosition());

  • trunk/Source/WebCore/Modules/geolocation/GeolocationClient.h

    r221743 r223192  
    2626#pragma once
    2727
     28#include <wtf/Optional.h>
     29
    2830namespace WebCore {
    2931
    … …  
    4345    // is published.
    4446    virtual void setEnableHighAccuracy(bool) = 0;
    45     virtual GeolocationPosition* lastPosition() = 0;
     47    virtual std::optional<GeolocationPosition> lastPosition() = 0;
    4648
    4749    virtual void requestPermission(Geolocation&) = 0;

  • trunk/Source/WebCore/Modules/geolocation/GeolocationController.cpp

    r221743 r223192  
    100100}
    101101
    102 void GeolocationController::positionChanged(GeolocationPosition* position)
     102void GeolocationController::positionChanged(const std::optional<GeolocationPosition>& position)
    103103{
    104104    m_lastPosition = position;
    … …  
    121121}
    122122
    123 GeolocationPosition* GeolocationController::lastPosition()
     123std::optional<GeolocationPosition> GeolocationController::lastPosition()
    124124{
    125     if (m_lastPosition.get())
    126         return m_lastPosition.get();
     125    if (m_lastPosition)
     126        return m_lastPosition.value();
    127127
    128128    return m_client.lastPosition();

  • trunk/Source/WebCore/Modules/geolocation/GeolocationController.h

    r221743 r223192  
    5454    void cancelPermissionRequest(Geolocation&);
    5555
    56     WEBCORE_EXPORT void positionChanged(GeolocationPosition*);
     56    WEBCORE_EXPORT void positionChanged(const std::optional<GeolocationPosition>&);
    5757    WEBCORE_EXPORT void errorOccurred(GeolocationError&);
    5858
    59     GeolocationPosition* lastPosition();
     59    std::optional<GeolocationPosition> lastPosition();
    6060
    6161    GeolocationClient& client() { return m_client; }
    … …  
    7070    void activityStateDidChange(ActivityState::Flags oldActivityState, ActivityState::Flags newActivityState) override;
    7171
    72     RefPtr<GeolocationPosition> m_lastPosition;
     72    std::optional<GeolocationPosition> m_lastPosition;
    7373
    7474    typedef HashSet<Ref<Geolocation>> ObserversSet;

  • trunk/Source/WebCore/Modules/geolocation/GeolocationPosition.h

    r208646 r223192  
    11/*
    2  * Copyright (C) 2009 Apple Inc. All rights reserved.
     2 * Copyright (C) 2009-2017 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2626#pragma once
    2727
     28#include <cmath>
     29#include <wtf/Optional.h>
    2830#include <wtf/Ref.h>
    2931#include <wtf/RefCounted.h>
    3032
     33#if PLATFORM(IOS)
     34OBJC_CLASS CLLocation;
     35#endif
     36
    3137namespace WebCore {
    3238
    33 class GeolocationPosition : public RefCounted<GeolocationPosition> {
     39class GeolocationPosition {
    3440public:
    35     static Ref<GeolocationPosition> create(double timestamp, double latitude, double longitude, double accuracy)
    36     {
    37         return adoptRef(*new GeolocationPosition(timestamp, latitude, longitude, accuracy));
    38     }
     41    GeolocationPosition() = default;
    3942
    40     static Ref<GeolocationPosition> create(double timestamp, double latitude, double longitude, double accuracy, bool providesAltitude, double altitude, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed)
    41     {
    42         return adoptRef(*new GeolocationPosition(timestamp, latitude, longitude, accuracy, providesAltitude, altitude, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed));
    43     }
    44 
    45     double timestamp() const { return m_timestamp; }
    46 
    47     double latitude() const { return m_latitude; }
    48     double longitude() const { return m_longitude; }
    49     double accuracy() const { return m_accuracy; }
    50     double altitude() const { return m_altitude; }
    51     double altitudeAccuracy() const { return m_altitudeAccuracy; }
    52     double heading() const { return m_heading; }
    53     double speed() const { return m_speed; }
    54 
    55     bool canProvideAltitude() const { return m_canProvideAltitude; }
    56     bool canProvideAltitudeAccuracy() const { return m_canProvideAltitudeAccuracy; }
    57     bool canProvideHeading() const { return m_canProvideHeading; }
    58     bool canProvideSpeed() const { return m_canProvideSpeed; }
    59 
    60 private:
    6143    GeolocationPosition(double timestamp, double latitude, double longitude, double accuracy)
    62         : m_timestamp(timestamp)
    63         , m_latitude(latitude)
    64         , m_longitude(longitude)
    65         , m_accuracy(accuracy)
    66         , m_altitude(0)
    67         , m_altitudeAccuracy(0)
    68         , m_heading(0)
    69         , m_speed(0)
    70         , m_canProvideAltitude(false)
    71         , m_canProvideAltitudeAccuracy(false)
    72         , m_canProvideHeading(false)
    73         , m_canProvideSpeed(false)
     44        : timestamp(timestamp)
     45        , latitude(latitude)
     46        , longitude(longitude)
     47        , accuracy(accuracy)
    7448    {
    7549    }
    7650
    77     GeolocationPosition(double timestamp, double latitude, double longitude, double accuracy, bool providesAltitude, double altitude, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed)
    78         : m_timestamp(timestamp)
    79         , m_latitude(latitude)
    80         , m_longitude(longitude)
    81         , m_accuracy(accuracy)
    82         , m_altitude(altitude)
    83         , m_altitudeAccuracy(altitudeAccuracy)
    84         , m_heading(heading)
    85         , m_speed(speed)
    86         , m_canProvideAltitude(providesAltitude)
    87         , m_canProvideAltitudeAccuracy(providesAltitudeAccuracy)
    88         , m_canProvideHeading(providesHeading)
    89         , m_canProvideSpeed(providesSpeed)
    90     {
    91     }
     51#if PLATFORM(IOS)
     52    WEBCORE_EXPORT explicit GeolocationPosition(CLLocation*);
     53#endif
    9254
    93     double m_timestamp;
     55    double timestamp { std::numeric_limits<double>::quiet_NaN() };
    9456
    95     double m_latitude;
    96     double m_longitude;
    97     double m_accuracy;
    98     double m_altitude;
    99     double m_altitudeAccuracy;
    100     double m_heading;
    101     double m_speed;
     57    double latitude { std::numeric_limits<double>::quiet_NaN() };
     58    double longitude { std::numeric_limits<double>::quiet_NaN() };
     59    double accuracy { std::numeric_limits<double>::quiet_NaN() };
    10260
    103     bool m_canProvideAltitude;
    104     bool m_canProvideAltitudeAccuracy;
    105     bool m_canProvideHeading;
    106     bool m_canProvideSpeed;
     61    std::optional<double> altitude;
     62    std::optional<double> altitudeAccuracy;
     63    std::optional<double> heading;
     64    std::optional<double> speed;
     65
     66    bool isValid() const;
     67
     68    template<class Encoder> void encode(Encoder&) const;
     69    template<class Decoder> static bool decode(Decoder&, GeolocationPosition&);
    10770};
    10871
     72template<class Encoder>
     73void GeolocationPosition::encode(Encoder& encoder) const
     74{
     75    encoder << timestamp;
     76    encoder << latitude;
     77    encoder << longitude;
     78    encoder << accuracy;
     79    encoder << altitude;
     80    encoder << altitudeAccuracy;
     81    encoder << heading;
     82    encoder << speed;
     83}
     84
     85template<class Decoder>
     86bool GeolocationPosition::decode(Decoder& decoder, GeolocationPosition& position)
     87{
     88    if (!decoder.decode(position.timestamp))
     89        return false;
     90    if (!decoder.decode(position.latitude))
     91        return false;
     92    if (!decoder.decode(position.longitude))
     93        return false;
     94    if (!decoder.decode(position.accuracy))
     95        return false;
     96    if (!decoder.decode(position.altitude))
     97        return false;
     98    if (!decoder.decode(position.altitudeAccuracy))
     99        return false;
     100    if (!decoder.decode(position.heading))
     101        return false;
     102    if (!decoder.decode(position.speed))
     103        return false;
     104
     105    return true;
     106}
     107
     108inline bool GeolocationPosition::isValid() const
     109{
     110    return !std::isnan(timestamp) && !std::isnan(latitude) && !std::isnan(longitude) && !std::isnan(accuracy);
     111}
     112
    109113} // namespace WebCore

  • trunk/Source/WebCore/Modules/geolocation/ios/GeolocationPositionIOS.mm

    r223191 r223192  
    11/*
    2  * Copyright (C) 2013 Google Inc. All Rights Reserved.
     2 * Copyright (C) 2017 Apple Inc. All Rights Reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2121 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    2222 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
    2525
    2626#include "config.h"
    27 #include "Coordinates.h"
     27#include "GeolocationPosition.h"
     28
     29#if PLATFORM(IOS)
     30
     31#import <CoreLocation/CLLocation.h>
    2832
    2933namespace WebCore {
    3034
    31 std::optional<double> Coordinates::altitude() const
     35GeolocationPosition::GeolocationPosition(CLLocation* location)
     36    : timestamp(location.timestamp.timeIntervalSince1970)
     37    , latitude(location.coordinate.latitude)
     38    , longitude(location.coordinate.longitude)
     39    , accuracy(location.horizontalAccuracy)
    3240{
    33     if (!m_canProvideAltitude)
    34         return std::nullopt;
    35     return m_altitude;
     41    if (location.verticalAccuracy >= 0.0) {
     42        altitude = location.altitude;
     43        altitudeAccuracy = location.verticalAccuracy;
     44    }
     45    if (location.speed >= 0.0)
     46        speed = location.speed;
     47    if (location.course >= 0.0)
     48        heading = location.course;
    3649}
    3750
    38 std::optional<double> Coordinates::altitudeAccuracy() const
    39 {
    40     if (!m_canProvideAltitudeAccuracy)
    41         return std::nullopt;
    42     return m_altitudeAccuracy;
    4351}
    4452
    45 std::optional<double> Coordinates::heading() const
    46 {
    47     if (!m_canProvideHeading)
    48         return std::nullopt;
    49     return m_heading;
    50 }
    51 
    52 std::optional<double> Coordinates::speed() const
    53 {
    54     if (!m_canProvideSpeed)
    55         return std::nullopt;
    56     return m_speed;
    57 }
    58    
    59 } // namespace WebCore
     53#endif

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r223191 r223192  
    35523552                837609CA1F54CC18000C122D /* ErrorCallback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 837609C81F54CC13000C122D /* ErrorCallback.cpp */; };
    35533553                83765F951DAC522F00C06537 /* MouseEventInit.h in Headers */ = {isa = PBXBuildFile; fileRef = 83765F941DAC521800C06537 /* MouseEventInit.h */; settings = {ATTRIBUTES = (Private, ); }; };
     3554                837964CF1F8DB69D00218EA0 /* GeolocationPositionIOS.mm in Sources */ = {isa = PBXBuildFile; fileRef = 837964CE1F8DB69A00218EA0 /* GeolocationPositionIOS.mm */; };
    35543555                837A80131E1E127300026B9F /* Localizable.stringsdict in Resources */ = {isa = PBXBuildFile; fileRef = 837A80111E1E127300026B9F /* Localizable.stringsdict */; };
    35553556                837B7D201DC3F55000D051FC /* ValidationBubbleIOS.mm in Sources */ = {isa = PBXBuildFile; fileRef = 837B7D1F1DC3F54C00D051FC /* ValidationBubbleIOS.mm */; };
    … …  
    1187611877                83765F931DAC521800C06537 /* MouseEventInit.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = MouseEventInit.idl; sourceTree = "<group>"; };
    1187711878                83765F941DAC521800C06537 /* MouseEventInit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MouseEventInit.h; sourceTree = "<group>"; };
     11879                837964CE1F8DB69A00218EA0 /* GeolocationPositionIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = GeolocationPositionIOS.mm; path = Modules/geolocation/ios/GeolocationPositionIOS.mm; sourceTree = SOURCE_ROOT; };
    1187811880                837A80121E1E127300026B9F /* English */ = {isa = PBXFileReference; lastKnownFileType = text.plist.stringsdict; name = English; path = English.lproj/Localizable.stringsdict; sourceTree = SOURCE_ROOT; };
    1187911881                837B7D1F1DC3F54C00D051FC /* ValidationBubbleIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ValidationBubbleIOS.mm; sourceTree = "<group>"; };
    … …  
    2044220444                        sourceTree = "<group>";
    2044320445                };
     20446                837964CC1F8DB67D00218EA0 /* ios */ = {
     20447                        isa = PBXGroup;
     20448                        children = (
     20449                                837964CE1F8DB69A00218EA0 /* GeolocationPositionIOS.mm */,
     20450                        );
     20451                        name = ios;
     20452                        path = "New Group";
     20453                        sourceTree = "<group>";
     20454                };
    2044420455                83FB33651F508A1700986E54 /* entriesapi */ = {
    2044520456                        isa = PBXGroup;
    … …  
    2130521316                        isa = PBXGroup;
    2130621317                        children = (
     21318                                837964CC1F8DB67D00218EA0 /* ios */,
    2130721319                                9746AF1114F4DDE6003E7A72 /* Coordinates.cpp */,
    2130821320                                9746AF1114F4DDE6003E7A70 /* Coordinates.h */,
    … …  
    3215932171                                9746AF2314F4DDE6003E7A70 /* Geolocation.cpp in Sources */,
    3216032172                                9746AF2614F4DDE6003E7A70 /* GeolocationController.cpp in Sources */,
     32173                                837964CF1F8DB69D00218EA0 /* GeolocationPositionIOS.mm in Sources */,
    3216132174                                0FB6252E18DE1B1500A07C05 /* GeometryUtilities.cpp in Sources */,
    3216232175                                46C83EFD1A9BBE2900A79A41 /* GeoNotifier.cpp in Sources */,

  • trunk/Source/WebCore/platform/mock/GeolocationClientMock.cpp

    r221743 r223192  
    6262}
    6363
    64 void GeolocationClientMock::setPosition(RefPtr<GeolocationPosition>&& position)
     64void GeolocationClientMock::setPosition(GeolocationPosition&& position)
    6565{
    6666    m_lastPosition = WTFMove(position);
    … …  
    7373    m_hasError = true;
    7474    m_errorMessage = errorMessage;
    75     m_lastPosition = nullptr;
     75    m_lastPosition = std::nullopt;
    7676    asyncUpdateController();
    7777}
    … …  
    127127void GeolocationClientMock::reset()
    128128{
    129     m_lastPosition = nullptr;
     129    m_lastPosition = std::nullopt;
    130130    clearError();
    131131    m_permissionState = PermissionStateUnset;
    … …  
    157157}
    158158
    159 GeolocationPosition* GeolocationClientMock::lastPosition()
     159std::optional<GeolocationPosition> GeolocationClientMock::lastPosition()
    160160{
    161     return m_lastPosition.get();
     161    return m_lastPosition;
    162162}
    163163
    … …  
    173173    ASSERT(m_controller);
    174174
    175     if (m_lastPosition.get()) {
     175    if (m_lastPosition) {
    176176        ASSERT(!m_hasError);
    177         m_controller->positionChanged(m_lastPosition.get());
     177        m_controller->positionChanged(*m_lastPosition);
    178178    } else if (m_hasError) {
    179179        auto geolocatioError = GeolocationError::create(GeolocationError::PositionUnavailable, m_errorMessage);

  • trunk/Source/WebCore/platform/mock/GeolocationClientMock.h

    r221743 r223192  
    3333
    3434#include "GeolocationClient.h"
     35#include "GeolocationPosition.h"
    3536#include "Timer.h"
    3637#include <wtf/HashSet.h>
    … …  
    4142
    4243class GeolocationController;
    43 class GeolocationPosition;
    4444
    4545// FIXME: this should not be in WebCore. It should be moved to WebKit.
    … …  
    5353    void setController(GeolocationController*);
    5454
    55     void setPosition(RefPtr<GeolocationPosition>&&);
     55    void setPosition(GeolocationPosition&&);
    5656    void setPositionUnavailableError(const String& errorMessage);
    5757    void setPermission(bool allowed);
    … …  
    6363    void stopUpdating() override;
    6464    void setEnableHighAccuracy(bool) override;
    65     GeolocationPosition* lastPosition() override;
     65    std::optional<GeolocationPosition> lastPosition() override;
    6666    void requestPermission(Geolocation&) override;
    6767    void cancelPermissionRequest(Geolocation&) override;
    … …  
    7777
    7878    GeolocationController* m_controller;
    79     RefPtr<GeolocationPosition> m_lastPosition;
     79    std::optional<GeolocationPosition> m_lastPosition;
    8080    bool m_hasError;
    8181    String m_errorMessage;

  • trunk/Source/WebKit/ChangeLog

    r223191 r223192  
     12017-10-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Modernize Geolocation code
     4        https://bugs.webkit.org/show_bug.cgi?id=178148
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        * Shared/WebGeolocationPosition.cpp:
     9        (WebKit::WebGeolocationPosition::create):
     10        (WebKit::WebGeolocationPosition::~WebGeolocationPosition):
     11        * Shared/WebGeolocationPosition.h:
     12        (WebKit::WebGeolocationPosition::timestamp const):
     13        (WebKit::WebGeolocationPosition::latitude const):
     14        (WebKit::WebGeolocationPosition::longitude const):
     15        (WebKit::WebGeolocationPosition::accuracy const):
     16        (WebKit::WebGeolocationPosition::altitude const):
     17        (WebKit::WebGeolocationPosition::altitudeAccuracy const):
     18        (WebKit::WebGeolocationPosition::heading const):
     19        (WebKit::WebGeolocationPosition::speed const):
     20        (WebKit::WebGeolocationPosition::corePosition const):
     21        (WebKit::WebGeolocationPosition::WebGeolocationPosition):
     22        * UIProcess/API/C/WKGeolocationPosition.cpp:
     23        (WKGeolocationPositionCreate_b):
     24        * UIProcess/API/Cocoa/_WKGeolocationPosition.mm:
     25        (WebKit::wrapper):
     26        * UIProcess/API/glib/WebKitGeolocationProvider.cpp:
     27        (WebKit::WebKitGeolocationProvider::notifyPositionChanged):
     28        * UIProcess/WebGeolocationManagerProxy.cpp:
     29        (WebKit::WebGeolocationManagerProxy::providerDidChangePosition):
     30        * UIProcess/ios/WKGeolocationProviderIOS.mm:
     31        (-[WKLegacyCoreLocationProvider positionChanged:]):
     32        * WebProcess/Geolocation/WebGeolocationManager.cpp:
     33        (WebKit::WebGeolocationManager::didChangePosition):
     34        * WebProcess/Geolocation/WebGeolocationManager.h:
     35        * WebProcess/Geolocation/WebGeolocationManager.messages.in:
     36        * WebProcess/WebCoreSupport/WebGeolocationClient.cpp:
     37        (WebKit::WebGeolocationClient::lastPosition):
     38        * WebProcess/WebCoreSupport/WebGeolocationClient.h:
     39
    1402017-10-11  Brady Eidson  <beidson@apple.com>
    241

  • trunk/Source/WebKit/Shared/WebGeolocationPosition.cpp

    r204668 r223192  
    3131namespace WebKit {
    3232
    33 WebGeolocationPosition::WebGeolocationPosition(double timestamp, double latitude, double longitude, double accuracy, bool providesAltitude, double altitude, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed)
     33using namespace WebCore;
     34
     35Ref<WebGeolocationPosition> WebGeolocationPosition::create(GeolocationPosition&& geolocationPosition)
    3436{
    35     m_data.timestamp = timestamp;
    36     m_data.latitude = latitude;
    37     m_data.longitude = longitude;
    38     m_data.accuracy = accuracy;
    39     m_data.canProvideAltitude = providesAltitude;
    40     m_data.altitude = altitude;
    41     m_data.canProvideAltitudeAccuracy = providesAltitudeAccuracy;
    42     m_data.altitudeAccuracy = altitudeAccuracy;
    43     m_data.canProvideHeading = providesHeading;
    44     m_data.heading = heading;
    45     m_data.canProvideSpeed = providesSpeed;
    46     m_data.speed = speed;
     37    return adoptRef(*new WebGeolocationPosition(WTFMove(geolocationPosition)));
    4738}
    4839
    … …  
    5142}
    5243
    53 void WebGeolocationPosition::Data::encode(IPC::Encoder& encoder) const
    54 {
    55     IPC::SimpleArgumentCoder<WebGeolocationPosition::Data>::encode(encoder, *this);
    56 }
    57 
    58 bool WebGeolocationPosition::Data::decode(IPC::Decoder& decoder, Data& data)
    59 {
    60     return IPC::SimpleArgumentCoder<WebGeolocationPosition::Data>::decode(decoder, data);
    61 }
    62 
    6344} // namespace WebKit

  • trunk/Source/WebKit/Shared/WebGeolocationPosition.h

    r216764 r223192  
    2828
    2929#include "APIObject.h"
     30#include <WebCore/GeolocationPosition.h>
    3031#include <wtf/RefPtr.h>
    3132
    … …  
    3940class WebGeolocationPosition : public API::ObjectImpl<API::Object::Type::GeolocationPosition> {
    4041public:
    41     struct Data {
    42         void encode(IPC::Encoder&) const;
    43         static bool decode(IPC::Decoder&, Data&);
    44 
    45         double timestamp;
    46         double latitude;
    47         double longitude;
    48         double accuracy;
    49 
    50         double altitude;
    51         double altitudeAccuracy;
    52         double heading;
    53         double speed;
    54 
    55         bool canProvideAltitude;
    56         bool canProvideAltitudeAccuracy;
    57         bool canProvideHeading;
    58         bool canProvideSpeed;
    59     };
    60 
    61     static Ref<WebGeolocationPosition> create(double timestamp, double latitude, double longitude, double accuracy, bool providesAltitude, double altitude, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed)
    62     {
    63         return adoptRef(*new WebGeolocationPosition(timestamp, latitude, longitude, accuracy, providesAltitude, altitude, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed));
    64     }
     42    static Ref<WebGeolocationPosition> create(WebCore::GeolocationPosition&&);
    6543
    6644    virtual ~WebGeolocationPosition();
    6745
    68     double timestamp() const { return m_data.timestamp; }
    69     double latitude() const { return m_data.latitude; }
    70     double longitude() const { return m_data.longitude; }
    71     double accuracy() const { return m_data.accuracy; }
     46    double timestamp() const { return m_corePosition.timestamp; }
     47    double latitude() const { return m_corePosition.latitude; }
     48    double longitude() const { return m_corePosition.longitude; }
     49    double accuracy() const { return m_corePosition.accuracy; }
     50    std::optional<double> altitude() const { return m_corePosition.altitude; }
     51    std::optional<double> altitudeAccuracy() const { return m_corePosition.altitudeAccuracy; }
     52    std::optional<double> heading() const { return m_corePosition.heading; }
     53    std::optional<double> speed() const { return m_corePosition.speed; }
    7254
    73     bool canProvideAltitude() const { return m_data.canProvideAltitude; }
    74     double altitude() const { return m_data.altitude; }
    75 
    76     bool canProvideAltitudeAccuracy() const { return m_data.canProvideAltitudeAccuracy; }
    77     double altitudeAccuracy() const { return m_data.altitudeAccuracy; }
    78 
    79     bool canProvideHeading() const { return m_data.canProvideHeading; }
    80     double heading() const { return m_data.heading; }
    81 
    82     bool canProvideSpeed() const { return m_data.canProvideSpeed; }
    83     double speed() const { return m_data.speed; }
    84 
    85     const Data& data() const { return m_data; }
     55    const WebCore::GeolocationPosition& corePosition() const { return m_corePosition; }
    8656
    8757private:
    88     WebGeolocationPosition(double timestamp, double latitude, double longitude, double accuracy, bool providesAltitude, double altitude, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed);
     58    explicit WebGeolocationPosition(WebCore::GeolocationPosition&& geolocationPosition)
     59        : m_corePosition(WTFMove(geolocationPosition))
     60    {
     61    }
    8962
    90     Data m_data;
     63    WebCore::GeolocationPosition m_corePosition;
    9164};
    9265

  • trunk/Source/WebKit/UIProcess/API/C/WKGeolocationPosition.cpp

    r215246 r223192  
    4444WKGeolocationPositionRef WKGeolocationPositionCreate_b(double timestamp, double latitude, double longitude, double accuracy, bool providesAltitude, double altitude, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed)
    4545{
    46     auto position = WebGeolocationPosition::create(timestamp, latitude, longitude, accuracy, providesAltitude, altitude, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed);
     46    WebCore::GeolocationPosition corePosition { timestamp, latitude, longitude, accuracy };
     47    if (providesAltitude)
     48        corePosition.altitude = altitude;
     49    if (providesAltitudeAccuracy)
     50        corePosition.altitudeAccuracy = altitudeAccuracy;
     51    if (providesHeading)
     52        corePosition.heading = heading;
     53    if (providesSpeed)
     54        corePosition.speed = speed;
     55
     56    auto position = WebGeolocationPosition::create(WTFMove(corePosition));
    4757    return toAPI(&position.leakRef());
    4858}

  • trunk/Source/WebKit/UIProcess/API/Cocoa/_WKGeolocationPosition.mm

    r215246 r223192  
    4040        return nil;
    4141
    42     bool canProvideAltitude = true;
    43     bool canProvideAltitudeAccuracy = true;
    44     double altitude = location.altitude;
    45     double altitudeAccuracy = location.verticalAccuracy;
    46     if (altitudeAccuracy < 0.0) {
    47         canProvideAltitude = false;
    48         canProvideAltitudeAccuracy = false;
    49     }
    50 
    51     bool canProvideSpeed = true;
    52     double speed = location.speed;
    53     if (speed < 0.0)
    54         canProvideSpeed = false;
    55 
    56     bool canProvideHeading = true;
    57     double heading = location.course;
    58     if (heading < 0.0)
    59         canProvideHeading = false;
    60 
    61     CLLocationCoordinate2D coordinate = location.coordinate;
    62     double timestamp = location.timestamp.timeIntervalSince1970;
    63 
    64     return [wrapper(WebGeolocationPosition::create(timestamp, coordinate.latitude, coordinate.longitude, location.horizontalAccuracy, canProvideAltitude, altitude, canProvideAltitudeAccuracy, altitudeAccuracy, canProvideHeading, heading, canProvideSpeed, speed).leakRef()) autorelease];
     42    return [wrapper(WebGeolocationPosition::create(WebCore::GeolocationPosition { location }).leakRef()) autorelease];
    6543}
    6644

  • trunk/Source/WebKit/UIProcess/API/glib/WebKitGeolocationProvider.cpp

    r218487 r223192  
    8282void WebKitGeolocationProvider::notifyPositionChanged(int timestamp, double latitude, double longitude, double altitude, double accuracy, double altitudeAccuracy)
    8383{
    84     RefPtr<WebGeolocationPosition> position = WebGeolocationPosition::create(timestamp, latitude, longitude, accuracy, true, altitude, true, altitudeAccuracy, false, 0, false, 0);
     84    WebCore::GeolocationPosition corePosition { static_cast<double>(timestamp), latitude, longitude, accuracy };
     85    corePosition.altitude = altitude;
     86    corePosition.altitudeAccuracy = altitudeAccuracy;
     87    RefPtr<WebGeolocationPosition> position = WebGeolocationPosition::create(WTFMove(corePosition));
    8588    m_geolocationManager->providerDidChangePosition(position.get());
    8689}

  • trunk/Source/WebKit/UIProcess/WebGeolocationManagerProxy.cpp

    r218259 r223192  
    3030#include "WebGeolocationManagerMessages.h"
    3131#include "WebGeolocationManagerProxyMessages.h"
     32#include "WebGeolocationPosition.h"
    3233#include "WebProcessPool.h"
    3334
    … …  
    9192        return;
    9293
    93     processPool()->sendToAllProcesses(Messages::WebGeolocationManager::DidChangePosition(position->data()));
     94    processPool()->sendToAllProcesses(Messages::WebGeolocationManager::DidChangePosition(position->corePosition()));
    9495}
    9596

  • trunk/Source/WebKit/UIProcess/ios/WKGeolocationProviderIOS.mm

    r221764 r223192  
    7575};
    7676
    77 static inline Ref<WebGeolocationPosition> kit(WebCore::GeolocationPosition *position)
    78 {
    79     return WebGeolocationPosition::create(position->timestamp(), position->latitude(), position->longitude(), position->accuracy(), position->canProvideAltitude(), position->altitude(), position->canProvideAltitudeAccuracy(), position->altitudeAccuracy(), position->canProvideHeading(), position->heading(), position->canProvideSpeed(), position->speed());
    80 }
    81 
    8277struct GeolocationRequestData {
    8378    RefPtr<SecurityOrigin> origin;
    … …  
    305300}
    306301
    307 - (void)positionChanged:(WebCore::GeolocationPosition *)corePosition
    308 {
    309     ASSERT(_listener);
    310     auto position = kit(corePosition);
     302- (void)positionChanged:(WebCore::GeolocationPosition&&)corePosition
     303{
     304    ASSERT(_listener);
     305    auto position = WebGeolocationPosition::create(WTFMove(corePosition));
    311306    [_listener positionChanged:wrapper(position.get())];
    312307}

  • trunk/Source/WebKit/WebProcess/Geolocation/WebGeolocationManager.cpp

    r221743 r223192  
    9292}
    9393
    94 void WebGeolocationManager::didChangePosition(const WebGeolocationPosition::Data& data)
     94void WebGeolocationManager::didChangePosition(const GeolocationPosition& position)
    9595{
    9696#if ENABLE(GEOLOCATION)
    97     RefPtr<GeolocationPosition> position = GeolocationPosition::create(data.timestamp, data.latitude, data.longitude, data.accuracy, data.canProvideAltitude, data.altitude, data.canProvideAltitudeAccuracy, data.altitudeAccuracy, data.canProvideHeading, data.heading, data.canProvideSpeed, data.speed);
    98 
    9997    Vector<RefPtr<WebPage>> webPageCopy;
    10098    copyToVector(m_pageSet, webPageCopy);
    10199    for (auto& page : webPageCopy) {
    102100        if (page->corePage())
    103             GeolocationController::from(page->corePage())->positionChanged(position.get());
     101            GeolocationController::from(page->corePage())->positionChanged(position);
    104102    }
    105103#else
    106     UNUSED_PARAM(data);
     104    UNUSED_PARAM(position);
    107105#endif // ENABLE(GEOLOCATION)
    108106}

  • trunk/Source/WebKit/WebProcess/Geolocation/WebGeolocationManager.h

    r221743 r223192  
    3636namespace WebCore {
    3737class Geolocation;
     38class GeolocationPosition;
    3839}
    3940
    … …  
    6364    bool isHighAccuracyEnabled() const { return !m_highAccuracyPageSet.isEmpty(); }
    6465
    65     void didChangePosition(const WebGeolocationPosition::Data&);
     66    void didChangePosition(const WebCore::GeolocationPosition&);
    6667    void didFailToDeterminePosition(const String& errorMessage);
    6768#if PLATFORM(IOS)

  • trunk/Source/WebKit/WebProcess/Geolocation/WebGeolocationManager.messages.in

    r160022 r223192  
    2222
    2323messages -> WebGeolocationManager {
    24     DidChangePosition(WebKit::WebGeolocationPosition::Data position);
     24    DidChangePosition(WebCore::GeolocationPosition position);
    2525    DidFailToDeterminePosition(String errorMessage);
    2626#if PLATFORM(IOS)

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebGeolocationClient.cpp

    r221743 r223192  
    6565}
    6666
    67 GeolocationPosition* WebGeolocationClient::lastPosition()
     67std::optional<GeolocationPosition> WebGeolocationClient::lastPosition()
    6868{
    6969    // FIXME: Implement this.
    70     return 0;
     70    return std::nullopt;
    7171}
    7272

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebGeolocationClient.h

    r221743 r223192  
    4848    void setEnableHighAccuracy(bool) override;
    4949
    50     WebCore::GeolocationPosition* lastPosition() override;
     50    std::optional<WebCore::GeolocationPosition> lastPosition() override;
    5151
    5252    void requestPermission(WebCore::Geolocation&) override;

  • trunk/Source/WebKitLegacy/ios/ChangeLog

    r222898 r223192  
     12017-10-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Modernize Geolocation code
     4        https://bugs.webkit.org/show_bug.cgi?id=178148
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        * Misc/WebGeolocationCoreLocationProvider.h:
     9        * Misc/WebGeolocationCoreLocationProvider.mm:
     10        (-[WebGeolocationCoreLocationProvider sendLocation:]):
     11        * Misc/WebGeolocationProviderIOS.mm:
     12        (-[_WebCoreLocationUpdateThreadingProxy positionChanged:]):
     13
    1142017-10-04  Alex Christensen  <achristensen@webkit.org>
    215

  • trunk/Source/WebKitLegacy/ios/Misc/WebGeolocationCoreLocationProvider.h

    r204466 r223192  
    4444- (void)geolocationAuthorizationDenied;
    4545
    46 - (void)positionChanged:(WebCore::GeolocationPosition*)position;
     46- (void)positionChanged:(WebCore::GeolocationPosition&&)position;
    4747- (void)errorOccurred:(NSString *)errorMessage;
    4848- (void)resetGeolocation;

  • trunk/Source/WebKitLegacy/ios/Misc/WebGeolocationCoreLocationProvider.mm

    r219191 r223192  
    166166- (void)sendLocation:(CLLocation *)newLocation
    167167{
    168     // Normalize.
    169     bool canProvideAltitude = true;
    170     bool canProvideAltitudeAccuracy = true;
    171     double altitude = newLocation.altitude;
    172     double altitudeAccuracy = newLocation.verticalAccuracy;
    173     if (altitudeAccuracy < 0.0) {
    174         canProvideAltitude = false;
    175         canProvideAltitudeAccuracy = false;
    176     }
    177 
    178     bool canProvideSpeed = true;
    179     double speed = newLocation.speed;
    180     if (speed < 0.0)
    181         canProvideSpeed = false;
    182 
    183     bool canProvideHeading = true;
    184     double heading = newLocation.course;
    185     if (heading < 0.0)
    186         canProvideHeading = false;
    187 
    188     double timestamp = [newLocation.timestamp timeIntervalSince1970];
    189     RefPtr<GeolocationPosition> geolocationPosition = GeolocationPosition::create(timestamp, newLocation.coordinate.latitude, newLocation.coordinate.longitude, newLocation.horizontalAccuracy, canProvideAltitude, altitude, canProvideAltitudeAccuracy, altitudeAccuracy, canProvideHeading, heading, canProvideSpeed, speed);
    190     [_positionListener positionChanged:geolocationPosition.get()];
     168    [_positionListener positionChanged:GeolocationPosition { newLocation }];
    191169}
    192170

  • trunk/Source/WebKitLegacy/ios/Misc/WebGeolocationProviderIOS.mm

    r216816 r223192  
    4545
    4646@interface WebGeolocationPosition (Internal)
    47 - (id)initWithGeolocationPosition:(RefPtr<GeolocationPosition>&&)coreGeolocationPosition;
     47- (id)initWithGeolocationPosition:(GeolocationPosition&&)coreGeolocationPosition;
    4848@end
    4949
    … …  
    362362}
    363363
    364 - (void)positionChanged:(WebCore::GeolocationPosition*)position
    365 {
    366     RetainPtr<WebGeolocationPosition> webPosition = adoptNS([[WebGeolocationPosition alloc] initWithGeolocationPosition:position]);
     364- (void)positionChanged:(WebCore::GeolocationPosition&&)position
     365{
     366    RetainPtr<WebGeolocationPosition> webPosition = adoptNS([[WebGeolocationPosition alloc] initWithGeolocationPosition:WTFMove(position)]);
    367367    WebThreadRun(^{
    368368        [_provider positionChanged:webPosition.get()];

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r223167 r223192  
     12017-10-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Modernize Geolocation code
     4        https://bugs.webkit.org/show_bug.cgi?id=178148
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        * WebCoreSupport/WebGeolocationClient.h:
     9        * WebCoreSupport/WebGeolocationClient.mm:
     10        (WebGeolocationClient::lastPosition):
     11        * WebView/WebGeolocationPosition.mm:
     12        (-[WebGeolocationPositionInternal initWithCoreGeolocationPosition:]):
     13        (core):
     14        (-[WebGeolocationPosition initWithTimestamp:latitude:longitude:accuracy:]):
     15        (-[WebGeolocationPosition initWithGeolocationPosition:]):
     16        * WebView/WebGeolocationPositionInternal.h:
     17
    1182017-10-10  Ryosuke Niwa  <rniwa@webkit.org>
    219

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebGeolocationClient.h

    r221743 r223192  
    4848#endif
    4949
    50     WebCore::GeolocationPosition* lastPosition() override;
     50    std::optional<WebCore::GeolocationPosition> lastPosition() override;
    5151
    5252    void requestPermission(WebCore::Geolocation&) override;

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebGeolocationClient.mm

    r221743 r223192  
    133133}
    134134
    135 GeolocationPosition* WebGeolocationClient::lastPosition()
     135std::optional<GeolocationPosition> WebGeolocationClient::lastPosition()
    136136{
    137137    return core([[m_webView _geolocationProvider] lastPosition]);

  • trunk/Source/WebKitLegacy/mac/WebView/WebGeolocationPosition.mm

    r216816 r223192  
    2727
    2828#import "WebGeolocationPositionInternal.h"
     29#import <WebCore/GeolocationPosition.h>
     30#import <wtf/Optional.h>
    2931#import <wtf/RefPtr.h>
    30 
    31 #import <WebCore/GeolocationPosition.h>
    3232
    3333using namespace WebCore;
    … …  
    3636{
    3737@public
    38     RefPtr<GeolocationPosition> _position;
     38    GeolocationPosition _position;
    3939}
    4040
    41 - (id)initWithCoreGeolocationPosition:(RefPtr<GeolocationPosition>&&)coreGeolocationPosition;
     41- (id)initWithCoreGeolocationPosition:(GeolocationPosition&&)coreGeolocationPosition;
    4242@end
    4343
    4444@implementation WebGeolocationPositionInternal
    4545
    46 - (id)initWithCoreGeolocationPosition:(RefPtr<GeolocationPosition>&&)coreGeolocationPosition
     46- (id)initWithCoreGeolocationPosition:(GeolocationPosition&&)coreGeolocationPosition
    4747{
    4848    self = [super init];
    … …  
    5757@implementation WebGeolocationPosition
    5858
    59 GeolocationPosition* core(WebGeolocationPosition *position)
     59std::optional<GeolocationPosition> core(WebGeolocationPosition *position)
    6060{
    61     return position ? position->_internal->_position.get() : 0;
     61    if (!position)
     62        return std::nullopt;
     63    return position->_internal->_position;
    6264}
    6365
    … …  
    6769    if (!self)
    6870        return nil;
    69     _internal = [[WebGeolocationPositionInternal alloc] initWithCoreGeolocationPosition:GeolocationPosition::create(timestamp, latitude, longitude, accuracy)];
     71    _internal = [[WebGeolocationPositionInternal alloc] initWithCoreGeolocationPosition:GeolocationPosition { timestamp, latitude, longitude, accuracy }];
    7072    return self;
    7173}
    7274
    73 - (id)initWithGeolocationPosition:(RefPtr<GeolocationPosition>&&)coreGeolocationPosition
     75- (id)initWithGeolocationPosition:(GeolocationPosition&&)coreGeolocationPosition
    7476{
    7577    self = [super init];

  • trunk/Source/WebKitLegacy/mac/WebView/WebGeolocationPositionInternal.h

    r110595 r223192  
    2525
    2626#import "WebGeolocationPosition.h"
     27#import <wtf/Optional.h>
    2728
    2829namespace WebCore {
    … …  
    3031}
    3132
    32 WebCore::GeolocationPosition* core(WebGeolocationPosition *);
     33std::optional<WebCore::GeolocationPosition> core(WebGeolocationPosition *);
    3334

  • trunk/Source/WebKitLegacy/win/ChangeLog

    r222938 r223192  
     12017-10-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Modernize Geolocation code
     4        https://bugs.webkit.org/show_bug.cgi?id=178148
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        * WebCoreSupport/WebGeolocationClient.cpp:
     9        (WebGeolocationClient::lastPosition):
     10        * WebCoreSupport/WebGeolocationClient.h:
     11        * WebGeolocationPosition.cpp:
     12        (WebGeolocationPosition::initWithTimestamp):
     13        (core):
     14        * WebGeolocationPosition.h:
     15        (WebGeolocationPosition::impl const):
     16
    1172017-10-05  Chris Dumez  <cdumez@apple.com>
    218

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebGeolocationClient.cpp

    r221743 r223192  
    6565}
    6666
    67 GeolocationPosition* WebGeolocationClient::lastPosition()
     67std::optional<GeolocationPosition> WebGeolocationClient::lastPosition()
    6868{
    6969    COMPtr<IWebGeolocationProvider> provider;
    7070    if (FAILED(m_webView->geolocationProvider(&provider)))
    71         return 0;
     71        return std::nullopt;
    7272    COMPtr<IWebGeolocationPosition> position;
    7373    if (FAILED(provider->lastPosition(&position)))
    74         return 0;
     74        return std::nullopt;
    7575    return core(position.get());
    7676}

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebGeolocationClient.h

    r221743 r223192  
    4444    void stopUpdating() final;
    4545    void setEnableHighAccuracy(bool) final { }
    46     WebCore::GeolocationPosition* lastPosition() final;
     46    std::optional<WebCore::GeolocationPosition> lastPosition() final;
    4747
    4848    void requestPermission(WebCore::Geolocation&) final;

  • trunk/Source/WebKitLegacy/win/WebGeolocationPosition.cpp

    r188662 r223192  
    8282HRESULT WebGeolocationPosition::initWithTimestamp(double timestamp, double latitude, double longitude, double accuracy)
    8383{
    84     m_position = GeolocationPosition::create(timestamp, latitude, longitude, accuracy);
     84    m_position = GeolocationPosition { timestamp, latitude, longitude, accuracy };
    8585    return S_OK;
    8686}
    8787
    88 GeolocationPosition* core(IWebGeolocationPosition* position)
     88std::optional<GeolocationPosition> core(IWebGeolocationPosition* position)
    8989{
    9090    if (!position)
    91         return 0;
     91        return std::nullopt;
    9292
    9393    COMPtr<WebGeolocationPosition> webGeolocationPosition(Query, position);
    9494    if (!webGeolocationPosition)
    95         return 0;
     95        return std::nullopt;
    9696
    9797    return webGeolocationPosition->impl();

  • trunk/Source/WebKitLegacy/win/WebGeolocationPosition.h

    r188662 r223192  
    2828#include "WebKit.h"
    2929#include <WebCore/COMPtr.h>
    30 
    31 namespace WebCore {
    32     class GeolocationPosition;
    33 };
     30#include <WebCore/GeolocationPosition.h>
    3431
    3532class WebGeolocationPosition : public IWebGeolocationPosition {
    … …  
    4946    virtual HRESULT STDMETHODCALLTYPE initWithTimestamp(double timestamp, double latitude, double longitude, double accuracy);
    5047
    51     WebCore::GeolocationPosition* impl() const { return m_position.get(); }
     48    const std::optional<WebCore::GeolocationPosition>& impl() const { return m_position; }
    5249
    5350private:
    5451    ULONG m_refCount { 0 };
    55     RefPtr<WebCore::GeolocationPosition> m_position;
     52    std::optional<WebCore::GeolocationPosition> m_position;
    5653};
    5754
    58 WebCore::GeolocationPosition* core(IWebGeolocationPosition*);
     55std::optional<WebCore::GeolocationPosition> core(IWebGeolocationPosition*);
    5956
    6057#endif // WebGeolocationPosition_h

  • trunk/Tools/ChangeLog

    r223178 r223192  
     12017-10-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Modernize Geolocation code
     4        https://bugs.webkit.org/show_bug.cgi?id=178148
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        * DumpRenderTree/mac/TestRunnerMac.mm:
     9        (TestRunner::setMockGeolocationPosition):
     10
    1112017-10-11  Nael Ouedraogo  <nael.ouedraogo@crf.canon.fr>
    212

  • trunk/Tools/DumpRenderTree/mac/TestRunnerMac.mm

    r222097 r223192  
    126126
    127127@interface WebGeolocationPosition (Internal)
    128 - (id)initWithGeolocationPosition:(RefPtr<WebCore::GeolocationPosition>)coreGeolocationPosition;
     128- (id)initWithGeolocationPosition:(WebCore::GeolocationPosition&&)coreGeolocationPosition;
    129129@end
    130130
    … …  
    450450        position = [[WebGeolocationPosition alloc] initWithTimestamp:currentTime() latitude:latitude longitude:longitude accuracy:accuracy];
    451451    } else {
    452         auto coreGeolocationPosition = WebCore::GeolocationPosition::create(currentTime(), latitude, longitude, accuracy, providesAltitude, altitude, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed);
    453         position = [[WebGeolocationPosition alloc] initWithGeolocationPosition:(WTFMove(coreGeolocationPosition))];
     452        WebCore::GeolocationPosition geolocationPosition { currentTime(), latitude, longitude, accuracy };
     453        if (providesAltitude)
     454            geolocationPosition.altitude = altitude;
     455        if (providesAltitudeAccuracy)
     456            geolocationPosition.altitudeAccuracy = altitudeAccuracy;
     457        if (providesHeading)
     458            geolocationPosition.heading = heading;
     459        if (providesSpeed)
     460            geolocationPosition.speed = speed;
     461        position = [[WebGeolocationPosition alloc] initWithGeolocationPosition:(WTFMove(geolocationPosition))];
    454462    }
    455463    [[MockGeolocationProvider shared] setPosition:position];
Note: See TracChangeset for help on using the changeset viewer.