MediaResource refactoring to support multiple streams

media/remoting/fake_remoting_media_resource.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 "media/remoting/fake_remoting_demuxer_stream_provider.h"
+#include "media/remoting/fake_remoting_media_resource.h"
 
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Invoke;
@@ skipping 49 matching lines @@
 
 bool DummyDemuxerStream::SupportsConfigChanges() {
   return false;
 }
 
 VideoRotation DummyDemuxerStream::video_rotation() {
   return VIDEO_ROTATION_0;
 }
 
 bool DummyDemuxerStream::enabled() const {
-  return false;
+  return true;
 }
 
 void DummyDemuxerStream::CreateFakeFrame(size_t size,
                                          bool key_frame,
                                          int pts_ms) {
   std::vector<uint8_t> buffer(size);
   // Assign each byte in the buffer its index mod 256.
   for (size_t i = 0; i < size; ++i) {
     buffer[i] = static_cast<uint8_t>(i & 0xFF);
   }
   base::TimeDelta pts = base::TimeDelta::FromMilliseconds(pts_ms);
 
   // To DecoderBuffer
   scoped_refptr<::media::DecoderBuffer> input_buffer =
       ::media::DecoderBuffer::CopyFrom(buffer.data(), size);
   input_buffer->set_timestamp(pts);
   input_buffer->set_is_key_frame(key_frame);
 
   // Sends frame out if there is pending read callback. Otherwise, stores it
   // in the buffer queue.
   if (pending_read_cb_.is_null()) {
     buffer_queue_.push_back(input_buffer);
   } else {
     base::ResetAndReturn(&pending_read_cb_).Run(kOk, input_buffer);
   }
 }
 
-FakeRemotingDemuxerStreamProvider::FakeRemotingDemuxerStreamProvider()
+FakeRemotingMediaResource::FakeRemotingMediaResource()
     : demuxer_stream_(new DummyDemuxerStream(true)) {}
 
-FakeRemotingDemuxerStreamProvider::~FakeRemotingDemuxerStreamProvider() {}
+FakeRemotingMediaResource::~FakeRemotingMediaResource() {}
 
-DemuxerStream* FakeRemotingDemuxerStreamProvider::GetStream(
-    DemuxerStream::Type type) {
-  if (type == DemuxerStream::AUDIO)
-    return reinterpret_cast<DemuxerStream*>(demuxer_stream_.get());
-  return nullptr;
+std::vector<DemuxerStream*> FakeRemotingMediaResource::GetStreams() {
+  std::vector<DemuxerStream*> streams;
+  streams.push_back(demuxer_stream_.get());
+  return streams;
 }
 
 }  // namespace media