Implement DocumentTimeline constructor

third_party/WebKit/Source/core/animation/DocumentTimeline.cpp

 /*
  * Copyright (C) 2013 Google 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * 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 "core/animation/DocumentTimeline.h"
 
 #include <algorithm>
 #include "core/animation/AnimationClock.h"
+#include "core/animation/DocumentTimelineOptions.h"
 #include "core/animation/ElementAnimations.h"
 #include "core/dom/Document.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/Page.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/animation/CompositorAnimationTimeline.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 
 namespace blink {
 
 namespace {
 
 bool CompareAnimations(const Member<Animation>& left,
                        const Member<Animation>& right) {
   return Animation::HasLowerPriority(left.Get(), right.Get());
 }
 }  // namespace
 
 // This value represents 1 frame at 30Hz plus a little bit of wiggle room.
 // TODO: Plumb a nominal framerate through and derive this value from that.
 const double DocumentTimeline::kMinimumDelay = 0.04;
 
 DocumentTimeline* DocumentTimeline::Create(Document* document,
+                                           double origin_time_in_milliseconds,
                                            PlatformTiming* timing) {
-  return new DocumentTimeline(document, timing);
+  return new DocumentTimeline(document, origin_time_in_milliseconds, timing);
 }
 
-DocumentTimeline::DocumentTimeline(Document* document, PlatformTiming* timing)
+DocumentTimeline* DocumentTimeline::Create(
+    ExecutionContext* execution_context,
+    const DocumentTimelineOptions& options) {
+  Document* document = ToDocument(execution_context);
+  return new DocumentTimeline(document, options.originTime(), nullptr);
+}
+
+DocumentTimeline::DocumentTimeline(Document* document,
+                                   double origin_time_in_milliseconds,
+                                   PlatformTiming* timing)
     : document_(document),
-      // 0 is used by unit tests which cannot initialize from the loader
-      zero_time_(0),
+      origin_time_(origin_time_in_milliseconds / 1000),
+      zero_time_(origin_time_),
       zero_time_initialized_(false),
       outdated_animation_count_(0),
       playback_rate_(1),
       last_current_time_internal_(0) {
   if (!timing)
     timing_ = new DocumentTimelineTiming(this);
   else
     timing_ = timing;
 
   if (Platform::Current()->IsThreadedAnimationEnabled())
@@ skipping 95 matching lines @@
     timeline_->document_->View()->ScheduleAnimation();
 }
 
 DEFINE_TRACE(DocumentTimeline::DocumentTimelineTiming) {
   visitor->Trace(timeline_);
   DocumentTimeline::PlatformTiming::Trace(visitor);
 }
 
 double DocumentTimeline::ZeroTime() {
   if (!zero_time_initialized_ && document_ && document_->Loader()) {
-    zero_time_ = document_->Loader()->GetTiming().ReferenceMonotonicTime();
+    zero_time_ = document_->Loader()->GetTiming().ReferenceMonotonicTime() +
+                 origin_time_;
     zero_time_initialized_ = true;
   }
   return zero_time_;
 }
 
 void DocumentTimeline::ResetForTesting() {
-  zero_time_ = 0;
+  zero_time_ = origin_time_;
   zero_time_initialized_ = true;
   playback_rate_ = 1;
   last_current_time_internal_ = 0;
 }
 
 double DocumentTimeline::currentTime(bool& is_null) {
   return CurrentTimeInternal(is_null) * 1000;
 }
 
 double DocumentTimeline::CurrentTimeInternal(bool& is_null) {
@@ skipping 93 matching lines @@
 
 DEFINE_TRACE(DocumentTimeline) {
   visitor->Trace(document_);
   visitor->Trace(timing_);
   visitor->Trace(animations_needing_update_);
   visitor->Trace(animations_);
   AnimationTimeline::Trace(visitor);
 }
 
 }  // namespace blink