Motown: Move responsibility for binding to MediaFactoryService::Product

services/media/factory_service/media_demux_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_demux_impl.h"
 #include "services/media/framework/parts/reader_cache.h"
 #include "services/media/framework/util/callback_joiner.h"
 #include "services/media/framework_mojo/mojo_reader.h"
 #include "services/media/framework_mojo/mojo_type_conversions.h"
 
 namespace mojo {
 namespace media {
 
 // static
 std::shared_ptr<MediaDemuxImpl> MediaDemuxImpl::Create(
     InterfaceHandle<SeekingReader> reader,
     InterfaceRequest<MediaDemux> request,
     MediaFactoryService* owner) {
   return std::shared_ptr<MediaDemuxImpl>(
       new MediaDemuxImpl(reader.Pass(), request.Pass(), owner));
 }
 
 MediaDemuxImpl::MediaDemuxImpl(InterfaceHandle<SeekingReader> reader,
                                InterfaceRequest<MediaDemux> request,
                                MediaFactoryService* owner)
-    : MediaFactoryService::Product(owner), binding_(this, request.Pass()) {
+    : MediaFactoryService::Product<MediaDemux>(this, request.Pass(), owner) {
   DCHECK(reader);
 
   task_runner_ = base::MessageLoop::current()->task_runner();
   DCHECK(task_runner_);
 
   metadata_publisher_.SetCallbackRunner(
       [this](const GetMetadataCallback& callback, uint64_t version) {
         callback.Run(version, demux_ ? MediaMetadata::From(demux_->metadata())
                                      : nullptr);
       });
 
-  // 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";
     return;
   }
 
   std::shared_ptr<ReaderCache> reader_cache_ptr =
       ReaderCache::Create(reader_ptr);
   if (!reader_cache_ptr) {
     NOTREACHED() << "couldn't create reader cache";
@@ skipping 40 matching lines @@
           MediaSourceStreamDescriptor::New();
       result[i] = streams_[i]->media_type();
     }
 
     callback.Run(result.Pass());
   });
 }
 
 void MediaDemuxImpl::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 MediaDemuxImpl::GetMetadata(uint64_t version_last_seen,
                                  const GetMetadataCallback& callback) {
   metadata_publisher_.Get(version_last_seen, callback);
 }
 
 void MediaDemuxImpl::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 MediaDemuxImpl::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 MediaDemuxImpl::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 MediaDemuxImpl::RunSeekCallback(const SeekCallback& callback) {
   callback.Run();
 }
@@ skipping 28 matching lines @@
 }
 
 void MediaDemuxImpl::Stream::FlushConnection(
     const MojoProducer::FlushConnectionCallback callback) {
   DCHECK(producer_);
   producer_->FlushConnection(callback);
 }
 
 }  // namespace media
 }  // namespace mojo