Make new TaskRunner, SequencedTaskRunner, and SingleThreadTaskRunner interfaces

base/message_loop_proxy.h

 // 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 BASE_MESSAGE_LOOP_PROXY_H_
 #define BASE_MESSAGE_LOOP_PROXY_H_
 #pragma once
 
 #include "base/base_export.h"
-#include "base/basictypes.h"
-#include "base/callback_forward.h"
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop_helpers.h"
-
-namespace tracked_objects {
-class Location;
-} // namespace tracked_objects
+#include "base/single_thread_task_runner.h"
 
 namespace base {
 
-struct MessageLoopProxyTraits;
-
 // This class provides a thread-safe refcounted interface to the Post* methods
 // of a message loop. This class can outlive the target message loop.
 // MessageLoopProxy objects are constructed automatically for all MessageLoops.
 // So, to access them, you can use any of the following:
 //   Thread::message_loop_proxy()
 //   MessageLoop::current()->message_loop_proxy()
 //   MessageLoopProxy::current()
-class BASE_EXPORT MessageLoopProxy
-    : public base::RefCountedThreadSafe<MessageLoopProxy,
-                                        MessageLoopProxyTraits> {
+//
+// TODO(akalin): Now that we have the *TaskRunner interfaces, we can
+// merge this with MessageLoopProxyImpl.
+class BASE_EXPORT MessageLoopProxy : public SingleThreadTaskRunner {
  public:
-  // These methods are the same as in message_loop.h, but are guaranteed to
-  // either post the Task to the MessageLoop (if it's still alive), or the task
-  // is discarded.
-  // They return true iff the thread existed and the task was posted.  Note that
-  // even if the task is posted, there's no guarantee that it will run; for
-  // example the target loop may already be quitting, or in the case of a
-  // delayed task a Quit message may preempt it in the message loop queue.
-  // Conversely, a return value of false is a guarantee the task will not run.
-  virtual bool PostTask(const tracked_objects::Location& from_here,
-                        const base::Closure& task) = 0;
-  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
-                               const base::Closure& task,
-                               int64 delay_ms) = 0;
-  virtual bool PostNonNestableTask(const tracked_objects::Location& from_here,
-                                   const base::Closure& task) = 0;
-  virtual bool PostNonNestableDelayedTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task,
-      int64 delay_ms) = 0;
-
-  // A method which checks if the caller is currently running in the thread that
-  // this proxy represents.
-  virtual bool BelongsToCurrentThread() = 0;
-
-  // Executes |task| on the given MessageLoopProxy.  On completion, |reply|
-  // is passed back to the MessageLoopProxy for the thread that called
-  // PostTaskAndReply().  Both |task| and |reply| are guaranteed to be deleted
-  // on the thread from which PostTaskAndReply() is invoked.  This allows
-  // objects that must be deleted on the originating thread to be bound into the
-  // |task| and |reply| Closures.  In particular, it can be useful to use
-  // WeakPtr<> in the |reply| Closure so that the reply operation can be
-  // canceled. See the following pseudo-code:
-  //
-  // class DataBuffer : public RefCountedThreadSafe<DataBuffer> {
-  //  public:
-  //   // Called to add data into a buffer.
-  //   void AddData(void* buf, size_t length);
-  //   ...
-  // };
-  //
-  //
-  // class DataLoader : public SupportsWeakPtr<DataLoader> {
-  //  public:
-  //    void GetData() {
-  //      scoped_refptr<DataBuffer> buffer = new DataBuffer();
-  //      target_thread_.message_loop_proxy()->PostTaskAndReply(
-  //          FROM_HERE,
-  //          base::Bind(&DataBuffer::AddData, buffer),
-  //          base::Bind(&DataLoader::OnDataReceived, AsWeakPtr(), buffer));
-  //    }
-  //
-  //  private:
-  //    void OnDataReceived(scoped_refptr<DataBuffer> buffer) {
-  //      // Do something with buffer.
-  //    }
-  // };
-  //
-  //
-  // Things to notice:
-  //   * Results of |task| are shared with |reply| by binding a shared argument
-  //     (a DataBuffer instance).
-  //   * The DataLoader object has no special thread safety.
-  //   * The DataLoader object can be deleted while |task| is still running,
-  //     and the reply will cancel itself safely because it is bound to a
-  //     WeakPtr<>.
-  bool PostTaskAndReply(const tracked_objects::Location& from_here,
-                        const Closure& task,
-                        const Closure& reply);
-
-  template <class T>
-  bool DeleteSoon(const tracked_objects::Location& from_here,
-                  const T* object) {
-    return subtle::DeleteHelperInternal<T, bool>::DeleteOnMessageLoop(
-        this, from_here, object);
-  }
-  template <class T>
-  bool ReleaseSoon(const tracked_objects::Location& from_here,
-                   T* object) {
-    return subtle::ReleaseHelperInternal<T, bool>::ReleaseOnMessageLoop(
-        this, from_here, object);
-  }
-
   // Gets the MessageLoopProxy for the current message loop, creating one if
   // needed.
   static scoped_refptr<MessageLoopProxy> current();
 
  protected:
-  friend class RefCountedThreadSafe<MessageLoopProxy, MessageLoopProxyTraits>;
-  friend struct MessageLoopProxyTraits;
-
   MessageLoopProxy();
   virtual ~MessageLoopProxy();
-
-  // Called when the proxy is about to be deleted. Subclasses can override this
-  // to provide deletion on specific threads.
-  virtual void OnDestruct() const;
-
- private:
-  template <class T, class R> friend class subtle::DeleteHelperInternal;
-  template <class T, class R> friend class subtle::ReleaseHelperInternal;
-  bool DeleteSoonInternal(const tracked_objects::Location& from_here,
-                          void(*deleter)(const void*),
-                          const void* object);
-  bool ReleaseSoonInternal(const tracked_objects::Location& from_here,
-                           void(*releaser)(const void*),
-                           const void* object);
-};
-
-struct MessageLoopProxyTraits {
-  static void Destruct(const MessageLoopProxy* proxy) {
-    proxy->OnDestruct();
-  }
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_PROXY_H_