1 files changed, 86 insertions, 0 deletions
diff --git a/remoting/base/scoped_thread_proxy.cc b/remoting/base/scoped_thread_proxy.cc
new file mode 100644
index 0000000..d1dcc26
--- /dev/null
+++ b/remoting/base/scoped_thread_proxy.cc
@@ -0,0 +1,86 @@
+// 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/base/scoped_thread_proxy.h"
+
+#include "base/bind.h"
+
+namespace remoting {
+
+class ScopedThreadProxy::Core : public base::RefCountedThreadSafe<Core> {
+ public:
+  Core(base::MessageLoopProxy* message_loop)
+      : message_loop_(message_loop),
+        canceled_(false) {
+  }
+
+  void PostTask(const tracked_objects::Location& from_here,
+                const base::Closure& closure) {
+    if (!canceled_)
+      message_loop_->PostTask(from_here, Wrap(closure));
+  }
+
+  void PostDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& closure,
+      int64 delay_ms) {
+    if (!canceled_) {
+      message_loop_->PostDelayedTask(from_here, Wrap(closure), delay_ms);
+    }
+  }
+
+  void Detach() {
+    DCHECK(message_loop_->BelongsToCurrentThread());
+    canceled_ = true;
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<Core>;
+
+  ~Core() {
+    DCHECK(canceled_);
+  }
+
+  base::Closure Wrap(const base::Closure& closure) {
+    return base::Bind(&Core::CallClosure, this, closure);
+  }
+
+  void CallClosure(const base::Closure& closure) {
+    DCHECK(message_loop_->BelongsToCurrentThread());
+
+    if (!canceled_)
+      closure.Run();
+  }
+
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
+  bool canceled_;
+
+  DISALLOW_COPY_AND_ASSIGN(Core);
+};
+
+ScopedThreadProxy::ScopedThreadProxy(base::MessageLoopProxy* message_loop)
+    : core_(new Core(message_loop)) {
+}
+
+ScopedThreadProxy::~ScopedThreadProxy() {
+  Detach();
+}
+
+void ScopedThreadProxy::PostTask(const tracked_objects::Location& from_here,
+                                 const base::Closure& closure) {
+  core_->PostTask(from_here, closure);
+}
+
+void ScopedThreadProxy::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& closure,
+    int64 delay_ms) {
+  core_->PostDelayedTask(from_here, closure, delay_ms);
+}
+
+void ScopedThreadProxy::Detach() {
+  core_->Detach();
+}
+
+}  // namespace remoting