MediaResource refactoring to support multiple streams

media/remoting/fake_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_demuxer_stream_provider.h"
+#include "media/remoting/fake_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 50 matching lines @@
 
 bool FakeDemuxerStream::SupportsConfigChanges() {
   return false;
 }
 
 VideoRotation FakeDemuxerStream::video_rotation() {
   return VIDEO_ROTATION_0;
 }
 
 bool FakeDemuxerStream::enabled() const {
-  return false;
+  return true;
 }
 
 void FakeDemuxerStream::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<DecoderBuffer> input_buffer =
       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);
   }
 }
 
-FakeDemuxerStreamProvider::FakeDemuxerStreamProvider()
+FakeMediaResource::FakeMediaResource()
     : demuxer_stream_(new FakeDemuxerStream(true)) {}
 
-FakeDemuxerStreamProvider::~FakeDemuxerStreamProvider() {}
+FakeMediaResource::~FakeMediaResource() {}
 
-DemuxerStream* FakeDemuxerStreamProvider::GetStream(DemuxerStream::Type type) {
-  if (type == DemuxerStream::AUDIO)
-    return reinterpret_cast<DemuxerStream*>(demuxer_stream_.get());
-  return nullptr;
+std::vector<DemuxerStream*> FakeMediaResource::GetStreams() {
+  std::vector<DemuxerStream*> streams;
+  streams.push_back(demuxer_stream_.get());
+  return streams;
+}
+
+void FakeMediaResource::SetStreamStatusChangeCB(
+    const StreamStatusChangeCB& cb) {
+  NOTIMPLEMENTED();
 }
 
 }  // namespace remoting
 }  // namespace media