Privatize StrongBinding lifetime management

media/mojo/clients/mojo_renderer_unittest.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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/platform_thread.h"
 #include "base/timer/elapsed_timer.h"
 #include "media/base/audio_renderer_sink.h"
 #include "media/base/cdm_config.h"
 #include "media/base/cdm_context.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_renderer_sink.h"
 #include "media/cdm/default_cdm_factory.h"
 #include "media/mojo/clients/mojo_renderer.h"
 #include "media/mojo/common/media_type_converters.h"
 #include "media/mojo/interfaces/content_decryption_module.mojom.h"
 #include "media/mojo/interfaces/renderer.mojom.h"
 #include "media/mojo/services/mojo_cdm_service.h"
 #include "media/mojo/services/mojo_cdm_service_context.h"
 #include "media/mojo/services/mojo_renderer_service.h"
 #include "media/renderers/video_overlay_factory.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace media {
 
@@ skipping 14 matching lines @@
 }  // namespace
 
 class MojoRendererTest : public ::testing::Test {
  public:
   MojoRendererTest() {
     std::unique_ptr<StrictMock<MockRenderer>> mock_renderer(
         new StrictMock<MockRenderer>());
     mock_renderer_ = mock_renderer.get();
 
     mojom::RendererPtr remote_renderer;
-
-    mojo_renderer_service_ = new MojoRendererService(
-        mojo_cdm_service_context_.GetWeakPtr(), nullptr, nullptr,
-        std::move(mock_renderer), mojo::GetProxy(&remote_renderer));
+    renderer_binding_ =
+        mojo::MakeStrongBinding(base::MakeUnique<MojoRendererService>(
+                                    mojo_cdm_service_context_.GetWeakPtr(),
+                                    nullptr, nullptr, std::move(mock_renderer)),
+                                mojo::GetProxy(&remote_renderer));
 
     mojo_renderer_.reset(
         new MojoRenderer(message_loop_.task_runner(),
                          std::unique_ptr<VideoOverlayFactory>(nullptr), nullptr,
                          std::move(remote_renderer)));
 
     // CreateAudioStream() and CreateVideoStream() overrides expectations for
     // expected non-NULL streams.
     EXPECT_CALL(demuxer_, GetStream(_)).WillRepeatedly(Return(nullptr));
 
@@ skipping 69 matching lines @@
         &cdm_context_,
         base::Bind(&MojoRendererTest::OnCdmAttached, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   // Simulates a connection error at the client side by killing the service.
   // Note that |mock_renderer_| will also be destroyed, do NOT expect anything
   // on it. Otherwise the test will crash.
   void ConnectionError() {
     DVLOG(1) << __FUNCTION__;
-    delete mojo_renderer_service_;
+    DCHECK(renderer_binding_);
+    renderer_binding_->Close();
     base::RunLoop().RunUntilIdle();
   }
 
   void OnCdmCreated(mojom::CdmPromiseResultPtr result,
                     int cdm_id,
                     mojom::DecryptorPtr decryptor) {
     EXPECT_TRUE(result->success);
     EXPECT_NE(CdmContext::kInvalidCdmId, cdm_id);
     cdm_context_.set_cdm_id(cdm_id);
   }
 
   void CreateCdm() {
-    new MojoCdmService(mojo_cdm_service_context_.GetWeakPtr(), &cdm_factory_,
-                       mojo::GetProxy(&remote_cdm_));
+    mojo::MakeStrongBinding(
+        base::MakeUnique<MojoCdmService>(mojo_cdm_service_context_.GetWeakPtr(),
+                                         &cdm_factory_),
+        mojo::GetProxy(&remote_cdm_));
     remote_cdm_->Initialize(
         kClearKeyKeySystem, "https://www.test.com",
         mojom::CdmConfig::From(CdmConfig()),
         base::Bind(&MojoRendererTest::OnCdmCreated, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   void StartPlayingFrom(base::TimeDelta start_time) {
     EXPECT_CALL(*mock_renderer_, StartPlayingFrom(start_time));
     mojo_renderer_->StartPlayingFrom(start_time);
@@ skipping 20 matching lines @@
   StrictMock<MockDemuxer> demuxer_;
   std::unique_ptr<StrictMock<MockDemuxerStream>> audio_stream_;
   std::unique_ptr<StrictMock<MockDemuxerStream>> video_stream_;
 
   // Service side mocks and helpers.
   StrictMock<MockRenderer>* mock_renderer_;
   MojoCdmServiceContext mojo_cdm_service_context_;
   RendererClient* remote_renderer_client_;
   DefaultCdmFactory cdm_factory_;
 
-  // Owned by the connection. But we can delete it manually to trigger a
-  // connection error at the client side. See ConnectionError();
-  MojoRendererService* mojo_renderer_service_;
+  mojo::StrongBindingPtr<mojom::Renderer> renderer_binding_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MojoRendererTest);
 };
 
 TEST_F(MojoRendererTest, Initialize_Success) {
   Initialize();
 }
 
 TEST_F(MojoRendererTest, Initialize_Failure) {
@@ skipping 197 matching lines @@
   Play();
   remote_renderer_client_->OnError(PIPELINE_ERROR_DECODE);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*mock_renderer_, SetPlaybackRate(0.0)).Times(1);
   mojo_renderer_->SetPlaybackRate(0.0);
   Flush();
 }
 
 }  // namespace media