Revert of Fixing a Dr. memory failure in the remoting unit tests.

remoting/host/security_key/remote_security_key_message_reader_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 "remoting/host/security_key/remote_security_key_message_reader.h"
 
 #include <cstdint>
 #include <string>
 #include <utility>
 
@@ skipping 15 matching lines @@
 
 class RemoteSecurityKeyMessageReaderTest : public testing::Test {
  public:
   RemoteSecurityKeyMessageReaderTest();
   ~RemoteSecurityKeyMessageReaderTest() override;
 
   // SecurityKeyMessageCallback passed to the Reader. Stores |message| so it can
   // be verified by tests.
   void OnMessage(scoped_ptr<SecurityKeyMessage> message);
 
-  // Used as a callback to signal completion.
-  void OperationComplete();
-
  protected:
   // testing::Test interface.
   void SetUp() override;
 
   // Runs the MessageLoop until the reader has completed and called back.
   void Run();
 
   // Writes a message (header+code+body) to the write-end of the pipe.
   void WriteMessage(RemoteSecurityKeyMessageType message_type,
                     const std::string& message_payload);
 
   // Writes some data to the write-end of the pipe.
   void WriteData(const char* data, int length);
 
   scoped_ptr<RemoteSecurityKeyMessageReader> reader_;
   base::File read_file_;
   base::File write_file_;
 
   std::vector<scoped_ptr<SecurityKeyMessage>> messages_received_;
 
  private:
   base::MessageLoopForIO message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  base::RunLoop run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteSecurityKeyMessageReaderTest);
 };
 
-RemoteSecurityKeyMessageReaderTest::RemoteSecurityKeyMessageReaderTest()
-    : run_loop_(new base::RunLoop()) {}
+RemoteSecurityKeyMessageReaderTest::RemoteSecurityKeyMessageReaderTest() {}
 
 RemoteSecurityKeyMessageReaderTest::~RemoteSecurityKeyMessageReaderTest() {}
 
 void RemoteSecurityKeyMessageReaderTest::SetUp() {
   ASSERT_TRUE(MakePipe(&read_file_, &write_file_));
   reader_.reset(new RemoteSecurityKeyMessageReader(std::move(read_file_)));
 
   // base::Unretained is safe since no further tasks can run after
   // RunLoop::Run() returns.
-  reader_->Start(
-      base::Bind(&RemoteSecurityKeyMessageReaderTest::OnMessage,
-                 base::Unretained(this)),
-      base::Bind(&RemoteSecurityKeyMessageReaderTest::OperationComplete,
-                 base::Unretained(this)));
+  reader_->Start(base::Bind(&RemoteSecurityKeyMessageReaderTest::OnMessage,
+                            base::Unretained(this)),
+                 run_loop_.QuitClosure());
 }
 
 void RemoteSecurityKeyMessageReaderTest::Run() {
-  run_loop_->Run();
-  run_loop_.reset(new base::RunLoop());
+  // Close the write-end, so the reader doesn't block waiting for more data.
+  write_file_.Close();
+  run_loop_.Run();
 }
 
 void RemoteSecurityKeyMessageReaderTest::OnMessage(
     scoped_ptr<SecurityKeyMessage> message) {
   messages_received_.push_back(std::move(message));
-  OperationComplete();
-}
-
-void RemoteSecurityKeyMessageReaderTest::OperationComplete() {
-  run_loop_->Quit();
 }
 
 void RemoteSecurityKeyMessageReaderTest::WriteMessage(
     RemoteSecurityKeyMessageType message_type,
     const std::string& message_payload) {
   uint32_t length =
       SecurityKeyMessage::kMessageTypeSizeBytes + message_payload.size();
   WriteData(reinterpret_cast<char*>(&length),
             SecurityKeyMessage::kHeaderSizeBytes);
   WriteData(reinterpret_cast<char*>(&message_type),
@@ skipping 39 matching lines @@
                           SecurityKeyMessage::kMessageTypeSizeBytes,
                       'Y');
   WriteMessage(kTestMessageType, payload);
   Run();
   ASSERT_EQ(1u, messages_received_.size());
   ASSERT_EQ(kTestMessageType, messages_received_[0]->type());
   ASSERT_EQ(payload, messages_received_[0]->payload());
 }
 
 TEST_F(RemoteSecurityKeyMessageReaderTest, EmptyFile) {
-  write_file_.Close();
   Run();
   ASSERT_EQ(0u, messages_received_.size());
 }
 
 TEST_F(RemoteSecurityKeyMessageReaderTest, InvalidMessageLength) {
   uint32_t length = kMaxSecurityKeyMessageByteCount + 1;
   ASSERT_FALSE(SecurityKeyMessage::IsValidMessageSize(length));
   WriteData(reinterpret_cast<char*>(&length), sizeof(length));
   Run();
   ASSERT_EQ(0u, messages_received_.size());
 }
 
 TEST_F(RemoteSecurityKeyMessageReaderTest, ShortHeader) {
   // Write only 3 bytes - the message length header is supposed to be 4 bytes.
   WriteData("xxx", SecurityKeyMessage::kHeaderSizeBytes - 1);
-  write_file_.Close();
   Run();
   ASSERT_EQ(0u, messages_received_.size());
 }
 
 TEST_F(RemoteSecurityKeyMessageReaderTest, ZeroLengthMessage) {
   uint32_t length = 0;
   WriteData(reinterpret_cast<char*>(&length), sizeof(length));
   Run();
   ASSERT_EQ(0u, messages_received_.size());
 }
 
 TEST_F(RemoteSecurityKeyMessageReaderTest, MissingControlCode) {
   uint32_t length = 1;
   WriteData(reinterpret_cast<char*>(&length), sizeof(length));
-  write_file_.Close();
   Run();
   ASSERT_EQ(0u, messages_received_.size());
 }
 
 TEST_F(RemoteSecurityKeyMessageReaderTest, MissingPayload) {
   uint32_t length = 2;
   WriteData(reinterpret_cast<char*>(&length), sizeof(length));
 
   char test_control_code = static_cast<char>(kTestMessageType);
   WriteData(&test_control_code, sizeof(test_control_code));
-  write_file_.Close();
   Run();
   ASSERT_EQ(0u, messages_received_.size());
 }
 
 TEST_F(RemoteSecurityKeyMessageReaderTest, MultipleMessages) {
   std::vector<std::string> payloads({"", "S",  // Really short
                                      "", "Short", "", "Medium Length", "",
                                      "Longer than medium, but not super long",
                                      "", std::string(2048, 'Y'), ""});
 
   for (auto& payload : payloads) {
     WriteMessage(kTestMessageType, payload);
-    Run();
   }
 
+  Run();
   ASSERT_EQ(payloads.size(), messages_received_.size());
 
   for (size_t i = 0; i < payloads.size(); i++) {
     ASSERT_EQ(kTestMessageType, messages_received_[i]->type());
     ASSERT_EQ(payloads[i], messages_received_[i]->payload());
   }
 }
 
 }  // namespace remoting