Created a stock implementation of the MessageLoopProxy interface than can be ...

base/message_loop_proxy_impl.cc

+// 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.
+
+#include "base/message_loop_proxy_impl.h"
+
+namespace base {
+
+MessageLoopProxyImpl::MessageLoopProxyImpl()
+    : target_message_loop_(MessageLoop::current()) {
+  target_message_loop_->AddDestructionObserver(this);
+}
+
+MessageLoopProxyImpl::~MessageLoopProxyImpl() {
+  AutoLock lock(message_loop_lock_);
+  // If the target message loop still exists, the d'tor WILL execute on the
+  // target loop.
+  if (target_message_loop_) {
+    DCHECK(MessageLoop::current() == target_message_loop_);
+    MessageLoop::current()->RemoveDestructionObserver(this);
+  }
+}
+
+  // MessageLoopProxy implementation
+bool MessageLoopProxyImpl::PostTask(const tracked_objects::Location& from_here,
+                                    Task* task) {
+  return PostTaskHelper(from_here, task, 0, true);
+}
+
+bool MessageLoopProxyImpl::PostDelayedTask(
+    const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
+  return PostTaskHelper(from_here, task, delay_ms, true);
+}
+
+bool MessageLoopProxyImpl::PostNonNestableTask(
+    const tracked_objects::Location& from_here, Task* task) {
+  return PostTaskHelper(from_here, task, 0, false);
+}
+
+bool MessageLoopProxyImpl::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    Task* task,
+    int64 delay_ms) {
+  return PostTaskHelper(from_here, task, delay_ms, false);
+}
+
+bool MessageLoopProxyImpl::BelongsToCurrentThread() {
+  AutoLock lock(message_loop_lock_);
+  return (target_message_loop_ &&
+          (MessageLoop::current() == target_message_loop_));
+}
+
+bool MessageLoopProxyImpl::PostTaskHelper(
+    const tracked_objects::Location& from_here, Task* task, int64 delay_ms,
+    bool nestable) {
+  bool ret = false;
+  {
+    AutoLock lock(message_loop_lock_);
+    if (target_message_loop_) {
+      if (nestable) {
+        target_message_loop_->PostDelayedTask(from_here, task, delay_ms);
+      } else {
+        target_message_loop_->PostNonNestableDelayedTask(from_here, task,
+                                                         delay_ms);
+      }
+      ret = true;
+    }
+  }
+  if (!ret)
+    delete task;
+  return ret;
+}
+
+void MessageLoopProxyImpl::OnDestruct() {
+  bool delete_later = false;
+  {
+    AutoLock lock(message_loop_lock_);
+    if (target_message_loop_ &&
+        (MessageLoop::current() != target_message_loop_)) {
+      target_message_loop_->DeleteSoon(FROM_HERE, this);
+      delete_later = true;
+    }
+  }
+  if (!delete_later)
+    delete this;
+}
+
+// MessageLoop::DestructionObserver implementation
+void MessageLoopProxyImpl::WillDestroyCurrentMessageLoop() {
+  AutoLock lock(message_loop_lock_);
+  target_message_loop_ = NULL;
+}
+
+scoped_refptr<MessageLoopProxy>
+MessageLoopProxy::CreateForCurrentThread() {
+  scoped_refptr<MessageLoopProxy> ret = new MessageLoopProxyImpl();
+  return ret;
+}
+
+}  // namespace base
+