Make MessageReader class not ref-counted.

remoting/protocol/message_reader.cc

Index: remoting/protocol/message_reader.cc
diff --git a/remoting/protocol/message_reader.cc b/remoting/protocol/message_reader.cc
index 441d7295b1dc4340fe5a8e5e17b388a52a87c41f..fbbe9be74bf1c0cdf23f47acdb8d513813344324 100644
--- a/remoting/protocol/message_reader.cc
+++ b/remoting/protocol/message_reader.cc
@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
@@ -23,11 +24,13 @@ MessageReader::MessageReader()
     : socket_(NULL),
       read_pending_(false),
       pending_messages_(0),
-      closed_(false) {
+      closed_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 void MessageReader::Init(net::Socket* socket,
                          const MessageReceivedCallback& callback) {
+  DCHECK(CalledOnValidThread());
   message_received_callback_ = callback;
   DCHECK(socket);
   socket_ = socket;
@@ -39,18 +42,20 @@ MessageReader::~MessageReader() {
 }
 
 void MessageReader::DoRead() {
+  DCHECK(CalledOnValidThread());
   // Don't try to read again if there is another read pending or we
   // have messages that we haven't finished processing yet.
   while (!closed_ && !read_pending_ && pending_messages_ == 0) {
     read_buffer_ = new net::IOBuffer(kReadBufferSize);
     int result = socket_->Read(
-        read_buffer_, kReadBufferSize, base::Bind(&MessageReader::OnRead,
-                                                  base::Unretained(this)));
+        read_buffer_, kReadBufferSize,
+        base::Bind(&MessageReader::OnRead, weak_factory_.GetWeakPtr()));
     HandleReadResult(result);
   }
 }
 
 void MessageReader::OnRead(int result) {
+  DCHECK(CalledOnValidThread());
   DCHECK(read_pending_);
   read_pending_ = false;
 
@@ -61,6 +66,7 @@ void MessageReader::OnRead(int result) {
 }
 
 void MessageReader::HandleReadResult(int result) {
+  DCHECK(CalledOnValidThread());
   if (closed_)
     return;
 
@@ -78,6 +84,7 @@ void MessageReader::HandleReadResult(int result) {
 }
 
 void MessageReader::OnDataReceived(net::IOBuffer* data, int data_size) {
+  DCHECK(CalledOnValidThread());
   message_decoder_.AddData(data, data_size);
 
   // Get list of all new messages first, and then call the callback
@@ -96,27 +103,18 @@ void MessageReader::OnDataReceived(net::IOBuffer* data, int data_size) {
        it != new_messages.end(); ++it) {
     message_received_callback_.Run(
         scoped_ptr<CompoundBuffer>(*it),
-        base::Bind(&MessageReader::OnMessageDone, this,
-                   base::ThreadTaskRunnerHandle::Get()));
+        base::Bind(&MessageReader::OnMessageDone,
+                   weak_factory_.GetWeakPtr()));
   }
 }
 
-void MessageReader::OnMessageDone(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  if (task_runner->BelongsToCurrentThread()) {
-    ProcessDoneEvent();
-  } else {
-    task_runner->PostTask(
-        FROM_HERE, base::Bind(&MessageReader::ProcessDoneEvent, this));
-  }
-}
-
-void MessageReader::ProcessDoneEvent() {
+void MessageReader::OnMessageDone() {
+  DCHECK(CalledOnValidThread());
   pending_messages_--;
   DCHECK_GE(pending_messages_, 0);
 
   if (!read_pending_)
-    DoRead();  // Start next read if neccessary.
+    DoRead();  // Start next read if necessary.
 }
 
 }  // namespace protocol