Use ApplicationTestBase for MojoRendererTest.

media/mojo/services/media_renderer_apptest.cc

 // 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"
+#include "mojo/public/cpp/application/application_test_base.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) {}
   ~MojoRendererTestHelper() override {}
 
   // ApplicationDelegate implementation.
   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() {}
   ~FakeDemuxerStream() override {}
 
   // media::Demuxer implementation.
   media::DemuxerStream* GetStream(media::DemuxerStream::Type type) override {
-    DCHECK_EQ(media::DemuxerStream::AUDIO, type);
-    return this;
+    if (type == media::DemuxerStream::AUDIO)
+      return this;
+    return nullptr;
   }
   media::DemuxerStreamProvider::Liveness GetLiveness() const override {
     return media::DemuxerStreamProvider::LIVENESS_UNKNOWN;
   }
 
   // media::DemuxerStream implementation.
   void Read(const ReadCB& read_cb) override {}
 
   media::AudioDecoderConfig audio_decoder_config() override {
     media::AudioDecoderConfig config;
@@ skipping 29 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeDemuxerStream);
 };
 
 }  // namespace
 
 namespace media {
 
-class MojoRendererTest : public testing::Test {
+class MojoRendererTest : public mojo::test::ApplicationTestBase {
  public:
-  MojoRendererTest() : service_provider_(NULL) {}
+  MojoRendererTest()
+      : ApplicationTestBase(mojo::Array<mojo::String>()),
+        service_provider_(NULL) {}
+  ~MojoRendererTest() override {}
+
+ protected:
+  // ApplicationTestBase implementation.
+  mojo::ApplicationDelegate* GetApplicationDelegate() override {
+    return &mojo_renderer_test_helper_;
+  }
 
   void SetUp() override {
+    ApplicationTestBase::SetUp();
     demuxer_stream_provider_.reset(new FakeDemuxerStream());
     service_provider_ =
-        g_test_delegate->application_impl()
-            ->ConnectToApplication("mojo:media_mojo_renderer_app")
+        application_impl()
+            ->ConnectToApplication("mojo:mojo_media_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:
+  MojoRendererTestHelper mojo_renderer_test_helper_;
   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(), service_provider());
+  MojoRendererImpl mojo_renderer_impl(task_runner(), service_provider());
   PipelineStatus expected_error(PIPELINE_OK);
-  rimpl.Initialize(stream_provider(),
-                   base::MessageLoop::current()->QuitClosure(),
-                   media::StatisticsCB(),
-                   base::Closure(),
-                   base::Bind(&ErrorCallback, &expected_error),
-                   media::BufferingStateCB());
+  mojo_renderer_impl.Initialize(
+      stream_provider(), 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;
-}