Separate GeoNotifier class from Geolocation

Source/modules/geolocation/GeoNotifier.cpp

Index: Source/modules/geolocation/GeoNotifier.cpp
diff --git a/Source/modules/geolocation/GeoNotifier.cpp b/Source/modules/geolocation/GeoNotifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5702ec4d4fec50b969b8aa482b1a1f35c476f3ea
--- /dev/null
+++ b/Source/modules/geolocation/GeoNotifier.cpp
@@ -0,0 +1,109 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "modules/geolocation/GeoNotifier.h"
+
+#include "modules/geolocation/Geolocation.h"
+#include "modules/geolocation/PositionCallback.h"
+#include "modules/geolocation/PositionError.h"
+#include "modules/geolocation/PositionErrorCallback.h"
+#include "modules/geolocation/PositionOptions.h"
+
+namespace WebCore {
+
+GeoNotifier::GeoNotifier(Geolocation* geolocation, PassOwnPtr<PositionCallback> successCallback, PassOwnPtr<PositionErrorCallback> errorCallback, PositionOptions* options)
+    // FIXME : m_geolocation sould be removed, it makes circular dependancy.

[Michael van Ouwerkerk, 2014/07/15 13:47:08]

How do you plan to fix this?

[kihong, 2014/07/15 15:05:16]

"sould -> should" will be changed before landing.

+    : m_geolocation(geolocation)
+    , m_successCallback(successCallback)
+    , m_errorCallback(errorCallback)
+    , m_options(options)
+    , m_timer(this, &GeoNotifier::timerFired)
+    , m_useCachedPosition(false)
+{
+    ASSERT(m_geolocation);
+    ASSERT(m_successCallback);
+    ASSERT(m_options);
+}
+
+void GeoNotifier::trace(Visitor* visitor)
+{
+    visitor->trace(m_geolocation);
+    visitor->trace(m_options);
+    visitor->trace(m_fatalError);
+}
+
+void GeoNotifier::setFatalError(PositionError* error)
+{
+    // If a fatal error has already been set, stick with it. This makes sure that
+    // when permission is denied, this is the error reported, as required by the
+    // spec.
+    if (m_fatalError)
+        return;
+
+    m_fatalError = error;
+    // An existing timer may not have a zero timeout.
+    m_timer.stop();
+    m_timer.startOneShot(0, FROM_HERE);
+}
+
+void GeoNotifier::setUseCachedPosition()
+{
+    m_useCachedPosition = true;
+    m_timer.startOneShot(0, FROM_HERE);
+}
+
+void GeoNotifier::runSuccessCallback(Geoposition* position)
+{
+    // If we are here and the Geolocation permission is not approved, something has
+    // gone horribly wrong.
+    if (!m_geolocation->isAllowed())
+        CRASH();
+
+    m_successCallback->handleEvent(position);
+}
+
+void GeoNotifier::runErrorCallback(PositionError* error)
+{
+    if (m_errorCallback)
+        m_errorCallback->handleEvent(error);
+}
+
+void GeoNotifier::startTimer()
+{
+    m_timer.startOneShot(m_options->timeout() / 1000.0, FROM_HERE);
+}
+
+void GeoNotifier::stopTimer()
+{
+    m_timer.stop();
+}
+
+void GeoNotifier::timerFired(Timer<GeoNotifier>*)
+{
+    m_timer.stop();
+
+    // Test for fatal error first. This is required for the case where the LocalFrame is
+    // disconnected and requests are cancelled.
+    if (m_fatalError) {
+        runErrorCallback(m_fatalError.get());
+        // This will cause this notifier to be deleted.
+        m_geolocation->fatalErrorOccurred(this);
+        return;
+    }
+
+    if (m_useCachedPosition) {
+        // Clear the cached position flag in case this is a watch request, which
+        // will continue to run.
+        m_useCachedPosition = false;
+        m_geolocation->requestUsesCachedPosition(this);
+        return;
+    }
+
+    if (m_errorCallback)
+        m_errorCallback->handleEvent(PositionError::create(PositionError::TIMEOUT, "Timeout expired"));
+    m_geolocation->requestTimedOut(this);
+}
+
+} // namespace WebCore