Enable PipelineIntegrationTests in mojo!

media/filters/pipeline_integration_test.cc

 // Copyright (c) 2012 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/filters/pipeline_integration_test_base.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
+#include "media/base/media.h"
 #include "media/base/media_keys.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_data_util.h"
 #include "media/cdm/aes_decryptor.h"
 #include "media/cdm/json_web_key.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/renderer_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
+#if defined(MOJO_RENDERER)
+#include "media/mojo/services/mojo_renderer_impl.h"
+#include "mojo/public/cpp/application/application_impl.h"
+#include "mojo/public/cpp/application/application_test_base.h"
+#include "mojo/public/cpp/application/connect.h"
+#endif
+
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::AtMost;
 using testing::SaveArg;
 
 namespace media {
 
 const char kSourceId[] = "SourceId";
 const char kCencInitDataType[] = "cenc";
@@ skipping 516 matching lines @@
   scoped_refptr<DecoderBuffer> file_data_;
   int current_position_;
   int initial_append_size_;
   std::string mimetype_;
   ChunkDemuxer* chunk_demuxer_;
   scoped_ptr<Demuxer> owned_chunk_demuxer_;
   Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
   base::TimeDelta last_timestamp_offset_;
 };
 
-class PipelineIntegrationTest
-    : public testing::Test,
-      public PipelineIntegrationTestBase {
+#if defined(MOJO_RENDERER)
+class PipelineIntegrationTestHost : public mojo::test::ApplicationTestBase,
+                                    public PipelineIntegrationTestBase {
+ public:
+  virtual ~PipelineIntegrationTestHost() {
+    // MessageLoop is already dead here... so we can't Stop() the pipeline here.
+    CHECK(!pipeline_->IsRunning());
+  };
+
+  virtual void SetUp() override {
+    ApplicationTestBase::SetUp();
+
+    // TODO(dalecurtis): For some reason this isn't done...
+    if (!CommandLine::InitializedForCurrentProcess()) {
+      CommandLine::Init(0, NULL);
+      media::InitializeMediaLibraryForTesting();
+    }
+
+    // Creating the service provider will create a message loop which we need
+    // to share...
+    service_provider_ = application_impl()
+                            ->ConnectToApplication("mojo:media")
+                            ->GetServiceProvider();
+
+    CHECK(base::MessageLoop::current());
+    Initialize(base::MessageLoop::current());
+  }
+
+ protected:
+  scoped_ptr<Renderer> CreateRenderer() override {
+    mojo::MediaRendererPtr mojo_media_renderer;
+    mojo::ConnectToService(service_provider_, &mojo_media_renderer);
+    return make_scoped_ptr(new MojoRendererImpl(message_loop_->task_runner(),
+                                                mojo_media_renderer.Pass()));
+  }
+
+ private:
+  mojo::ServiceProvider* service_provider_;
+};
+#else
+class PipelineIntegrationTestHost : public testing::Test,
+                                    public PipelineIntegrationTestBase {
+ public:
+  virtual ~PipelineIntegrationTestHost() {
+    if (pipeline_->IsRunning())
+      Stop();
+  };
+
+  virtual void SetUp() override { Initialize(&test_message_loop_); }
+
+ private:
+  base::MessageLoop test_message_loop_;
+};
+#endif

[xhwang, 2014/12/15 22:22:39]

Neat! 

I thought about putting mojo related code in media/mojo folder. But now I am not
sure whether it's worth the effort. Here's the rough idea just FYI:
- Have PipelineIntegrationTest defined in two files:
media/filters/pipeline_integration_test_host.h and
media/mojo/services/pipeline_integration_test_host.h
- Have an ifdef in this file to include different header files.

+
+class PipelineIntegrationTest : public PipelineIntegrationTestHost {
  public:
   void StartPipelineWithMediaSource(MockMediaSource* source) {
     EXPECT_CALL(*source, InitSegmentReceived()).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
         .Times(AtMost(1))
         .WillRepeatedly(SaveArg<0>(&metadata_));
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
         .Times(AtMost(1));
     demuxer_ = source->GetDemuxer().Pass();
     pipeline_->Start(
         demuxer_.get(), CreateRenderer(),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnStatusCallback,
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnMetadata,
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnBufferingStateChanged,
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnVideoFramePaint,
                    base::Unretained(this)),
         base::Closure(), base::Bind(&PipelineIntegrationTest::OnAddTextTrack,
                                     base::Unretained(this)));
-    message_loop_.Run();
+    message_loop_->Run();
     EXPECT_EQ(PIPELINE_OK, pipeline_status_);
   }
 
   void StartHashedPipelineWithMediaSource(MockMediaSource* source) {
     hashing_enabled_ = true;
     StartPipelineWithMediaSource(source);
   }
 
   void StartPipelineWithEncryptedMedia(
       MockMediaSource* source,
@@ skipping 24 matching lines @@
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnVideoFramePaint,
                    base::Unretained(this)),
         base::Closure(), base::Bind(&PipelineIntegrationTest::OnAddTextTrack,
                                     base::Unretained(this)));
 
     source->set_encrypted_media_init_data_cb(
         base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
                    base::Unretained(encrypted_media)));
 
-    message_loop_.Run();
+    message_loop_->Run();
     EXPECT_EQ(PIPELINE_OK, pipeline_status_);
   }
 
   // Verifies that seeking works properly for ChunkDemuxer when the
   // seek happens while there is a pending read on the ChunkDemuxer
   // and no data is available.
   bool TestSeekDuringRead(const std::string& filename,
                           const std::string& mimetype,
                           int initial_append_size,
                           base::TimeDelta start_seek_time,
@@ skipping 21 matching lines @@
     return true;
   }
 };
 
 TEST_F(PipelineIntegrationTest, BasicPlayback) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
+
+  // TODO(dalecurtis): Have to add this to every test since the MessageLoop dies
+  // before ~PipelineIntegrationTest(Base|Host|Etc).
+  Stop();
 }
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackOpusOgg) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-opus.ogg"));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
@@ skipping 226 matching lines @@
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-640x360-av_enc-av.webm");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
-  message_loop_.Run();
+  message_loop_->Run();
   EXPECT_EQ(PIPELINE_ERROR_DECODE, pipeline_status_);
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   // The second video was not added, so its time has not been added.
   EXPECT_EQ(k320WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
@@ skipping 233 matching lines @@
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
 
   scoped_refptr<DecoderBuffer> second_file =
       ReadTestDataFile("bear-1280x720-v_frag-cenc.mp4");
 
   source.AppendAtTime(base::TimeDelta::FromSeconds(kAppendTimeSec),
                       second_file->data(), second_file->data_size());
 
   source.EndOfStream();
 
-  message_loop_.Run();
+  message_loop_->Run();
   EXPECT_EQ(PIPELINE_ERROR_DECODE, pipeline_status_);
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   // The second video was not added, so its time has not been added.
   EXPECT_EQ(k640IsoFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
@@ skipping 427 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media