Changed MessageReader so that it doesn't read from the socket if there are

remoting/protocol/ref_counted_task.h

 // Copyright (c) 2010 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.
 
 // This is a wrapper class to help ref-counting a protobuf message.
 // This file should only be inclued on host_message_dispatcher.cc and
 // client_message_dispatche.cc.
 
 // A single protobuf can contain multiple messages that will be handled by
 // different message handlers.  We use this wrapper to ensure that the
-// protobuf is only deleted after all the handlers have finished executing.
+// done_task is only called after all the handlers have finished executing.
 
 #ifndef REMOTING_PROTOCOL_REF_COUNTED_MESSAGE_H_
 #define REMOTING_PROTOCOL_REF_COUNTED_MESSAGE_H_
 
 #include "base/ref_counted.h"
 #include "base/task.h"
+#include "base/scoped_ptr.h"
 
 namespace remoting {
 namespace protocol {
 
-template <typename T>
-class RefCountedMessage : public base::RefCounted<RefCountedMessage<T> > {
+class RefCountedTask : public base::RefCounted<RefCountedTask> {

[awong, 2011/01/19 02:12:48]

I'm not sure I completely agree with having this class.  If we're doing this, it
feels like we should be passing around a refcounted object.

Is there a way to join and/or cancel all the outstanding requests?  Maybe using
a ScopedRunnableMethodFactory or something?

[Sergey Ulanov, 2011/01/19 20:07:00]

ScopedRunnableMethodFactory can't be used here because it is not thread-safe,
and I don't see how it can be applicable here (or was your comment about
MessageReader::DoneTaskHandler?).

This class is just used to call a task ref count gets to zero, and then deletes
that task..

  public:
-  RefCountedMessage(T* message) : message_(message) { }
-
-  T* message() { return message_.get(); }
+  RefCountedTask(Task* task);
 
  private:
-  scoped_ptr<T> message_;
+  friend class base::RefCounted<RefCountedTask>;
+
+  virtual ~RefCountedTask();
+
+  scoped_ptr<Task> task_;
 };
 
 // Dummy methods to destroy messages.
 template <class T>
 static void DeleteMessage(scoped_refptr<T> message) { }
 
 template <class T>
 static Task* NewDeleteTask(scoped_refptr<T> message) {
   return NewRunnableFunction(&DeleteMessage<T>, message);
 }
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_REF_COUNTED_MESSAGE_H_