Fix double close in MojoAudioOutputStream.

media/mojo/services/mojo_audio_output_stream_unittest.cc

 // Copyright 2017 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/mojo/services/mojo_audio_output_stream.h"
 
 #include <utility>
 
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 17 matching lines @@
 using testing::_;
 using testing::Mock;
 using testing::NotNull;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 using testing::Test;
 using AudioOutputStream = mojom::AudioOutputStream;
 using AudioOutputStreamPtr = mojo::InterfacePtr<AudioOutputStream>;
 
+class TestCancelableSyncSocket : public base::CancelableSyncSocket {
+ public:
+  TestCancelableSyncSocket() {}
+
+  void ExpectOwnershipTransfer() { expect_ownership_transfer_ = true; }
+
+  ~TestCancelableSyncSocket() override {
+    // When the handle is sent over mojo, mojo takes ownership over it and
+    // closes it. We have to make sure we do not also retain the handle in the
+    // sync socket, as the sync socket closes the handle on destruction.
+    if (expect_ownership_transfer_)
+      EXPECT_EQ(handle(), kInvalidHandle);
+  }
+
+ private:
+  bool expect_ownership_transfer_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCancelableSyncSocket);
+};
+
 class MockDelegate : NON_EXPORTED_BASE(public AudioOutputDelegate) {
  public:
   MockDelegate() {}
   ~MockDelegate() {}
 
   MOCK_CONST_METHOD0(GetController, scoped_refptr<AudioOutputController>());
   MOCK_CONST_METHOD0(GetStreamId, int());
   MOCK_METHOD0(OnPlayStream, void());
   MOCK_METHOD0(OnPauseStream, void());
   MOCK_METHOD1(OnSetVolume, void(double));
@@ skipping 56 matching lines @@
 
  private:
   std::unique_ptr<base::SharedMemory> buffer_;
   std::unique_ptr<base::CancelableSyncSocket> socket_;
 };
 
 }  // namespace
 
 class MojoAudioOutputStreamTest : public Test {
  public:
-  MojoAudioOutputStreamTest() {}
+  MojoAudioOutputStreamTest()
+      : foreign_socket_(base::MakeUnique<TestCancelableSyncSocket>()) {}
 
   AudioOutputStreamPtr CreateAudioOutput() {
     AudioOutputStreamPtr p;
     ExpectDelegateCreation();
     impl_ = base::MakeUnique<MojoAudioOutputStream>(
         mojo::MakeRequest(&p),
         base::BindOnce(&MockDelegateFactory::CreateDelegate,
                        base::Unretained(&mock_delegate_factory_)),
         base::Bind(&MockClient::Initialized, base::Unretained(&client_)),
         base::BindOnce(&MockDeleter::Finished, base::Unretained(&deleter_)));
     EXPECT_NE(nullptr, p);
     return p;
   }
 
  protected:
   void ExpectDelegateCreation() {
     delegate_ = new StrictMock<MockDelegate>();
     mock_delegate_factory_.PrepareDelegateForCreation(
         base::WrapUnique(delegate_));
     EXPECT_TRUE(
-        base::CancelableSyncSocket::CreatePair(&local_, &foreign_socket_));
+        base::CancelableSyncSocket::CreatePair(&local_, foreign_socket_.get()));
     EXPECT_TRUE(mem_.CreateAnonymous(kShmemSize));
     EXPECT_CALL(mock_delegate_factory_, MockCreateDelegate(NotNull()))
         .WillOnce(SaveArg<0>(&delegate_event_handler_));
   }
 
   base::MessageLoop loop_;
-  base::CancelableSyncSocket local_, foreign_socket_;
+  base::CancelableSyncSocket local_;
+  std::unique_ptr<TestCancelableSyncSocket> foreign_socket_;
   base::SharedMemory mem_;
   StrictMock<MockDelegate>* delegate_ = nullptr;
   AudioOutputDelegate::EventHandler* delegate_event_handler_ = nullptr;
   StrictMock<MockDelegateFactory> mock_delegate_factory_;
   StrictMock<MockDeleter> deleter_;
   MockClient client_;
   std::unique_ptr<MojoAudioOutputStream> impl_;
 };
 
 TEST_F(MojoAudioOutputStreamTest, Play_Plays) {
@@ skipping 18 matching lines @@
 
   audio_output_ptr->SetVolume(kNewVolume);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MojoAudioOutputStreamTest, DestructWithCallPending_Safe) {
   AudioOutputStreamPtr audio_output_ptr = CreateAudioOutput();
   base::RunLoop().RunUntilIdle();
 
   ASSERT_NE(nullptr, delegate_event_handler_);
-  delegate_event_handler_->OnStreamCreated(kStreamId, &mem_, &foreign_socket_);
+  foreign_socket_->ExpectOwnershipTransfer();
+  delegate_event_handler_->OnStreamCreated(kStreamId, &mem_,
+                                           std::move(foreign_socket_));
   audio_output_ptr->Play();
   impl_.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MojoAudioOutputStreamTest, Created_NotifiesClient) {
   AudioOutputStreamPtr audio_output_ptr = CreateAudioOutput();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(client_, GotNotification());
 
   ASSERT_NE(nullptr, delegate_event_handler_);
-  delegate_event_handler_->OnStreamCreated(kStreamId, &mem_, &foreign_socket_);
+  foreign_socket_->ExpectOwnershipTransfer();
+  delegate_event_handler_->OnStreamCreated(kStreamId, &mem_,
+                                           std::move(foreign_socket_));
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MojoAudioOutputStreamTest, SetVolumeTooLarge_Error) {
   AudioOutputStreamPtr audio_output_ptr = CreateAudioOutput();
   EXPECT_CALL(deleter_, Finished());
 
   audio_output_ptr->SetVolume(15);
   base::RunLoop().RunUntilIdle();
@@ skipping 19 matching lines @@
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClear(&deleter_);
 }
 
 TEST_F(MojoAudioOutputStreamTest, DelegateErrorAfterCreated_PropagatesError) {
   AudioOutputStreamPtr audio_output_ptr = CreateAudioOutput();
   EXPECT_CALL(deleter_, Finished());
   base::RunLoop().RunUntilIdle();
 
   ASSERT_NE(nullptr, delegate_event_handler_);
-  delegate_event_handler_->OnStreamCreated(kStreamId, &mem_, &foreign_socket_);
+  foreign_socket_->ExpectOwnershipTransfer();
+  delegate_event_handler_->OnStreamCreated(kStreamId, &mem_,
+                                           std::move(foreign_socket_));
   delegate_event_handler_->OnStreamError(kStreamId);
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClear(&deleter_);
 }
 
 TEST_F(MojoAudioOutputStreamTest, RemoteEndGone_Error) {
   AudioOutputStreamPtr audio_output_ptr = CreateAudioOutput();
   EXPECT_CALL(deleter_, Finished());
   audio_output_ptr.reset();
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClear(&deleter_);
 }
 
 }  // namespace media