Adds NetInfo v3 Web API to Blink.

Source/modules/netinfo/NetworkInformation.cpp

Index: Source/modules/netinfo/NetworkInformation.cpp
diff --git a/Source/modules/netinfo/NetworkInformation.cpp b/Source/modules/netinfo/NetworkInformation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..02d7b1ef2cf0df21d24e079c051e972ba01d58eb
--- /dev/null
+++ b/Source/modules/netinfo/NetworkInformation.cpp
@@ -0,0 +1,149 @@
+// 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/netinfo/NetworkInformation.h"
+
+#include "core/dom/ExecutionContext.h"
+#include "core/page/NetworkStateNotifier.h"
+#include "modules/EventTargetModules.h"
+#include "wtf/text/WTFString.h"
+
+namespace {
+
+String connectionTypeToString(blink::WebConnectionType type)
+{
+    DEFINE_STATIC_LOCAL(const String, cellular, ("cellular"));

[adamk, 2014/05/29 16:57:56]

These aren't going to play nice with the multi-threading. See
https://code.google.com/p/chromium/issues/detail?id=367982

[jkarlin, 2014/05/29 17:12:56]

This is only called by NetworkInformation::type() which is on the context
thread.  Shouldn't have multiple threads accessing it.  I can either add an
assert that I'm on the context thread or go back to using a global char*.  Which
do you prefer?  I'm more in favor of the char* but I can go either way.

[adamk, 2014/05/29 18:07:58]

Each instance of NetworkInformation is on its own thread, but there's only a
single version of connectionTypeToString (and thus of each DEFINE_STATIC_LOCAL)
that all threads will call into. The unsafety is that the initialization of
these static locals is not thread-safe, so if two threads happen to call type()
there's a race.
Please go back to the const char[], I think that's the only safe thing to do.
You could imagine caching the strings per instance, but I can't imagine that
this is performance sensitive code.

+    DEFINE_STATIC_LOCAL(const String, bluetooth, ("bluetooth"));
+    DEFINE_STATIC_LOCAL(const String, ethernet, ("ethernet"));
+    DEFINE_STATIC_LOCAL(const String, wifi, ("wifi"));
+    DEFINE_STATIC_LOCAL(const String, other, ("other"));
+    DEFINE_STATIC_LOCAL(const String, none, ("none"));
+
+    switch (type) {
+    case blink::ConnectionTypeCellular:
+        return cellular;
+    case blink::ConnectionTypeBluetooth:
+        return bluetooth;
+    case blink::ConnectionTypeEthernet:
+        return ethernet;
+    case blink::ConnectionTypeWifi:
+        return wifi;
+    case blink::ConnectionTypeOther:
+        return other;
+    case blink::ConnectionTypeNone:
+        return none;
+    }
+    ASSERT_NOT_REACHED();
+    return none;
+}
+
+} // namespace
+
+namespace WebCore {
+
+PassRefPtrWillBeRawPtr<NetworkInformation> NetworkInformation::create(ExecutionContext* context)
+{
+    RefPtrWillBeRawPtr<NetworkInformation> connection(adoptRefWillBeRefCountedGarbageCollected(new NetworkInformation(context)));
+    connection->suspendIfNeeded();
+    return connection.release();
+}
+
+NetworkInformation::~NetworkInformation()
+{
+    ASSERT(!m_observing);
+}
+
+String NetworkInformation::type() const
+{
+    return connectionTypeToString(m_type);
+}
+
+void NetworkInformation::connectionTypeChange(blink::WebConnectionType type)
+{
+    ASSERT(executionContext()->isContextThread());
+
+    // This can happen if the observer removes and then adds itself again
+    // during notification.
+    if (m_type == type)
+        return;
+
+    m_type = type;
+    dispatchEvent(Event::create(EventTypeNames::typechange));
+}
+
+const AtomicString& NetworkInformation::interfaceName() const
+{
+    return EventTargetNames::NetworkInformation;
+}
+
+ExecutionContext* NetworkInformation::executionContext() const
+{
+    return ActiveDOMObject::executionContext();
+}
+
+bool NetworkInformation::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
+{
+    if (!EventTargetWithInlineData::addEventListener(eventType, listener, useCapture))
+        return false;
+    startObserving();
+    return true;
+}
+
+bool NetworkInformation::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
+{
+    if (!EventTargetWithInlineData::removeEventListener(eventType, listener, useCapture))
+        return false;
+    if (!hasEventListeners())
+        stopObserving();
+    return true;
+}
+
+void NetworkInformation::removeAllEventListeners()
+{
+    EventTargetWithInlineData::removeAllEventListeners();
+    ASSERT(!hasEventListeners());
+    stopObserving();
+}
+
+bool NetworkInformation::hasPendingActivity() const
+{
+    ASSERT(m_contextStopped || m_observing == hasEventListeners());
+
+    // Prevent collection of this object when there are active listeners.
+    return m_observing;
+}
+
+void NetworkInformation::stop()
+{
+    m_contextStopped = true;
+    stopObserving();
+}
+
+void NetworkInformation::startObserving()
+{
+    if (!m_observing && !m_contextStopped) {
+        networkStateNotifier().addObserver(this, executionContext());
+        m_observing = true;
+    }
+}
+
+void NetworkInformation::stopObserving()
+{
+    if (m_observing) {
+        networkStateNotifier().removeObserver(this, executionContext());
+        m_observing = false;
+    }
+}
+
+NetworkInformation::NetworkInformation(ExecutionContext* context)
+    : ActiveDOMObject(context)
+    , m_type(networkStateNotifier().connectionType())
+    , m_observing(false)
+    , m_contextStopped(false)
+{
+    ScriptWrappable::init(this);
+}
+
+} // namespace WebCore