First version of PerformanceObserver

Source/core/timing/PerformanceObserver.cpp

+// Copyright 2015 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 "core/timing/PerformanceObserver.h"
+
+#include "bindings/core/v8/ExceptionState.h"
+#include "core/dom/ExceptionCode.h"
+#include "core/inspector/InspectorInstrumentation.h"
+#include "core/timing/PerformanceBase.h"
+#include "core/timing/PerformanceEntry.h"
+#include "core/timing/PerformanceObserverCallback.h"
+#include "core/timing/PerformanceObserverEntryList.h"
+#include "core/timing/PerformanceObserverInit.h"
+#include "platform/Timer.h"
+#include "wtf/MainThread.h"
+#include <algorithm>
+
+namespace blink {
+
+class BLINK_EXPORT PerformanceObserverTimerCoordinator {
+public:
+    PerformanceObserverTimerCoordinator();
+    ~PerformanceObserverTimerCoordinator() {}
+
+    void fired(Timer<PerformanceObserverTimerCoordinator>*);
+    PerformanceObserverSet& activePerformanceObservers() { return *m_activeObservers; }
+    PerformanceObserverSet& suspendedPerformanceObservers() { return *m_suspendedObservers; }
+private:
+    Persistent<PerformanceObserverSet> m_activeObservers;
+    Persistent<PerformanceObserverSet> m_suspendedObservers;
+};
+
+PerformanceObserverTimerCoordinator::PerformanceObserverTimerCoordinator()
+    : m_activeObservers(new PerformanceObserverSet())
+    , m_suspendedObservers(new PerformanceObserverSet())
+{
+}
+
+void PerformanceObserverTimerCoordinator::fired(Timer<PerformanceObserverTimerCoordinator>*)
+{
+    ASSERT(isMainThread());
+    PerformanceObserverVector observers;
+    copyToVector(activePerformanceObservers(), observers);
+    activePerformanceObservers().clear();
+    for (size_t i = 0; i < observers.size(); ++i) {
+        if (observers[i]->shouldBeSuspended())
+            suspendedPerformanceObservers().add(observers[i]);
+        else
+            observers[i]->deliver();
+    }
+}
+
+static PerformanceObserverTimerCoordinator& timerCoordinator()
+{

[esprehn, 2015/07/24 08:23:12]

No static, PerformanceBase should own this. Each window.performance should have
it's own timer.

[MikeB, 2015/07/24 19:30:38]

Done.

+    DEFINE_STATIC_LOCAL(PerformanceObserverTimerCoordinator*, coordinator, (new PerformanceObserverTimerCoordinator));
+    return *coordinator;
+}
+
+static Timer<PerformanceObserverTimerCoordinator>& deliverObservationsTimer()
+{
+    DEFINE_STATIC_LOCAL(Timer<PerformanceObserverTimerCoordinator>*, timer, (new Timer<PerformanceObserverTimerCoordinator>(&timerCoordinator(), &PerformanceObserverTimerCoordinator::fired)));

[esprehn, 2015/07/24 08:23:12]

static Timer is usually bad, I think you want PerformanceBase to own this.

[MikeB, 2015/07/24 19:30:38]

Done.

+    return *timer;
+}
+
+PerformanceObserver* PerformanceObserver::create(PerformanceBase* performance, PerformanceObserverCallback* callback)
+{
+    ASSERT(isMainThread());
+    return new PerformanceObserver(performance, callback);
+}
+
+PerformanceObserver::PerformanceObserver(PerformanceBase* performance, PerformanceObserverCallback* callback)
+    : m_callback(callback)
+    , m_performance(performance)
+    , m_filterOptions(PerformanceEntry::Invalid)
+    , m_isRegistered(false)
+{
+}
+
+PerformanceObserver::~PerformanceObserver()
+{
+    if (!m_performanceEntries.isEmpty())
+        InspectorInstrumentation::didClearAllPerformanceObservations(m_callback->executionContext(), this);
+}
+
+void PerformanceObserver::observe(const PerformanceObserverInit& observerInit, ExceptionState& exceptionState)
+{
+    if (!m_performance) {
+        exceptionState.throwTypeError("Window may be destroyed? Performance target is invalid.");
+        return;
+    }
+
+    PerformanceEntryType_t entryType = PerformanceEntry::Invalid;
+    if (observerInit.hasEntryType() && observerInit.entryType().size()) {
+        const Vector<String>& sequence = observerInit.entryType();
+        for (unsigned i = 0; i < sequence.size(); ++i)
+            entryType |= PerformanceEntry::toEntryTypeEnum(sequence[i]);
+    }
+    if (entryType == PerformanceEntry::Invalid) {
+        exceptionState.throwTypeError("A Performance Observer MUST have a non-empty entryType attribute.");
+        return;
+    }
+    if (m_isRegistered)
+        m_performance->unregisterPerformanceObserver(this);
+    m_filterOptions = entryType;
+    m_performance->registerPerformanceObserver(this);
+    m_isRegistered = true;
+}
+
+void PerformanceObserver::disconnect()
+{
+    m_performanceEntries.clear();
+    InspectorInstrumentation::didClearAllPerformanceObservations(m_callback->executionContext(), this);
+    if (m_performance)
+        m_performance->unregisterPerformanceObserver(this);
+    m_isRegistered = false;
+}
+
+static void activateObserver(PerformanceObserver* observer)
+{
+    if (timerCoordinator().activePerformanceObservers().isEmpty())
+        deliverObservationsTimer().startOneShot(0, FROM_HERE);
+
+    timerCoordinator().activePerformanceObservers().add(observer);
+}
+
+void PerformanceObserver::enqueuePerformanceEntry(PerformanceEntry* entry)
+{
+    ASSERT(isMainThread());
+    m_performanceEntries.append(entry);
+    activateObserver(this);
+    InspectorInstrumentation::didEnqueuePerformanceObserverEntries(m_callback->executionContext(), this);
+}
+
+bool PerformanceObserver::shouldBeSuspended() const
+{
+    return m_callback->executionContext() && m_callback->executionContext()->activeDOMObjectsAreSuspended();
+}
+
+void PerformanceObserver::deliver()
+{
+    ASSERT(!shouldBeSuspended());
+
+    if (m_performanceEntries.isEmpty())
+        return;
+
+    PerformanceEntryVector performanceEntries;
+    performanceEntries.swap(m_performanceEntries);
+    Member<PerformanceObserverEntryList> entryList(new PerformanceObserverEntryList(performanceEntries));
+
+    InspectorInstrumentation::willDeliverPerformanceObservations(m_callback->executionContext(), this);
+    m_callback->handleEvent(entryList, this);
+    InspectorInstrumentation::didDeliverPerformanceObservations(m_callback->executionContext());
+}
+
+void PerformanceObserver::resumeSuspendedObservers()
+{
+    ASSERT(isMainThread());
+    if (timerCoordinator().suspendedPerformanceObservers().isEmpty())
+        return;
+
+    PerformanceObserverVector suspended;
+    copyToVector(timerCoordinator().suspendedPerformanceObservers(), suspended);
+    for (size_t i = 0; i < suspended.size(); ++i) {
+        if (!suspended[i]->shouldBeSuspended()) {
+            timerCoordinator().suspendedPerformanceObservers().remove(suspended[i]);
+            activateObserver(suspended[i]);
+        }
+    }
+}
+
+
+DEFINE_TRACE(PerformanceObserver)
+{
+    visitor->trace(m_callback);
+    visitor->trace(m_performance);
+    visitor->trace(m_performanceEntries);
+}
+
+} // namespace blink