Motown: Move responsibility for binding to MediaFactoryService::Product

services/media/factory_service/media_source_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/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "services/media/factory_service/media_source_impl.h"
 #include "services/media/framework/util/callback_joiner.h"
 #include "services/media/framework/util/conversion_pipeline_builder.h"
@@ skipping 13 matching lines @@
     MediaFactoryService* owner) {
   return std::shared_ptr<MediaSourceImpl>(new MediaSourceImpl(
       reader.Pass(), allowed_media_types, request.Pass(), owner));
 }
 
 MediaSourceImpl::MediaSourceImpl(
     InterfaceHandle<SeekingReader> reader,
     const Array<MediaTypeSetPtr>& allowed_media_types,
     InterfaceRequest<MediaSource> request,
     MediaFactoryService* owner)
-    : MediaFactoryService::Product(owner),
-      binding_(this, request.Pass()),
+    : MediaFactoryService::Product<MediaSource>(this, request.Pass(), owner),
       allowed_media_types_(allowed_media_types.Clone()) {
   DCHECK(reader);
 
   task_runner_ = base::MessageLoop::current()->task_runner();
   DCHECK(task_runner_);
 
   status_publisher_.SetCallbackRunner(
       [this](const GetStatusCallback& callback, uint64_t version) {
         MediaSourceStatusPtr status = MediaSourceStatus::New();
         status->state = state_;
         status->metadata =
             demux_ ? MediaMetadata::From(demux_->metadata()) : nullptr;
         callback.Run(version, status.Pass());
       });
 
-  // Go away when the client is no longer connected.
-  binding_.set_connection_error_handler([this]() { ReleaseFromOwner(); });
-
   std::shared_ptr<Reader> reader_ptr = MojoReader::Create(reader.Pass());
   if (!reader_ptr) {
     NOTREACHED() << "couldn't create reader";
     state_ = MediaState::FAULT;
     return;
   }
 
   demux_ = Demux::Create(reader_ptr);
   if (!demux_) {
     NOTREACHED() << "couldn't create demux";
@@ skipping 38 matching lines @@
       descriptor->media_type = streams_[i]->media_type();
       descriptor->original_media_type = streams_[i]->original_media_type();
       result[i] = descriptor.Pass();
     }
     callback.Run(result.Pass());
   });
 }
 
 void MediaSourceImpl::GetProducer(uint32_t stream_index,
                                   InterfaceRequest<MediaProducer> producer) {
-  DCHECK(init_complete_.occurred());
+  RCHECK(init_complete_.occurred());
 
   if (stream_index >= streams_.size()) {
     return;
   }
 
   streams_[stream_index]->GetProducer(producer.Pass());
 }
 
 void MediaSourceImpl::GetPullModeProducer(
     uint32_t stream_index,
     InterfaceRequest<MediaPullModeProducer> producer) {
-  DCHECK(init_complete_.occurred());
+  RCHECK(init_complete_.occurred());
 
   if (stream_index >= streams_.size()) {
     return;
   }
 
   streams_[stream_index]->GetPullModeProducer(producer.Pass());
 }
 
 void MediaSourceImpl::GetStatus(uint64_t version_last_seen,
                                 const GetStatusCallback& callback) {
   status_publisher_.Get(version_last_seen, callback);
 }
 
 void MediaSourceImpl::Prepare(const PrepareCallback& callback) {
-  DCHECK(init_complete_.occurred());
+  RCHECK(init_complete_.occurred());
 
   for (std::unique_ptr<Stream>& stream : streams_) {
     stream->EnsureSink();
   }
   graph_.Prepare();
   state_ = MediaState::PAUSED;
   callback.Run();
   status_publisher_.SendUpdates();
 }
 
 void MediaSourceImpl::Prime(const PrimeCallback& callback) {
-  DCHECK(init_complete_.occurred());
+  RCHECK(init_complete_.occurred());
 
   std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
 
   for (std::unique_ptr<Stream>& stream : streams_) {
     stream->PrimeConnection(callback_joiner->NewCallback());
   }
 
   callback_joiner->WhenJoined(callback);
 }
 
 void MediaSourceImpl::Flush(const FlushCallback& callback) {
-  DCHECK(init_complete_.occurred());
+  RCHECK(init_complete_.occurred());
 
   graph_.FlushAllOutputs(demux_part_);
 
   std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
 
   for (std::unique_ptr<Stream>& stream : streams_) {
     stream->FlushConnection(callback_joiner->NewCallback());
   }
 
   callback_joiner->WhenJoined(callback);
 }
 
 void MediaSourceImpl::Seek(int64_t position, const SeekCallback& callback) {
-  DCHECK(init_complete_.occurred());
+  RCHECK(init_complete_.occurred());
 
   demux_->Seek(position, [this, callback]() {
     task_runner_->PostTask(FROM_HERE, base::Bind(&RunSeekCallback, callback));
   });
 }
 
 // static
 void MediaSourceImpl::RunSeekCallback(const SeekCallback& callback) {
   callback.Run();
 }
@@ skipping 83 matching lines @@
     const MojoProducer::FlushConnectionCallback callback) {
   if (producer_ != nullptr) {
     producer_->FlushConnection(callback);
   } else {
     callback.Run();
   }
 }
 
 }  // namespace media
 }  // namespace mojo