Use "Dictionary" for PositionOptions instead of Custom binding

Source/modules/geolocation/PositionOptions.cpp

Index: Source/modules/geolocation/PositionOptions.cpp
diff --git a/Source/modules/geolocation/PositionOptions.cpp b/Source/modules/geolocation/PositionOptions.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e777da2a217344eac5a23b00f60bf4916efb492a
--- /dev/null
+++ b/Source/modules/geolocation/PositionOptions.cpp
@@ -0,0 +1,47 @@
+// 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/PositionOptions.h"
+
+#include "bindings/v8/Dictionary.h"
+#include <limits.h>
+
+namespace WebCore {
+
+PositionOptions* PositionOptions::create(const Dictionary& options)

[Inactive, 2014/06/17 13:49:13]

Are we returning a raw pointer because of oilpan? IMHO, this looks unsafe / leak
prone.

[sof, 2014/06/17 14:05:05]

geolocation/ is using Oilpan by default.

[kihong, 2014/06/17 14:46:18]

As sof said geolocation is using Oilpan already, but it's not a reason why I am
using raw pointer.

Basically legacy geolocation API implementation have used so many raw pointers.
And PositionOptions raw pointers are used by some other functions also.
I agree with your opinion that it's unsafe, but I don't think it is in this
patch's scope.
That's why I'm using raw pointer.

And I stacked a bug for that(http://crbug.com/385638) and I will change them
soon.

[Inactive, 2014/06/18 12:22:44]

If this is how oilpan code looks when done porting, I have some concerns.
Passing around raw pointers like this looks unsafe and leak-prone. I thought
oilpan was going to pass around "handles".

+{
+    return new PositionOptions(options);
+}
+
+PositionOptions::PositionOptions(const Dictionary& options)
+    : m_highAccuracy(false)
+    , m_maximumAge(0)
+    , m_timeout(std::numeric_limits<unsigned>::max())
+{
+    if (options.hasProperty("enableHighAccuracy"))
+        options.get("enableHighAccuracy", m_highAccuracy);
+    if (options.hasProperty("maximumAge")) {
+        double maximumAge;

[Michael van Ouwerkerk, 2014/06/17 11:13:56]

Why a double? m_maximumAge is an int. I'm not sure I understand this bit of V8
binding correctly.

[kihong, 2014/06/17 13:13:10]

This value is a "[Clamp] unsigned long" therefore I suppose to be input larger
than unsigned. That's why I use double for
this.(http://dev.w3.org/geo/api/spec-source.html#position_options_interface)

+        options.get("maximumAge", maximumAge);
+        if (maximumAge < 0)
+            m_maximumAge = 0;
+        else if (maximumAge > std::numeric_limits<unsigned>::max())
+            m_maximumAge = std::numeric_limits<unsigned>::max();
+        else
+            m_maximumAge = maximumAge;
+    }
+    if (options.hasProperty("timeout")) {
+        double timeout;
+        options.get("timeout", timeout);
+        if (timeout < 0)
+            m_timeout = 0;
+        else if (timeout > std::numeric_limits<unsigned>::max())
+            m_timeout = std::numeric_limits<unsigned>::max();
+        else
+            m_timeout = timeout;
+    }
+}
+
+} // namespace WebCore