Motown: Convert MediaSink to expose MediaTimelineControlSite

services/media/common/timeline_control_site.cc

 // Copyright 2016 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 "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/services/media/common/cpp/timeline.h"
 #include "services/media/common/timeline_control_site.h"
 
@@ skipping 18 matching lines @@
   ClearPendingTimelineFunctionUnsafe(false);
 
   status_publisher_.SetCallbackRunner(
       [this](const GetStatusCallback& callback, uint64_t version) {
         MediaTimelineControlSiteStatusPtr status;
         {
           base::AutoLock lock(lock_);
           status = MediaTimelineControlSiteStatus::New();
           status->timeline_transform =
               TimelineTransform::From(current_timeline_function_);
-          status->end_of_stream = false; // TODO(dalesat): Provide this.
+          status->end_of_stream = ReachedEndOfStreamUnsafe();
         }
         callback.Run(version, status.Pass());
       });
 }
 
 TimelineControlSite::~TimelineControlSite() {}
 
 void TimelineControlSite::Bind(
     InterfaceRequest<MediaTimelineControlSite> request) {
   if (control_site_binding_.is_bound()) {
@@ skipping 25 matching lines @@
 void TimelineControlSite::SnapshotCurrentFunction(int64_t reference_time,
                                                   TimelineFunction* out,
                                                   uint32_t* generation) {
   DCHECK(out);
   base::AutoLock lock(lock_);
   ApplyPendingChangesUnsafe(reference_time);
   *out = current_timeline_function_;
   if (generation) {
     *generation = generation_;
   }
+
+  if (ReachedEndOfStreamUnsafe() && !end_of_stream_published_) {
+    end_of_stream_published_ = true;
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&MojoPublisher<GetStatusCallback>::SendUpdates,
+                              base::Unretained(&status_publisher_)));
+  }
+}
+
+void TimelineControlSite::SetEndOfStreamPts(int64_t end_of_stream_pts) {
+  base::AutoLock lock(lock_);
+  if (end_of_stream_pts_ != end_of_stream_pts) {
+    end_of_stream_pts_ = end_of_stream_pts;
+    end_of_stream_published_ = false;
+  }
+}
+
+bool TimelineControlSite::ReachedEndOfStreamUnsafe() {
+  lock_.AssertAcquired();
+
+  return end_of_stream_pts_ != kUnspecifiedTime &&
+         current_timeline_function_(Timeline::local_now()) >=
+             end_of_stream_pts_;
 }
 
 void TimelineControlSite::GetStatus(uint64_t version_last_seen,
                                     const GetStatusCallback& callback) {
   status_publisher_.Get(version_last_seen, callback);
 }
 
 void TimelineControlSite::GetTimelineConsumer(
     InterfaceRequest<TimelineConsumer> timeline_consumer) {
   if (consumer_binding_.is_bound()) {
@@ skipping 13 matching lines @@
   base::AutoLock lock(lock_);
 
   // At most one of the effective times must be specified.
   RCHECK(effective_reference_time == kUnspecifiedTime ||
          effective_subject_time == kUnspecifiedTime);
   // effective_subject_time can only be used if we're progressing already.
   RCHECK(effective_subject_time == kUnspecifiedTime ||
          current_timeline_function_.subject_delta() != 0);
   RCHECK(reference_delta != 0);
 
+  if (subject_time != kUnspecifiedTime &&
+      end_of_stream_pts_ != kUnspecifiedTime) {
+    end_of_stream_pts_ = kUnspecifiedTime;
+    end_of_stream_published_ = false;
+  }
+
   if (effective_subject_time != kUnspecifiedTime) {
     // Infer effective_reference_time from effective_subject_time.
     effective_reference_time =
         current_timeline_function_.ApplyInverse(effective_subject_time);
 
     if (subject_time == kUnspecifiedTime) {
       // Infer subject_time from effective_subject_time.
       subject_time = effective_subject_time;
     }
   } else {
@@ skipping 56 matching lines @@
 }
 
 // static
 void TimelineControlSite::RunCallback(SetTimelineTransformCallback callback,
                                       bool completed) {
   callback.Run(completed);
 }
 
 }  // namespace media
 }  // namespace mojo