Performance.onwebkitresourcetimingbufferfull should be a Function

Source/core/page/Performance.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 14 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/page/Performance.h"
 
+#include "bindings/v8/ScriptFunctionCall.h"
 #include "core/dom/Document.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/MemoryInfo.h"
 #include "core/page/PerformanceEntry.h"
 #include "core/page/PerformanceNavigation.h"
 #include "core/page/PerformanceResourceTiming.h"
 #include "core/page/PerformanceTiming.h"
 #include "core/page/PerformanceUserTiming.h"
 #include <wtf/CurrentTime.h>
 
 #include "core/page/Frame.h"
 
 namespace WebCore {
 
 static const size_t defaultResourceTimingBufferSize = 150;
 
 Performance::Performance(Frame* frame)
     : DOMWindowProperty(frame)
     , m_resourceTimingBufferSize(defaultResourceTimingBufferSize)
     , m_userTiming(0)
+    , m_onwebkitresourcetimingbufferfull(v8::Null())
 {
     ScriptWrappable::init(this);
 }
 
 Performance::~Performance()
 {
 }
 
-const AtomicString& Performance::interfaceName() const
-{
-    return eventNames().interfaceForPerformance;
-}
-
-ScriptExecutionContext* Performance::scriptExecutionContext() const
-{
-    if (!frame())
-        return 0;
-    return frame()->document();
-}
-
 PassRefPtr<MemoryInfo> Performance::memory() const
 {
     return MemoryInfo::create(m_frame);
 }
 
 PerformanceNavigation* Performance::navigation() const
 {
     if (!m_navigation)
         m_navigation = PerformanceNavigation::create(m_frame);
 
@@ skipping 60 matching lines @@
 
     std::sort(entries.begin(), entries.end(), PerformanceEntry::startTimeCompareLessThan);
     return entries;
 }
 
 void Performance::webkitClearResourceTimings()
 {
     m_resourceTimingBuffer.clear();
 }
 
-void Performance::webkitSetResourceTimingBufferSize(unsigned size)
+void Performance::callResourceTimingBufferFullCallback(ScriptState* scriptState)
+{
+    if (!scriptState || m_onwebkitresourcetimingbufferfull.isNull())
+        return;
+
+    v8::HandleScope handleScope;
+    ScriptCallback callback(scriptState, m_onwebkitresourcetimingbufferfull);
+    v8::Handle<v8::Context> context = scriptState->context();
+    if (context.IsEmpty())
+        return;
+
+    v8::Context::Scope scope(context);
+    callback.call();
+}
+
+void Performance::webkitSetResourceTimingBufferSize(ScriptState* scriptState, unsigned size)
 {
     m_resourceTimingBufferSize = size;
     if (isResourceTimingBufferFull())
-        dispatchEvent(Event::create(eventNames().webkitresourcetimingbufferfullEvent, false, false));
+        callResourceTimingBufferFullCallback(scriptState);
+}
+
+void Performance::setOnwebkitresourcetimingbufferfull(const ScriptValue& callback)
+{
+    if (callback.isNull() || callback.isUndefined()) {
+        m_onwebkitresourcetimingbufferfull = ScriptValue(v8::Null());
+        return;
+    }
+
+    if (!callback.isFunction())

[arv (Not doing code reviews), 2013/07/09 18:19:58]

This is a bit inconsistent.

WebIDL says throw a TypeError if it is not a Function (which of course will not
work because we need to support null at least).

EventListeners sets it to null if not a function so maybe we should do that if
we don't want to throw.

+        return;
+
+    m_onwebkitresourcetimingbufferfull = callback;
 }
 
 void Performance::addResourceTiming(const String& initiatorName, Document* initiatorDocument, const ResourceRequest& request, const ResourceResponse& response, double initiationTime, double finishTime)
 {
     if (isResourceTimingBufferFull())
         return;
 
     RefPtr<PerformanceEntry> entry = PerformanceResourceTiming::create(initiatorName, request, response, initiationTime, finishTime, initiatorDocument);
 
     m_resourceTimingBuffer.append(entry);
 
     if (isResourceTimingBufferFull())
-        dispatchEvent(Event::create(eventNames().webkitresourcetimingbufferfullEvent, false, false));
+        callResourceTimingBufferFullCallback(mainWorldScriptState(frame()));
 }
 
 bool Performance::isResourceTimingBufferFull()
 {
     return m_resourceTimingBuffer.size() >= m_resourceTimingBufferSize;
 }
 
-EventTargetData* Performance::eventTargetData()
-{
-    return &m_eventTargetData;
-}
-
-EventTargetData* Performance::ensureEventTargetData()
-{
-    return &m_eventTargetData;
-}
-
 void Performance::mark(const String& markName, ExceptionCode& ec)
 {
     ec = 0;
     if (!m_userTiming)
         m_userTiming = UserTiming::create(this);
     m_userTiming->mark(markName, ec);
 }
 
 void Performance::clearMarks(const String& markName)
 {
@@ skipping 16 matching lines @@
         m_userTiming = UserTiming::create(this);
     m_userTiming->clearMeasures(measureName);
 }
 
 double Performance::now() const
 {
     return 1000.0 * m_frame->document()->loader()->timing()->monotonicTimeToZeroBasedDocumentTime(monotonicallyIncreasingTime());
 }
 
 } // namespace WebCore