Revert 139623 - Replace ScopedThreadProxy with MessageLoopProxy & WeakPtrs.

This affects the following classes:
* ChromotingClient
* ChromotingInstance
* HostUserInterface
* It2MeHostUserInterface

The MessageLoopProxy/WeakPtr combination requires that the WeakPtr is created on the thread referred to by the proxy; code in which that is hard to arrange usually has subtle race-conditions.

TEST=Existing unit-tests, and manual testing.


Review URL: https://chromiumcodereview.appspot.com/10454040

TBR=wez@chromium.org
Review URL: https://chromiumcodereview.appspot.com/10446088

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@139633 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 159 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
diff --git a/remoting/base/scoped_thread_proxy.h b/remoting/base/scoped_thread_proxy.h
new file mode 100644
index 0000000..9e43a15
--- /dev/null
+++ b/remoting/base/scoped_thread_proxy.h
@@ -0,0 +1,73 @@
+// Copyright (c) 2012 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.
+
+#ifndef REMOTING_BASE_SCOPED_THREAD_PROXY_H_
+#define REMOTING_BASE_SCOPED_THREAD_PROXY_H_
+
+#include "base/callback_forward.h"
+#include "base/message_loop_proxy.h"
+
+namespace remoting {
+
+// ScopedThreadProxy is proxy for message loops that cancels all
+// pending tasks when it is destroyed. It can be used to post tasks
+// for a non-refcounted object. Must be deleted on the thread it
+// belongs to.
+//
+//
+// The main difference from WeakPtr<> is that this class can be used safely to
+// post tasks from different threads.
+// It is similar to WeakHandle<> used in sync: the main difference is
+// that WeakHandle<> creates closures itself, while ScopedThreadProxy
+// accepts base::Closure instances which caller needs to create using
+// base::Bind().
+//
+// TODO(sergeyu): Potentially we could use WeakHandle<> instead of
+// this class. Consider migrating to WeakHandle<> when it is moved to
+// src/base and support for delayed tasks is implemented.
+//
+// Usage:
+//   class MyClass {
+//    public:
+//     MyClass()
+//         : thread_proxy_(base::MessageLoopProxy::current()) {}
+//
+//     // Always called on the thread on which this object was created.
+//     void NonThreadSafeMethod() {}
+//
+//     // Can be called on any thread.
+//     void ThreadSafeMethod() {
+//       thread_proxy_.PostTask(FROM_HERE, base::Bind(
+//           &MyClass::NonThreadSafeMethod, base::Unretained(this)));
+//     }
+//
+//    private:
+//     ScopedThreadProxy thread_proxy_;
+//   };
+class ScopedThreadProxy {
+ public:
+  ScopedThreadProxy(base::MessageLoopProxy* message_loop);
+  ~ScopedThreadProxy();
+
+  void PostTask(const tracked_objects::Location& from_here,
+                const base::Closure& closure);
+  void PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& closure,
+                       int64 delay_ms);
+
+  // Cancels all tasks posted via this proxy. Must be called on the
+  // thread this object belongs to.
+  void Detach();
+
+ private:
+  class Core;
+
+  scoped_refptr<Core> core_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedThreadProxy);
+};
+
+}  // namespace remoting
+
+#endif  // REMOTING_BASE_SCOPED_THREAD_PROXY_H_