Motown: Implement MediaTimelineController and use it.

services/media/factory_service/media_timeline_controller_impl.h

+// 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.
+
+#ifndef MOJO_SERVICES_MEDIA_FACTORY_TIMELINE_CONTROLLER_IMPL_H_
+#define MOJO_SERVICES_MEDIA_FACTORY_TIMELINE_CONTROLLER_IMPL_H_
+
+#include <memory>
+#include <vector>
+
+#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/services/media/common/cpp/local_time.h"
+#include "mojo/services/media/common/cpp/timeline.h"
+#include "mojo/services/media/common/cpp/timeline_function.h"
+#include "mojo/services/media/core/interfaces/timeline_controller.mojom.h"
+#include "services/media/common/mojo_publisher.h"
+#include "services/media/factory_service/factory_service.h"
+#include "services/media/framework/util/callback_joiner.h"
+
+namespace mojo {
+namespace media {
+
+// Mojo agent that controls timing in a graph.
+class MediaTimelineControllerImpl
+    : public MediaFactoryService::Product<MediaTimelineController>,
+      public MediaTimelineController,
+      public MediaTimelineControlSite,
+      public TimelineConsumer {
+ public:
+  static std::shared_ptr<MediaTimelineControllerImpl> Create(
+      InterfaceRequest<MediaTimelineController> request,
+      MediaFactoryService* owner);
+
+  ~MediaTimelineControllerImpl() override;
+
+  // MediaTimelineController implementation.
+  void AddControlSite(
+      InterfaceHandle<MediaTimelineControlSite> control_site) override;
+
+  void GetControlSite(
+      InterfaceRequest<MediaTimelineControlSite> control_site) override;
+
+  // MediaTimelineControlSite implementation.
+  void GetStatus(uint64_t version_last_seen,
+                 const GetStatusCallback& callback) override;
+
+  void GetTimelineConsumer(
+      InterfaceRequest<TimelineConsumer> timeline_consumer) override;
+
+  // TimelineConsumer implementation.
+  void SetTimelineTransform(
+      int64_t subject_time,
+      uint32_t reference_delta,
+      uint32_t subject_delta,
+      int64_t effective_reference_time,
+      int64_t effective_subject_time,
+      const SetTimelineTransformCallback& callback) override;
+
+ private:
+  static constexpr int64_t kDefaultLeadTime = Timeline::ns_from_ms(30);
+
+  // Relationship to subordinate control site.
+  struct SiteState {
+    SiteState(MediaTimelineControllerImpl* parent,
+              MediaTimelineControlSitePtr site);
+
+    SiteState(SiteState&& other);
+
+    ~SiteState();
+
+    void HandleStatusUpdates(
+        uint64_t version = MediaTimelineControlSite::kInitialStatus,
+        MediaTimelineControlSiteStatusPtr status = nullptr);
+
+    MediaTimelineControllerImpl* parent_;
+    MediaTimelineControlSitePtr site_;
+    TimelineConsumerPtr consumer_;
+    bool end_of_stream_ = false;
+  };
+
+  class TimelineTransition
+      : public std::enable_shared_from_this<TimelineTransition> {
+   public:
+    TimelineTransition(int64_t reference_time,
+                       int64_t subject_time,
+                       uint32_t reference_delta,
+                       uint32_t subject_delta,
+                       const SetTimelineTransformCallback& callback);
+
+    ~TimelineTransition();
+
+    // Calls returns a new callback for a child (site) transition. THIS METHOD
+    // WILL ONLY WORK IF THERE IS ALREADY A SHARED POINTER TO THIS OBJECT.
+    std::function<void(bool)> NewCallback() {
+      callback_joiner_.Spawn();
+
+      std::shared_ptr<TimelineTransition> this_ptr = shared_from_this();
+      DCHECK(!this_ptr.unique());
+
+      return [this_ptr](bool completed) {
+        DCHECK(this_ptr);
+        if (!completed && !this_ptr->cancelled_) {
+          LOG(WARNING) << "A site transition was cancelled unexpectedly.";
+        }
+        this_ptr->callback_joiner_.Complete();
+      };
+    }
+
+    // Cancels this transition.
+    void Cancel() {
+      DCHECK(!cancelled_);
+      cancelled_ = true;
+      DCHECK(callback_.is_null());
+      callback_.Run(false);
+      callback_.reset();
+      completed_callback_.reset();
+    }
+
+    // Specifies a callback to be called if and when the transition is complete.
+    // The callback will never be called if the transition is cancelled.
+    void WhenCompleted(const mojo::Callback<void()>& completed_callback) {
+      DCHECK(completed_callback_.is_null());
+      if (callback_.is_null() && !cancelled_) {
+        completed_callback.Run();
+      } else {
+        completed_callback_ = completed_callback;
+      }
+    }
+
+    // Returns the TimelineFunction that will result from this transition.
+    const TimelineFunction& new_timeline_function() const {
+      return new_timeline_function_;
+    }
+
+   private:
+    TimelineFunction new_timeline_function_;
+    SetTimelineTransformCallback callback_;
+    CallbackJoiner callback_joiner_;
+    bool cancelled_ = false;
+    Callback<void()> completed_callback_;
+  };
+
+  MediaTimelineControllerImpl(InterfaceRequest<MediaTimelineController> request,
+                              MediaFactoryService* owner);
+
+  // Takes action when a site changes its end-of-stream value.
+  void HandleSiteEndOfStreamChange();
+
+  Binding<MediaTimelineControlSite> control_site_binding_;
+  Binding<TimelineConsumer> consumer_binding_;
+  MojoPublisher<GetStatusCallback> status_publisher_;
+  std::vector<SiteState> site_states_;
+  TimelineFunction current_timeline_function_;
+  bool end_of_stream_;
+  std::weak_ptr<TimelineTransition> pending_transition_;
+};
+
+}  // namespace media
+}  // namespace mojo
+
+#endif  // MOJO_SERVICES_MEDIA_FACTORY_TIMELINE_CONTROLLER_IMPL_H_