media: scaffolding and plumbing for MojoRenderer{Impl, Service}

media/mojo/services/renderer_unittest.cc

Index: media/mojo/services/renderer_unittest.cc
diff --git a/media/mojo/services/renderer_unittest.cc b/media/mojo/services/renderer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e41557e082e75bfd061b79e9f77118ecd5310d26
--- /dev/null
+++ b/media/mojo/services/renderer_unittest.cc
@@ -0,0 +1,184 @@
+// Copyright 2014 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/at_exit.h"
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/channel_layout.h"
+#include "media/base/demuxer_stream_provider.h"
+#include "media/base/sample_format.h"
+#include "media/base/video_decoder_config.h"
+#include "media/mojo/services/mojo_renderer_impl.h"
+#include "mojo/public/c/system/main.h"
+#include "mojo/public/cpp/application/application_delegate.h"
+#include "mojo/public/cpp/application/application_impl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+// This class is here to give the gtest class access to the
+// mojo::ApplicationImpl so that the tests can connect to other applications.
+class MojoRendererTestHelper : public mojo::ApplicationDelegate {
+ public:
+  MojoRendererTestHelper() : application_impl_(NULL) {}
+  virtual ~MojoRendererTestHelper() {}
+
+  // ApplicationDelegate implementation.
+  virtual void Initialize(mojo::ApplicationImpl* app) OVERRIDE {
+    application_impl_ = app;
+  }
+
+  mojo::ApplicationImpl* application_impl() { return application_impl_; }
+
+ private:
+  mojo::ApplicationImpl* application_impl_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoRendererTestHelper);
+};
+
+// TODO(tim): Reconcile this with mojo apptest framework when ready.
+MojoRendererTestHelper* g_test_delegate = NULL;
+
+// TODO(tim): Make media::FakeDemuxerStream support audio and use that for the
+// DemuxerStream implementation instead.
+class FakeDemuxerStream : public media::DemuxerStreamProvider,
+                          public media::DemuxerStream {
+ public:
+  FakeDemuxerStream() {}
+  virtual ~FakeDemuxerStream() {}
+
+  // media::Demuxer implementation.
+  virtual media::DemuxerStream* GetStream(
+      media::DemuxerStream::Type type) OVERRIDE {
+    DCHECK_EQ(media::DemuxerStream::AUDIO, type);
+    return this;
+  }
+  virtual media::DemuxerStreamProvider::Liveness GetLiveness() const OVERRIDE {
+    return media::DemuxerStreamProvider::LIVENESS_UNKNOWN;
+  }
+
+  // media::DemuxerStream implementation.
+  virtual void Read(const ReadCB& read_cb) OVERRIDE {}
+
+  virtual media::AudioDecoderConfig audio_decoder_config() OVERRIDE {
+    media::AudioDecoderConfig config;
+    config.Initialize(media::kCodecAAC,
+                      media::kSampleFormatU8,
+                      media::CHANNEL_LAYOUT_SURROUND,
+                      48000,
+                      NULL,
+                      0,
+                      false,
+                      false,
+                      base::TimeDelta(),
+                      0);
+    return config;
+  }
+
+  virtual media::VideoDecoderConfig video_decoder_config() OVERRIDE {
+    NOTREACHED();
+    return media::VideoDecoderConfig();
+  }
+
+  virtual media::DemuxerStream::Type type() OVERRIDE {
+    return media::DemuxerStream::AUDIO;
+  }
+
+  virtual void EnableBitstreamConverter() OVERRIDE {}
+
+  virtual bool SupportsConfigChanges() OVERRIDE { return true; }
+
+  virtual media::VideoRotation video_rotation() OVERRIDE {
+    NOTREACHED();
+    return media::VIDEO_ROTATION_0;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeDemuxerStream);
+};
+
+}  // namespace
+
+namespace media {
+
+class MojoRendererTest : public testing::Test {
+ public:
+  MojoRendererTest() : service_provider_(NULL) {}
+
+  virtual void SetUp() OVERRIDE {
+    demuxer_stream_provider_.reset(new FakeDemuxerStream());
+    service_provider_ =
+        g_test_delegate->application_impl()
+            ->ConnectToApplication("mojo:media_mojo_renderer_app")
+            ->GetServiceProvider();
+  }
+
+  mojo::ServiceProvider* service_provider() { return service_provider_; }
+  DemuxerStreamProvider* stream_provider() {
+    return demuxer_stream_provider_.get();
+  }
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner() {
+    return base::MessageLoop::current()->task_runner();
+  }
+
+ private:
+  scoped_ptr<DemuxerStreamProvider> demuxer_stream_provider_;
+  mojo::ServiceProvider* service_provider_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoRendererTest);
+};
+
+void ErrorCallback(PipelineStatus* output, PipelineStatus status) {
+  *output = status;
+}
+
+// Tests that a MojoRendererImpl can successfully establish communication
+// with a MojoRendererService and set up a MojoDemuxerStream
+// connection. The test also initializes a media::AudioRendererImpl which
+// will error-out expectedly due to lack of support for decoder selection.
+TEST_F(MojoRendererTest, BasicInitialize) {
+  MojoRendererImpl rimpl(task_runner(), stream_provider(), service_provider());
+  PipelineStatus expected_error(PIPELINE_OK);
+  rimpl.Initialize(base::MessageLoop::current()->QuitClosure(),
+                   media::StatisticsCB(),
+                   base::Closure(),
+                   base::Bind(&ErrorCallback, &expected_error),
+                   media::BufferingStateCB());
+  base::MessageLoop::current()->Run();
+
+  // We expect an error during initialization because MojoRendererService
+  // doesn't initialize any decoders, which causes an error.
+  EXPECT_EQ(PIPELINE_ERROR_COULD_NOT_RENDER, expected_error);
+}
+
+}  // namespace media
+
+MojoResult MojoMain(MojoHandle shell_handle) {
+  base::CommandLine::Init(0, NULL);
+#if !defined(COMPONENT_BUILD)
+  base::AtExitManager at_exit;
+#endif
+
+  // TODO(tim): Reconcile this with apptest framework when it is ready.
+  scoped_ptr<mojo::ApplicationDelegate> delegate(new MojoRendererTestHelper());
+  g_test_delegate = static_cast<MojoRendererTestHelper*>(delegate.get());
+  {
+    base::MessageLoop loop;
+    mojo::ApplicationImpl impl(
+        delegate.get(),
+        mojo::MakeScopedHandle(mojo::MessagePipeHandle(shell_handle)));
+
+    int argc = 0;
+    char** argv = NULL;
+    testing::InitGoogleTest(&argc, argv);
+    mojo_ignore_result(RUN_ALL_TESTS());
+  }
+
+  g_test_delegate = NULL;
+  delegate.reset();
+  return MOJO_RESULT_OK;
+}