Separate GeoNotifier class from Geolocation

Source/modules/geolocation/Geolocation.h

 /*
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All Rights Reserved.
  * Copyright 2010, The Android Open Source Project
  *
  * 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
@@ skipping 12 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Geolocation_h
 #define Geolocation_h
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/dom/ActiveDOMObject.h"
+#include "modules/geolocation/GeoNotifier.h"
 #include "modules/geolocation/Geoposition.h"
 #include "modules/geolocation/PositionCallback.h"
 #include "modules/geolocation/PositionError.h"
 #include "modules/geolocation/PositionErrorCallback.h"
 #include "modules/geolocation/PositionOptions.h"
 #include "platform/Timer.h"
 #include "platform/heap/Handle.h"
 
 namespace WebCore {
 
@@ skipping 34 matching lines @@
 
     bool isAllowed() const { return m_geolocationPermission == PermissionAllowed; }
 
     // Notifies this that a new position is available. Must never be called
     // before permission is granted by the user.
     void positionChanged();
 
     // Notifies this that an error has occurred, it must be handled immediately.
     void setError(GeolocationError*);
 
+    // Discards the notifier because a fatal error occurred for it.
+    void fatalErrorOccurred(GeoNotifier*);
+
+    // Adds the notifier to the set awaiting a cached position. Runs the success
+    // callbacks for them if permission has been granted. Requests permission if
+    // it is unknown.
+    void requestUsesCachedPosition(GeoNotifier*);
+
+    // Discards the notifier if it is a oneshot because it timed it.
+    void requestTimedOut(GeoNotifier*);
+
     ScriptPromise registerRegion(ScriptState*, GeofencingRegion*);
     ScriptPromise unregisterRegion(ScriptState*, const String& regionId);
     ScriptPromise getRegisteredRegions(ScriptState*) const;
 
 private:
     // Returns the last known position, if any. May return null.
     Geoposition* lastPosition();
 
     bool isDenied() const { return m_geolocationPermission == PermissionDenied; }
 
     explicit Geolocation(ExecutionContext*);
 
-    // Holds the success and error callbacks and the options that were provided
-    // when a oneshot or watcher were created. Also, if specified in the
-    // options, manages a timer to limit the time to wait for the system to
-    // obtain a position.
-    class GeoNotifier : public GarbageCollectedFinalized<GeoNotifier> {
-    public:
-        static GeoNotifier* create(Geolocation* geolocation, PassOwnPtr<PositionCallback> positionCallback, PassOwnPtr<PositionErrorCallback> positionErrorCallback, PositionOptions* options)
-        {
-            return new GeoNotifier(geolocation, positionCallback, positionErrorCallback, options);
-        }
-        void trace(Visitor*);
-
-        PositionOptions* options() const { return m_options.get(); };
-
-        // Sets the given error as the fatal error if there isn't one yet.
-        // Starts the timer with an interval of 0.
-        void setFatalError(PositionError*);
-
-        bool useCachedPosition() const { return m_useCachedPosition; }
-
-        // Tells the notifier to use a cached position and starts its timer with
-        // an interval of 0.
-        void setUseCachedPosition();
-
-        void runSuccessCallback(Geoposition*);
-        void runErrorCallback(PositionError*);
-
-        void startTimer();
-        void stopTimer();
-
-        // Runs the error callback if there is a fatal error. Otherwise, if a
-        // cached position must be used, registers itself for receiving one.
-        // Otherwise, the notifier has expired, and its error callback is run.
-        void timerFired(Timer<GeoNotifier>*);
-
-    private:
-        GeoNotifier(Geolocation*, PassOwnPtr<PositionCallback>, PassOwnPtr<PositionErrorCallback>, PositionOptions*);
-
-        Member<Geolocation> m_geolocation;
-        OwnPtr<PositionCallback> m_successCallback;
-        OwnPtr<PositionErrorCallback> m_errorCallback;
-        Member<PositionOptions> m_options;
-        Timer<GeoNotifier> m_timer;
-        Member<PositionError> m_fatalError;
-        bool m_useCachedPosition;
-    };
-
     typedef HeapVector<Member<GeoNotifier> > GeoNotifierVector;
     typedef HeapHashSet<Member<GeoNotifier> > GeoNotifierSet;
 
     class Watchers {
         DISALLOW_ALLOCATION();
     public:
         void trace(Visitor*);
         bool add(int id, GeoNotifier*);
         GeoNotifier* find(int id);
         void remove(int id);
@@ skipping 53 matching lines @@
     // Processes the notifiers that were waiting for a permission decision. If
     // granted and this can be registered with the controller then the
     // notifier's timers are started. Otherwise, a fatal error is set on them.
     void handlePendingPermissionNotifiers();
 
     // Attempts to obtain a position for the given notifier, either by using
     // the cached position or by requesting one from the controller. Sets a
     // fatal error if permission is denied or no position can be obtained.
     void startRequest(GeoNotifier*);
 
-    // Discards the notifier because a fatal error occurred for it.
-    void fatalErrorOccurred(GeoNotifier*);
-
-    // Discards the notifier if it is a oneshot because it timed it.
-    void requestTimedOut(GeoNotifier*);
-
-    // Adds the notifier to the set awaiting a cached position. Runs the success
-    // callbacks for them if permission has been granted. Requests permission if
-    // it is unknown.
-    void requestUsesCachedPosition(GeoNotifier*);
-
     bool haveSuitableCachedPosition(PositionOptions*);
 
     // Runs the success callbacks for the set of notifiers awaiting a cached
     // position, the set is then cleared. The oneshots are removed everywhere.
     void makeCachedPositionCallbacks();
 
     GeoNotifierSet m_oneShots;
     Watchers m_watchers;
     GeoNotifierSet m_pendingForPermissionNotifiers;
     Member<Geoposition> m_lastPosition;
 
     // States of Geolocation permission as granted by the embedder. Unknown
     // means that the embedder still has to be asked for the current permission
     // level; Requested means that the user has yet to make a decision.
     enum Permission {
         PermissionUnknown,
         PermissionRequested,
         PermissionAllowed,
         PermissionDenied
     };
 
     Permission m_geolocationPermission;
 
     GeoNotifierSet m_requestsAwaitingCachedPosition;
 };
 
 } // namespace WebCore
 
 #endif // Geolocation_h