Geolocation.cpp

namespace WebCore {

38 Geolocation::GeoNotifier::GeoNotifier(Geolocation* geolocation, PassRefPtr<PositionCallback> successCallback, PassRefPtr<PositionErrorCallback> errorCallback, PassRefPtr<PositionOptions> options)

39 : m_geolocation(geolocation)

static const int firstOneShotId = 1 << 30;

static const int firstWatchId = 1;

Geolocation::GeoNotifier::GeoNotifier(int requestId, Geolocation* geolocation, PassRefPtr<PositionCallback> successCallback, PassRefPtr<PositionErrorCallback> errorCallback, PassRefPtr<PositionOptions> options)

    : m_requestId(requestId)

    , m_geolocation(geolocation)

    , m_successCallback(successCallback)

    , m_errorCallback(errorCallback)

    , m_options(options)

@@void Geolocation::GeoNotifier::timerFire

        RefPtr<PositionError> error = PositionError::create(PositionError::TIMEOUT, "Timeout expired");

        m_errorCallback->handleEvent(error.get());

    }

70 m_geolocation->requestTimedOut(~~this~~);

74 m_geolocation->requestTimedOut(m_requestId);

}

Geolocation::Geolocation(Frame* frame)

@@void Geolocation::disconnectFrame()

void Geolocation::getCurrentPosition(PassRefPtr<PositionCallback> successCallback, PassRefPtr<PositionErrorCallback> errorCallback, PassRefPtr<PositionOptions> options)

{

95 RefPtr<GeoNotifier> notifier = GeoNotifier::create(this, successCallback, errorCallback, options);

    static int nextAvailableOneShotId = firstOneShotId;

    // Handle wrap-around.

    if (!isOneShotRequest(nextAvailableOneShotId))

        nextAvailableOneShotId = firstOneShotId;

96103

    if (notifier->hasZeroTimeout() || m_service->startUpdating(notifier->m_options.get()))

        notifier->startTimerIfNeeded();

    else {

        if (notifier->m_errorCallback) {

            RefPtr<PositionError> error = PositionError::create(PositionError::PERMISSION_DENIED, "Unable to Start");

            notifier->m_errorCallback->handleEvent(error.get());

        }

104 RefPtr<GeoNotifier> notifier = startRequest(nextAvailableOneShotId, successCallback, errorCallback, options);

105 if (!notifier)

104106 return;

105 }

106107

107 m_oneShots.add(notifier);

108 m_notifiers.set(nextAvailableOneShotId, notifier);

109 nextAvailableOneShotId++;

}

int Geolocation::watchPosition(PassRefPtr<PositionCallback> successCallback, PassRefPtr<PositionErrorCallback> errorCallback, PassRefPtr<PositionOptions> options)

{

112 RefPtr<GeoNotifier> notifier = GeoNotifier::create(this, successCallback, errorCallback, options);

    static int nextAvailableWatchId = firstWatchId;

    // Handle wrap-around.

    if (isOneShotRequest(nextAvailableWatchId))

        nextAvailableWatchId = firstWatchId;

    RefPtr<GeoNotifier> notifier = startRequest(nextAvailableWatchId, successCallback, errorCallback, options);

    if (!notifier)

        return 0;

    m_notifiers.set(nextAvailableWatchId, notifier);

    return nextAvailableWatchId++;

}

PassRefPtr<Geolocation::GeoNotifier> Geolocation::startRequest(int requestId, PassRefPtr<PositionCallback> successCallback, PassRefPtr<PositionErrorCallback> errorCallback, PassRefPtr<PositionOptions> options)

{

    RefPtr<GeoNotifier> notifier = GeoNotifier::create(requestId, this, successCallback, errorCallback, options);

    if (notifier->hasZeroTimeout() || m_service->startUpdating(notifier->m_options.get()))

        notifier->startTimerIfNeeded();

@@int Geolocation::watchPosition(PassRefPt

        }

        return 0;

    }

    
    static int sIdentifier = 0;

    m_watchers.set(++sIdentifier, notifier);

127140

128 return ~~sIde~~ntifier;

141 return notifier.release();

129142}

130143

131 void Geolocation::requestTimedOut(G~~eoNotifier* notifier~~)

144void Geolocation::requestTimedOut(int requestId)

132145{

146 ASSERT(m_notifiers.contains(requestId));

147

133148 // If this is a one-shot request, stop it.

134 m_oneShots.remove(notifier);

149 if (!isOneShotRequest(requestId))

150 return;

135151

152 m_notifiers.remove(requestId);

    if (!hasListeners())

        m_service->stopUpdating();

}

void Geolocation::clearWatch(int watchId)

{

142 m_watchers.remove(watchId);

143

    if (isOneShotRequest(watchId))

        return;

    m_notifiers.remove(watchId);

    if (!hasListeners())

        m_service->stopUpdating();

}

@@void Geolocation::setIsAllowed(bool allo

    }

}

173 v~~oid~~ Geolocation::s~~endError(Vector<RefP~~t~~r<GeoNotifier> >& notifiers, PositionError* error~~)

192bool Geolocation::isOneShotRequest(int requestId)

174193{

     Vector<RefPtr<GeoNotifier> >::const_iterator end = notifiers.end();

     for (Vector<RefPtr<GeoNotifier> >::const_iterator it = notifiers.begin(); it != end; ++it) {

         RefPtr<GeoNotifier> notifier = *it;

         if (notifier->m_errorCallback)

             notifier->m_errorCallback->handleEvent(error);

     }

194 // This relies on the fact that one-shot request IDs are greater than watch IDs.

195 return requestId >= firstOneShotId;

182196}

183197

184 void Geolocation::sendP~~osition~~(Vector<RefPtr<GeoNotifier> >& notifiers, ~~Geop~~osition* p~~osition~~)

198void Geolocation::sendError(Vector<RefPtr<GeoNotifier> >& notifiers, PositionError* error)

{

    Vector<RefPtr<GeoNotifier> >::const_iterator end = notifiers.end();

    for (Vector<RefPtr<GeoNotifier> >::const_iterator it = notifiers.begin(); it != end; ++it) {

        RefPtr<GeoNotifier> notifier = *it;

        ASSERT(notifier->m_successCallback);

        notifier->m_successCallback->handleEvent(position);

        if (notifier->m_errorCallback)

            notifier->m_errorCallback->handleEvent(error);

    }

}

195 void Geolocation::st~~opTimer~~(Vector<RefPtr<GeoNotifier> >& notifiers)

209void Geolocation::sendPosition(Vector<RefPtr<GeoNotifier> >& notifiers, Geoposition* position)

{

    Vector<RefPtr<GeoNotifier> >::const_iterator end = notifiers.end();

    for (Vector<RefPtr<GeoNotifier> >::const_iterator it = notifiers.begin(); it != end; ++it) {

        RefPtr<GeoNotifier> notifier = *it;

200 notifier->m_timer.stop();

        ASSERT(notifier->m_successCallback);

        notifier->m_successCallback->handleEvent(position);

    }

}

void Geolocation::stopTimersForOneShots()

{

    Vector<RefPtr<GeoNotifier> > copy;

    copyToVector(m_oneShots, copy);

    stopTimer(copy);

}

void Geolocation::stopTimersForWatchers()

{

    Vector<RefPtr<GeoNotifier> > copy;

    copyValuesToVector(m_watchers, copy);

    stopTimer(copy);

}

220220void Geolocation::stopTimers()

221221{

222 stopTimersForOneShots();

223 stopTimersForWatchers();

    GeoNotifierMap::const_iterator end = m_notifiers.end();

    for (GeoNotifierMap::const_iterator it = m_notifiers.begin(); it != end; ++it) {

        GeoNotifier* notifier = it->second.get();

        notifier->m_timer.stop();

    }

}

void Geolocation::handleError(PositionError* error)

{

    ASSERT(error);

    Vector<RefPtr<GeoNotifier> > oneShotsCopy;

    copyToVector(m_oneShots, oneShotsCopy);

    Vector<RefPtr<GeoNotifier> > watchersCopy;

    copyValuesToVector(m_watchers, watchersCopy);

233 Vector<RefPtr<GeoNotifier> > copy;

234 copyValuesToVector(m_notifiers, copy);

235235

236 // Clear the l~~ist~~s before we make the callbacks, to avoid clearing notifiers

236 // Clear the notifiers before we make the callbacks, to avoid clearing notifiers

237237 // added by calls to Geolocation methods from the callbacks, and to prevent

238238 // further callbacks to these notifiers.

239 m_oneShots.clear();

240239 if (error->isFatal())

241 m_watchers.clear();

        m_notifiers.clear();

    else

        clearOneShots();

242243

243 sendError(oneShotsCopy, error);

244 sendError(watchersCopy, error);

244 sendError(copy, error);

    if (!hasListeners())

        m_service->stopUpdating();

@@void Geolocation::makeSuccessCallbacks()

    ASSERT(m_service->lastPosition());

    ASSERT(isAllowed());

    Vector<RefPtr<GeoNotifier> > oneShotsCopy;

    copyToVector(m_oneShots, oneShotsCopy);

    Vector<RefPtr<GeoNotifier> > watchersCopy;

    copyValuesToVector(m_watchers, watchersCopy);

293 Vector<RefPtr<GeoNotifier> > copy;

294 copyValuesToVector(m_notifiers, copy);

298295

299 // Clear the lists before we make the callbacks, to avoid clearing notifiers

296 // Clear the one-shots before we make the callbacks, to avoid clearing notifiers

300297 // added by calls to Geolocation methods from the callbacks, and to prevent

301298 // further callbacks to these notifiers.

302 ~~m_o~~neShots~~.clear~~();

299 clearOneShots();

303300

304 sendPosition(oneShotsCopy, m_service->lastPosition());

305 sendPosition(watchersCopy, m_service->lastPosition());

301 sendPosition(copy, m_service->lastPosition());

    if (!hasListeners())

        m_service->stopUpdating();

@@void Geolocation::geolocationServiceErro

    handleError(service->lastError());

}

void Geolocation::clearOneShots()

{

    Vector<int> oneShotIds;

    GeoNotifierMap::const_iterator end = m_notifiers.end();

    for (GeoNotifierMap::const_iterator iter = m_notifiers.begin(); iter != end; ++iter) {

        if (isOneShotRequest(iter->first))

            oneShotIds.append(iter->first);

    }

    for (Vector<int>::const_iterator iter = oneShotIds.begin(); iter != oneShotIds.end(); iter++)

        m_notifiers.remove(*iter);

}

318326} // namespace WebCore

49203

WebCore/page/Geolocation.h

#include "Timer.h"

#include <wtf/Platform.h>

#include <wtf/HashMap.h>

36 #include <wtf/HashSet.h>

#include <wtf/OwnPtr.h>

#include <wtf/PassRefPtr.h>

#include <wtf/RefCounted.h>

@@private:

    class GeoNotifier : public RefCounted<GeoNotifier> {

    public:

76 static PassRefPtr<GeoNotifier> create(Geolocation* geolocation, PassRefPtr<PositionCallback> positionCallback, PassRefPtr<PositionErrorCallback> positionErrorCallback, PassRefPtr<PositionOptions> options) { return adoptRef(new GeoNotifier(geolocation, positionCallback, positionErrorCallback, options)); }

75 static PassRefPtr<GeoNotifier> create(int requestId, Geolocation* geolocation, PassRefPtr<PositionCallback> positionCallback, PassRefPtr<PositionErrorCallback> positionErrorCallback, PassRefPtr<PositionOptions> options) { return adoptRef(new GeoNotifier(requestId, geolocation, positionCallback, positionErrorCallback, options)); }

        
        bool hasZeroTimeout() const;

        void startTimerIfNeeded();

        void timerFired(Timer<GeoNotifier>*);

81 int m_requestId;

        Geolocation* m_geolocation;

        RefPtr<PositionCallback> m_successCallback;

        RefPtr<PositionErrorCallback> m_errorCallback;

@@private:

        Timer<GeoNotifier> m_timer;

    private:

89 GeoNotifier(Geolocation*, PassRefPtr<PositionCallback>, PassRefPtr<PositionErrorCallback>, PassRefPtr<PositionOptions>);

89 GeoNotifier(int requestId, Geolocation*, PassRefPtr<PositionCallback>, PassRefPtr<PositionErrorCallback>, PassRefPtr<PositionOptions>);

9090 };

9191

92 bool hasListeners() const { return !m_oneShots.isEmpty() || !m_watchers.isEmpty(); }

    PassRefPtr<GeoNotifier> startRequest(int requestId, PassRefPtr<PositionCallback>, PassRefPtr<PositionErrorCallback>, PassRefPtr<PositionOptions>);

    bool hasListeners() const { return !m_notifiers.isEmpty(); }

    static bool isOneShotRequest(int requestId);

    void sendError(Vector<RefPtr<GeoNotifier> >&, PositionError*);

    void sendPosition(Vector<RefPtr<GeoNotifier> >&, Geoposition*);

    static void stopTimer(Vector<RefPtr<GeoNotifier> >&);

    void stopTimersForOneShots();

    void stopTimersForWatchers();

    void stopTimers();

    void makeSuccessCallbacks();

@@private:

    virtual void geolocationServicePositionChanged(GeolocationService*);

    virtual void geolocationServiceErrorOccurred(GeolocationService*);

111 void requestTimedOut(GeoNotifier*);

    void requestTimedOut(int requestId);

    void clearOneShots();

112115

113 typedef HashSet<RefPtr<GeoNotifier> > GeoNotifierSet;

116 // A map from notifier ID to notifier. We use positive IDs for watchers, and

117 // negative IDs for one-shots. Only watcher IDs are exposed to JS.

114118 typedef HashMap<int, RefPtr<GeoNotifier> > GeoNotifierMap;

    
    GeoNotifierSet m_oneShots;

    GeoNotifierMap m_watchers;

119 GeoNotifierMap m_notifiers;

120

    Frame* m_frame;

    OwnPtr<GeolocationService> m_service;

49203

WebCore/ChangeLog

WebCore/page/Geolocation.cpp

WebCore/page/Geolocation.h