Make MessageReader class not ref-counted.

remoting/protocol/message_reader_unittest.cc

 // Copyright (c) 2012 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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 #include "remoting/protocol/fake_session.h"
 #include "remoting/protocol/message_reader.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/libjingle/source/talk/base/byteorder.h"
 
 using testing::_;
 using testing::DoAll;
@@ skipping 13 matching lines @@
 }  // namespace
 
 class MockMessageReceivedCallback {
  public:
   MOCK_METHOD1(OnMessage, void(const base::Closure&));
 };
 
 class MessageReaderTest : public testing::Test {
  public:
   MessageReaderTest()
-      : other_thread_("SecondTestThread"),
-        run_task_finished_(false, false) {
-  }
-
-  void RunDoneTaskOnOtherThread(const base::Closure& done_task) {
-    other_thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&MessageReaderTest::RunClosure,
-                   base::Unretained(this), done_task));
+      : run_task_finished_(false, false) {
   }
 
  protected:
   virtual void SetUp() OVERRIDE {
-    reader_ = new MessageReader();
+    reader_.reset(new MessageReader());
   }
 
   virtual void TearDown() OVERRIDE {
     STLDeleteElements(&messages_);
   }
 
   void InitReader() {
     reader_->Init(&socket_, base::Bind(
         &MessageReaderTest::OnMessage, base::Unretained(this)));
   }
@@ skipping 16 matching lines @@
     run_task_finished_.Signal();
   }
 
   void OnMessage(scoped_ptr<CompoundBuffer> buffer,
                  const base::Closure& done_callback) {
     messages_.push_back(buffer.release());
     callback_.OnMessage(done_callback);
   }
 
   MessageLoop message_loop_;
-  base::Thread other_thread_;
   base::WaitableEvent run_task_finished_;
-  scoped_refptr<MessageReader> reader_;
+  scoped_ptr<MessageReader> reader_;
   FakeSocket socket_;
   MockMessageReceivedCallback callback_;
   std::vector<CompoundBuffer*> messages_;
 };
 
 // Receive one message and process it with delay
 TEST_F(MessageReaderTest, OneMessage_Delay) {
   base::Closure done_task;
 
   AddMessage(kTestMessage1);
@@ skipping 146 matching lines @@
 
   // Verify that the reader starts reading again only after we've
   // finished processing the previous message.
   EXPECT_FALSE(socket_.read_pending());
 
   done_task.Run();
 
   EXPECT_TRUE(socket_.read_pending());
 }
 
-// Verify that socket operations occur on same thread, even when the OnMessage()
-// callback triggers |done_task| to run on a different thread.
-TEST_F(MessageReaderTest, UseSocketOnCorrectThread) {
-  AddMessage(kTestMessage1);
-  other_thread_.Start();
-
-  EXPECT_CALL(callback_, OnMessage(_))
-      .WillOnce(Invoke(this, &MessageReaderTest::RunDoneTaskOnOtherThread));
-
-  InitReader();
-
-  run_task_finished_.Wait();
-  message_loop_.RunAllPending();
-
-  Mock::VerifyAndClearExpectations(&callback_);
-
-  // Write another message and verify that we receive it.
-  base::Closure done_task;
-  EXPECT_CALL(callback_, OnMessage(_))
-      .WillOnce(SaveArg<0>(&done_task));
-  AddMessage(kTestMessage2);
-  EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
-
-  done_task.Run();
-}
-
 // Read() returns error.
 TEST_F(MessageReaderTest, ReadError) {
   socket_.set_next_read_error(net::ERR_FAILED);
 
   // Add a message. It should never be read after the error above.
   AddMessage(kTestMessage1);
 
   EXPECT_CALL(callback_, OnMessage(_))
       .Times(0);
 
   InitReader();
 }
 
 }  // namespace protocol
 }  // namespace remoting