Motown: Define MediaRenderer and make it the way we identify renderers.

services/media/factory_service/media_timeline_controller_impl.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/logging.h"
 #include "mojo/services/media/common/cpp/timeline.h"
 #include "services/media/factory_service/media_timeline_controller_impl.h"
 #include "services/media/framework_mojo/mojo_type_conversions.h"
 
 namespace mojo {
@@ skipping 26 matching lines @@
         callback.Run(version, status.Pass());
       });
 }
 
 MediaTimelineControllerImpl::~MediaTimelineControllerImpl() {
   status_publisher_.SendUpdates();
 }
 
 void MediaTimelineControllerImpl::AddControlSite(
     InterfaceHandle<MediaTimelineControlSite> control_site) {
-  site_states_.emplace_back(
-      this, MediaTimelineControlSitePtr::Create(std::move(control_site)));
-  site_states_.back().HandleStatusUpdates();
+  site_states_.push_back(std::unique_ptr<SiteState>(new SiteState(
+      this, MediaTimelineControlSitePtr::Create(std::move(control_site)))));
+
+  site_states_.back()->HandleStatusUpdates();
 }
 
 void MediaTimelineControllerImpl::GetControlSite(
     InterfaceRequest<MediaTimelineControlSite> control_site) {
   if (control_site_binding_.is_bound()) {
     control_site_binding_.Close();
   }
 
   control_site_binding_.Bind(control_site.Pass());
 }
@@ skipping 103 matching lines @@
 
   // Recording the new pending transition.
   std::shared_ptr<TimelineTransition> transition =
       std::shared_ptr<TimelineTransition>(
           new TimelineTransition(new_reference_time, new_subject_time,
                                  reference_delta, subject_delta, callback));
 
   pending_transition_ = transition;
 
   // Initiate the transition for each site.
-  for (const SiteState& site_state : site_states_) {
-    site_state.consumer_->SetTimelineTransform(
+  for (const std::unique_ptr<SiteState>& site_state : site_states_) {
+    site_state->consumer_->SetTimelineTransform(
         subject_time, reference_delta, subject_delta, effective_reference_time,
         effective_subject_time, transition->NewCallback());
   }
 
   // If and when this transition is complete, adopt the new TimelineFunction
   // and tell any status subscribers.
   transition->WhenCompleted([this, transition]() {
     current_timeline_function_ = transition->new_timeline_function();
     status_publisher_.SendUpdates();
   });
 }
 
 void MediaTimelineControllerImpl::HandleSiteEndOfStreamChange() {
   bool end_of_stream = true;
-  for (const SiteState& site_state : site_states_) {
-    if (!site_state.end_of_stream_) {
+  for (const std::unique_ptr<SiteState>& site_state : site_states_) {
+    if (!site_state->end_of_stream_) {
       end_of_stream = false;
       break;
     }
   }
 
   if (end_of_stream_ != end_of_stream) {
     end_of_stream_ = end_of_stream;
     status_publisher_.SendUpdates();
   }
 }
 
 MediaTimelineControllerImpl::SiteState::SiteState(
     MediaTimelineControllerImpl* parent,
     MediaTimelineControlSitePtr site)
     : parent_(parent), site_(site.Pass()) {
   site_->GetTimelineConsumer(GetProxy(&consumer_));
 }
 
-MediaTimelineControllerImpl::SiteState::SiteState(SiteState&& other)
-    : parent_(other.parent_),
-      site_(other.site_.Pass()),
-      consumer_(other.consumer_.Pass()) {}
-
 MediaTimelineControllerImpl::SiteState::~SiteState() {}
 
 void MediaTimelineControllerImpl::SiteState::HandleStatusUpdates(
     uint64_t version,
     MediaTimelineControlSiteStatusPtr status) {
   if (status) {
     // Respond to any end-of-stream changes.
     if (end_of_stream_ != status->end_of_stream) {
       end_of_stream_ = status->end_of_stream;
       parent_->HandleSiteEndOfStreamChange();
@@ skipping 31 matching lines @@
       completed_callback_.Run();
       completed_callback_.reset();
     }
   });
 }
 
 MediaTimelineControllerImpl::TimelineTransition::~TimelineTransition() {}
 
 }  // namespace media
 }  // namespace mojo