Add the SharedWorker.workerStart property for high resolution timers.

Source/modules/performance/SharedWorkerPerformance.cpp

 /*
- * Copyright (c) 2013, Opera Software ASA. All rights reserved.
+ * Copyright (c) 2014, Opera Software ASA. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of Opera Software ASA nor the names of its
  *    contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT 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 "V8TextTrackCue.h"
+#include "modules/performance/SharedWorkerPerformance.h"
 
-#include "V8VTTCue.h"
-
-#include "bindings/v8/ExceptionMessages.h"
-#include "bindings/v8/ExceptionState.h"
-#include "core/frame/UseCounter.h"
+#include "core/dom/Document.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/loader/DocumentLoadTiming.h"
+#include "core/loader/DocumentLoader.h"
+#include "core/workers/SharedWorker.h"
 
 namespace WebCore {
 
-v8::Handle<v8::Value> toV8(TextTrackCue* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+SharedWorkerPerformance::SharedWorkerPerformance()
+    : m_timeOrigin(monotonicallyIncreasingTime())
 {
-    return toV8(toVTTCue(impl), creationContext, isolate);
 }
 
-// Custom constructor to make new TextTrackCue(...) return a VTTCue. This is legacy
-// compat, not per spec, and should be removed at the earliest opportunity.
-void V8TextTrackCue::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
+SharedWorkerPerformance::~SharedWorkerPerformance()
 {
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "TextTrackCue", info.Holder(), info.GetIsolate());
-    if (UNLIKELY(info.Length() < 3)) {
-        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(3, info.Length()));
-        exceptionState.throwIfNeeded();
-        return;
+}
+
+const char* SharedWorkerPerformance::supplementName()
+{
+    return "SharedWorkerPerformance";
+}
+
+SharedWorkerPerformance* SharedWorkerPerformance::from(SharedWorker* sharedWorker)
+{
+    SharedWorkerPerformance* supplement = static_cast<SharedWorkerPerformance*>(Supplement<SharedWorker>::from(sharedWorker, supplementName()));
+    if (!supplement) {
+        supplement = new SharedWorkerPerformance();
+        provideTo(sharedWorker, supplementName(), adoptPtr(supplement));
     }
-    V8TRYCATCH_VOID(double, startTime, static_cast<double>(info[0]->NumberValue()));
-    V8TRYCATCH_VOID(double, endTime, static_cast<double>(info[1]->NumberValue()));
-    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, text, info[2]);
+    return supplement;
+}
 
-    Document& document = *toDocument(getExecutionContext());
-    UseCounter::count(document, UseCounter::TextTrackCueConstructor);
+double SharedWorkerPerformance::workerStart(ExecutionContext *context, SharedWorker* sharedWorker)

[abarth-chromium, 2014/01/06 22:19:39]

ExecutionContext *context

->

ExecutionContext* context

[sof, 2014/01/06 22:47:20]

Thanks, done.

+{
+    return SharedWorkerPerformance::from(sharedWorker)->getWorkerStart(context, sharedWorker);
+}
 
-    RefPtr<VTTCue> impl = VTTCue::create(document, startTime, endTime, text);
-    v8::Handle<v8::Object> wrapper = wrap(impl.get(), info.Holder(), info.GetIsolate());
+double SharedWorkerPerformance::getWorkerStart(ExecutionContext *context, SharedWorker* sharedWorker) const
+{
+    ASSERT(context);
+    ASSERT(context->isDocument());
+    Document* document = toDocument(context);
+    if (!document->loader())
+        return 0;
 
-    v8SetReturnValue(info, wrapper);
+    double navigationStart = document->loader()->timing()->navigationStart();
+    return m_timeOrigin - navigationStart;
 }
 
 } // namespace WebCore
+