Pass through geofencing API calls to the content layer.

Source/modules/geofencing/Geofencing.cpp

 // 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/geofencing/Geofencing.h"
 
+#include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
+#include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
+#include "modules/geofencing/GeofencingError.h"
+#include "modules/geofencing/GeofencingRegion.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebGeofencingProvider.h"
 
 namespace blink {
 
+namespace {
+
+// Copy of same class in ServiceWorkerContainer.cpp

[esprehn, 2014/08/19 01:15:59]

How can we fix this code duplication?

[Marijn Kruisselbrink, 2014/08/19 18:55:13]

By adding more explicit support to WebCallbacks and CallbackPromiseAdapter for
promises that resolve to undefined probably. The situation in
ServiceWorkerContainer and ServiceWorkerRegistration is actually worse, since
both those classes define their own blink::UndefinedValue class, neither of them
in an anonymous namespace. Doing that would also solve the "must always pass
null to onSuccess" comments that are sprinkled throughout the serviceworker
code.

[Marijn Kruisselbrink, 2014/08/19 18:58:50]

Actually it seems the WebCallbacks side of things already got fixed for that, so
it's just CallbackPromiseAdapter that would need to be fixed, which shouldn't be
hard either.

[Marijn Kruisselbrink, 2014/08/19 19:13:07]

In my currently last patchset I got rid of this UndefinedValue class by adding
support for void to CallbackPromiseAdapter. The duplication of most of that
class seems a bit icky, but I'm not sure if there are better template tricks to
do what I want. Also maybe this part should be a separate CL, and certainly
porting the Service Worker code to get rid of the UndefinedValue classes will be
a separate CL as that will involve changing code on both the blink and content
sides.

+class UndefinedValue {
+public:
+    typedef blink::WebGeofencingError WebType;
+    static V8UndefinedType take(ScriptPromiseResolver* resolver, WebType* value)
+    {
+        ASSERT(!value); // Anything passed here will be leaked.
+        return V8UndefinedType();
+    }
+
+    static void dispose(WebType* value)
+    {
+        ASSERT(!value); // Anything passed here will be leaked.
+    }
+
+private:
+    UndefinedValue();
+};
+
+class RegionArray {
+public:
+    typedef blink::WebVector<blink::WebGeofencingRegion> WebType;
+    static HeapVector<Member<GeofencingRegion> > take(ScriptPromiseResolver* resolver, WebType* regionsRaw)
+    {
+        OwnPtr<WebType> webRegions = adoptPtr(regionsRaw);
+        HeapVector<Member<GeofencingRegion> > regions;
+        for (size_t i = 0; i < webRegions->size(); ++i) {
+            regions.append(GeofencingRegion::createFromWebRegion((*webRegions)[i]));
+        }
+        return regions;
+    }
+
+    static void dispose(WebType* regionsRaw)
+    {
+        delete regionsRaw;
+    }
+
+private:
+    RegionArray();
+};
+
+} // namespace
+
 Geofencing::Geofencing()
 {
     ScriptWrappable::init(this);
 }
 
 ScriptPromise Geofencing::registerRegion(ScriptState* scriptState, GeofencingRegion* region)
 {
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    WebGeofencingProvider* provider = Platform::current()->geofencingProvider();
+    if (!provider) {
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    }
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    // TODO(mek): somehow pass a reference to the current serviceworker to the provider.
+    provider->registerRegion(region->webRegion(), new CallbackPromiseAdapter<UndefinedValue, GeofencingError>(resolver));
+    return promise;
 }
 
 ScriptPromise Geofencing::unregisterRegion(ScriptState* scriptState, const String& regionId)
 {
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    WebGeofencingProvider* provider = Platform::current()->geofencingProvider();
+    if (!provider) {
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    }
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    // TODO(mek): somehow pass a reference to the current serviceworker to the provider.
+    provider->unregisterRegion(regionId, new CallbackPromiseAdapter<UndefinedValue, GeofencingError>(resolver));
+    return promise;
 }
 
 ScriptPromise Geofencing::getRegisteredRegions(ScriptState* scriptState) const
 {
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    WebGeofencingProvider* provider = Platform::current()->geofencingProvider();
+    if (!provider) {
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    }

[esprehn, 2014/08/19 01:15:59]

no braces

[Marijn Kruisselbrink, 2014/08/19 18:55:14]

Done.

+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    // TODO(mek): somehow pass a reference to the current serviceworker to the provider.
+    provider->getRegisteredRegions(new CallbackPromiseAdapter<RegionArray, GeofencingError>(resolver));
+    return promise;
 }
 
 } // namespace blink