Make JingleThreadMessageLoop usable without JingleThread.

remoting/jingle_glue/jingle_thread.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/jingle_glue/jingle_thread.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_pump.h"
 #include "base/time.h"
 #include "third_party/libjingle/source/talk/base/ssladapter.h"
 
 namespace remoting {
 
 const uint32 kRunTasksMessageId = 1;
 const uint32 kStopMessageId = 2;
 
-class JingleThread::JingleMessagePump : public base::MessagePump,
-                                        public talk_base::MessageHandler {
+namespace {
+
+class JingleMessagePump : public base::MessagePump,
+                          public talk_base::MessageHandler {
  public:
-  JingleMessagePump(JingleThread* thread) : thread_(thread) { }
+  JingleMessagePump(talk_base::Thread* thread, MessageLoop* message_loop)
+      : thread_(thread), message_loop_(message_loop) {
+  }
 
   virtual void Run(Delegate* delegate) { NOTIMPLEMENTED(); }
   virtual void Quit() { NOTIMPLEMENTED(); }
   virtual void ScheduleWork() {
     thread_->Post(this, kRunTasksMessageId);
   }
   virtual void ScheduleDelayedWork(const base::TimeTicks& time) {
     delayed_work_time_ = time;
     ScheduleNextDelayedTask();
   }
 
   void OnMessage(talk_base::Message* msg) {
     DCHECK(msg->message_id == kRunTasksMessageId);
 
     // Clear currently pending messages in case there were delayed tasks.
     // Will schedule it again from ScheduleNextDelayedTask() if neccessary.
     thread_->Clear(this, kRunTasksMessageId);
 
     // This code is executed whenever we get new message in |message_loop_|.
     // JingleMessagePump posts new tasks in the jingle thread.
     // TODO(sergeyu): Remove it when JingleThread moved on Chromium's
     // base::Thread.
-    base::MessagePump::Delegate* delegate = thread_->message_loop();
+    base::MessagePump::Delegate* delegate = message_loop_;
     // Process all pending tasks.
     while (true) {
       if (delegate->DoWork())
         continue;
       if (delegate->DoDelayedWork(&delayed_work_time_))
         continue;
       break;
     }
 
     ScheduleNextDelayedTask();
   }
 
  private:
   void ScheduleNextDelayedTask() {
-    DCHECK_EQ(thread_->message_loop(), MessageLoop::current());
+    DCHECK_EQ(message_loop_, MessageLoop::current());
 
     if (!delayed_work_time_.is_null()) {
       base::TimeTicks now = base::TimeTicks::Now();
       int delay = static_cast<int>((delayed_work_time_ - now).InMilliseconds());
       if (delay > 0) {
         thread_->PostDelayed(delay, this, kRunTasksMessageId);
       } else {
         thread_->Post(this, kRunTasksMessageId);
       }
     }
   }
 
-  JingleThread* thread_;
+  talk_base::Thread* thread_;
+  MessageLoop* message_loop_;

[Wez, 2011/07/01 20:33:00]

Normally the pump is created by the relevant MessageLoop, which passes itself to
the pump's Run(), I think.  Would that layout not work here?

[Sergey Ulanov, 2011/07/01 21:14:28]

No, because nobody ever calls Run() on this Pump. MessageLoop calls
ScheduleWork() and ScheduleDelayedWork() when new tasks are posted, and then the
tasks are executed in OnMessage(). A more elegant solution would be possible if
Post() and PostDelayed() were virtual in MessageLoop, but they are not.

   base::TimeTicks delayed_work_time_;
 };
 
-class JingleThread::JingleMessageLoop : public MessageLoop {
- public:
-  JingleMessageLoop(JingleThread* thread)
-      : MessageLoop(MessageLoop::TYPE_IO) {
-    pump_ = new JingleMessagePump(thread);
-  }
+}  // namespace
 
-  void Initialize() {
-    jingle_message_loop_state_.reset(new AutoRunState(this));
-  }
+JingleThreadMessageLoop::JingleThreadMessageLoop(talk_base::Thread* thread)
+    : MessageLoop(MessageLoop::TYPE_IO) {
+  pump_ = new JingleMessagePump(thread, this);
+}
 
- private:
-  // AutoRunState sets |state_| for this message loop. It needs to be
-  // created here because we never call Run() or RunAllPending() for
-  // the thread.
-  scoped_ptr<AutoRunState> jingle_message_loop_state_;
-};
+JingleThreadMessageLoop::~JingleThreadMessageLoop() {
+}
+
+void JingleThreadMessageLoop::Initialize() {
+  jingle_message_loop_state_.reset(new AutoRunState(this));
+}
 
 TaskPump::TaskPump() {
 }
 
 void TaskPump::WakeTasks() {
   talk_base::Thread::Current()->Post(this);
 }
 
 int64 TaskPump::CurrentTime() {
   return static_cast<int64>(talk_base::Time());
 }
 
 void TaskPump::OnMessage(talk_base::Message* pmsg) {
   RunTasks();
 }

[Wez, 2011/07/01 20:33:00]

Sorry, I'm not clear on what TaskPump is actually for, here?

[Sergey Ulanov, 2011/07/01 21:14:28]

It's an implementation of talk_base::TaskRunner that we need to run XMPP code.

[Wez, 2011/07/01 21:49:28]

Yes, what I was really asking is that, given it's the "obvious" implementation,
is it even required?  Does talk_base not already have a TaskRunner
implementation of this sort?

[Sergey Ulanov, 2011/07/01 22:40:54]

There is no default implementation of TaskRunner in libjingle. I don't know the
reason for that.

 
 JingleThread::JingleThread()
     : task_pump_(NULL),
       started_event_(true, false),
       stopped_event_(true, false),
       message_loop_(NULL) {
 }
 
 JingleThread::~JingleThread() { }
 
 void JingleThread::Start() {
   Thread::Start();
   started_event_.Wait();
 }
 
 void JingleThread::Run() {
-  JingleMessageLoop message_loop(this);
+  JingleThreadMessageLoop message_loop(this);
   message_loop.Initialize();
   message_loop_ = &message_loop;
 
   TaskPump task_pump;
   task_pump_ = &task_pump;
 
   // Signal after we've initialized |message_loop_| and |task_pump_|.
   started_event_.Signal();
 
   Thread::Run();
@@ skipping 11 matching lines @@
   stopped_event_.Wait();
 
   // This will wait until the thread is actually finished.
   Thread::Stop();
 }
 
 MessageLoop* JingleThread::message_loop() {
   return message_loop_;
 }
 
   // Returns task pump if the thread is running, otherwise NULL is returned.

[Wez, 2011/07/01 21:49:28]

nit: This comment is already present in the header.

[Sergey Ulanov, 2011/07/01 22:40:54]

Done.

 TaskPump* JingleThread::task_pump() {

[Wez, 2011/07/01 21:49:28]

nit: Presumably this is only callable from the JingleThread itself?

[Sergey Ulanov, 2011/07/01 22:40:54]

No, XmppSignalStrategy calls it.

   return task_pump_;
 }
 
 void JingleThread::OnMessage(talk_base::Message* msg) {
   DCHECK(msg->message_id == kStopMessageId);
 
   // Stop the thread only if there are no more messages left in the queue,
   // otherwise post another task to try again later.
   if (!msgq_.empty() || fPeekKeep_) {
     Post(this, kStopMessageId);
   } else {
     MessageQueue::Quit();
   }
 }
 
 }  // namespace remoting