media: Rename media_mojo_shell_unittests to media_service_unittests

media/mojo/services/media_mojo_unittest.cc

Index: media/mojo/services/media_mojo_unittest.cc
diff --git a/media/mojo/services/media_mojo_unittest.cc b/media/mojo/services/media_mojo_unittest.cc
deleted file mode 100644
index ed5e770ab76fb5c1f72f78b80fe783c43ce2be52..0000000000000000000000000000000000000000
--- a/media/mojo/services/media_mojo_unittest.cc
+++ /dev/null
@@ -1,221 +0,0 @@
-// Copyright 2015 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 <stdint.h>
-
-#include <memory>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/run_loop.h"
-#include "media/base/cdm_config.h"
-#include "media/base/mock_filters.h"
-#include "media/base/test_helpers.h"
-#include "media/mojo/clients/mojo_demuxer_stream_impl.h"
-#include "media/mojo/common/media_type_converters.h"
-#include "media/mojo/interfaces/content_decryption_module.mojom.h"
-#include "media/mojo/interfaces/decryptor.mojom.h"
-#include "media/mojo/interfaces/interface_factory.mojom.h"
-#include "media/mojo/interfaces/media_service.mojom.h"
-#include "media/mojo/interfaces/renderer.mojom.h"
-#include "mojo/public/cpp/bindings/associated_binding.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-#include "services/service_manager/public/cpp/interface_registry.h"
-#include "services/service_manager/public/cpp/service_test.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-using testing::Exactly;
-using testing::Invoke;
-using testing::InvokeWithoutArgs;
-using testing::StrictMock;
-
-namespace media {
-namespace {
-
-#if defined(ENABLE_MOJO_CDM)
-const char kClearKeyKeySystem[] = "org.w3.clearkey";
-const char kInvalidKeySystem[] = "invalid.key.system";
-#endif
-const char kSecurityOrigin[] = "http://foo.com";
-
-class MockRendererClient : public mojom::RendererClient {
- public:
-  MockRendererClient() {}
-  ~MockRendererClient() override {}
-
-  // mojom::RendererClient implementation.
-  MOCK_METHOD3(OnTimeUpdate,
-               void(base::TimeDelta time,
-                    base::TimeDelta max_time,
-                    base::TimeTicks capture_time));
-  MOCK_METHOD1(OnBufferingStateChange, void(BufferingState state));
-  MOCK_METHOD0(OnEnded, void());
-  MOCK_METHOD0(OnError, void());
-  MOCK_METHOD1(OnVideoOpacityChange, void(bool opaque));
-  MOCK_METHOD1(OnVideoNaturalSizeChange, void(const gfx::Size& size));
-  MOCK_METHOD1(OnStatisticsUpdate,
-               void(const media::PipelineStatistics& stats));
-  MOCK_METHOD0(OnWaitingForDecryptionKey, void());
-  MOCK_METHOD1(OnDurationChange, void(base::TimeDelta duration));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockRendererClient);
-};
-
-class MediaServiceTest : public service_manager::test::ServiceTest {
- public:
-  MediaServiceTest()
-      : ServiceTest("media_mojo_shell_unittests"),
-        renderer_client_binding_(&renderer_client_),
-        video_stream_(DemuxerStream::VIDEO) {}
-  ~MediaServiceTest() override {}
-
-  void SetUp() override {
-    ServiceTest::SetUp();
-
-    connection_ = connector()->Connect("media");
-    media::mojom::MediaServicePtr media_service;
-    connection_->GetInterface(&media_service);
-
-    auto registry =
-        base::MakeUnique<service_manager::InterfaceRegistry>(std::string());
-    service_manager::mojom::InterfaceProviderPtr interfaces;
-    registry->Bind(GetProxy(&interfaces), service_manager::Identity(),
-                   service_manager::InterfaceProviderSpec(),
-                   service_manager::Identity(),
-                   service_manager::InterfaceProviderSpec());
-
-    media_service->CreateInterfaceFactory(mojo::GetProxy(&interface_factory_),
-                                          std::move(interfaces));
-
-    run_loop_.reset(new base::RunLoop());
-  }
-
-  // MOCK_METHOD* doesn't support move only types. Work around this by having
-  // an extra method.
-  MOCK_METHOD2(OnCdmInitializedInternal, void(bool result, int cdm_id));
-  void OnCdmInitialized(mojom::CdmPromiseResultPtr result,
-                        int cdm_id,
-                        mojom::DecryptorPtr decryptor) {
-    OnCdmInitializedInternal(result->success, cdm_id);
-  }
-
-  void InitializeCdm(const std::string& key_system,
-                     bool expected_result,
-                     int cdm_id) {
-    interface_factory_->CreateCdm(mojo::GetProxy(&cdm_));
-
-    EXPECT_CALL(*this, OnCdmInitializedInternal(expected_result, cdm_id))
-        .Times(Exactly(1))
-        .WillOnce(InvokeWithoutArgs(run_loop_.get(), &base::RunLoop::Quit));
-    cdm_->Initialize(key_system, kSecurityOrigin,
-                     mojom::CdmConfig::From(CdmConfig()),
-                     base::Bind(&MediaServiceTest::OnCdmInitialized,
-                                base::Unretained(this)));
-  }
-
-  MOCK_METHOD1(OnRendererInitialized, void(bool));
-
-  void InitializeRenderer(const VideoDecoderConfig& video_config,
-                          bool expected_result) {
-    interface_factory_->CreateRenderer(std::string(),
-                                       mojo::GetProxy(&renderer_));
-
-    video_stream_.set_video_decoder_config(video_config);
-
-    mojom::DemuxerStreamPtr video_stream_proxy;
-    mojo_video_stream_.reset(new MojoDemuxerStreamImpl(
-        &video_stream_, GetProxy(&video_stream_proxy)));
-
-    mojom::RendererClientAssociatedPtrInfo client_ptr_info;
-    renderer_client_binding_.Bind(&client_ptr_info,
-                                  renderer_.associated_group());
-
-    EXPECT_CALL(*this, OnRendererInitialized(expected_result))
-        .Times(Exactly(1))
-        .WillOnce(InvokeWithoutArgs(run_loop_.get(), &base::RunLoop::Quit));
-    renderer_->Initialize(std::move(client_ptr_info), nullptr,
-                          std::move(video_stream_proxy), base::nullopt,
-                          base::nullopt,
-                          base::Bind(&MediaServiceTest::OnRendererInitialized,
-                                     base::Unretained(this)));
-  }
-
-  MOCK_METHOD0(ConnectionClosed, void());
-
- protected:
-  std::unique_ptr<service_manager::Connection> connection_;
-  std::unique_ptr<base::RunLoop> run_loop_;
-
-  mojom::InterfaceFactoryPtr interface_factory_;
-  mojom::ContentDecryptionModulePtr cdm_;
-  mojom::RendererPtr renderer_;
-
-  StrictMock<MockRendererClient> renderer_client_;
-  mojo::AssociatedBinding<mojom::RendererClient> renderer_client_binding_;
-
-  StrictMock<MockDemuxerStream> video_stream_;
-  std::unique_ptr<MojoDemuxerStreamImpl> mojo_video_stream_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MediaServiceTest);
-};
-
-}  // namespace
-
-// Note: base::RunLoop::RunUntilIdle() does not work well in these tests because
-// even when the loop is idle, we may still have pending events in the pipe.
-
-#if defined(ENABLE_MOJO_CDM)
-TEST_F(MediaServiceTest, InitializeCdm_Success) {
-  InitializeCdm(kClearKeyKeySystem, true, 1);
-  run_loop_->Run();
-}
-
-TEST_F(MediaServiceTest, InitializeCdm_InvalidKeySystem) {
-  InitializeCdm(kInvalidKeySystem, false, 0);
-  run_loop_->Run();
-}
-#endif  // defined(ENABLE_MOJO_CDM)
-
-#if defined(ENABLE_MOJO_RENDERER)
-// Sometimes fails on Linux. http://crbug.com/594977
-#if defined(OS_LINUX)
-#define MAYBE_InitializeRenderer_Success DISABLED_InitializeRenderer_Success
-#else
-#define MAYBE_InitializeRenderer_Success InitializeRenderer_Success
-#endif
-
-TEST_F(MediaServiceTest, MAYBE_InitializeRenderer_Success) {
-  InitializeRenderer(TestVideoConfig::Normal(), true);
-  run_loop_->Run();
-}
-
-TEST_F(MediaServiceTest, InitializeRenderer_InvalidConfig) {
-  InitializeRenderer(TestVideoConfig::Invalid(), false);
-  run_loop_->Run();
-}
-#endif  // defined(ENABLE_MOJO_RENDERER)
-
-TEST_F(MediaServiceTest, Lifetime) {
-  connection_->SetConnectionLostClosure(
-      base::Bind(&MediaServiceTest::ConnectionClosed, base::Unretained(this)));
-
-  // Disconnecting CDM and Renderer services doesn't terminate the app.
-  cdm_.reset();
-  renderer_.reset();
-
-  // Disconnecting InterfaceFactory service should terminate the app, which will
-  // close the connection.
-  EXPECT_CALL(*this, ConnectionClosed())
-      .Times(Exactly(1))
-      .WillOnce(Invoke(run_loop_.get(), &base::RunLoop::Quit));
-  interface_factory_.reset();
-
-  run_loop_->Run();
-}
-
-}  // namespace media