Home | History | Annotate | Download | only in base 
      1 /*
      2  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 #ifndef WEBRTC_BASE_MESSAGEHANDLER_H_
     12 #define WEBRTC_BASE_MESSAGEHANDLER_H_
     13 
     14 #include <utility>
     15 
     16 #include "webrtc/base/constructormagic.h"
     17 #include "webrtc/base/scoped_ptr.h"
     18 
     19 namespace rtc {
     20 
     21 struct Message;
     22 
     23 // Messages get dispatched to a MessageHandler
     24 
     25 class MessageHandler {
     26  public:
     27   virtual ~MessageHandler();
     28   virtual void OnMessage(Message* msg) = 0;
     29 
     30  protected:
     31   MessageHandler() {}
     32 
     33  private:
     34   RTC_DISALLOW_COPY_AND_ASSIGN(MessageHandler);
     35 };
     36 
     37 // Helper class to facilitate executing a functor on a thread.
     38 template <class ReturnT, class FunctorT>
     39 class FunctorMessageHandler : public MessageHandler {
     40  public:
     41   explicit FunctorMessageHandler(const FunctorT& functor)
     42       : functor_(functor) {}
     43   virtual void OnMessage(Message* msg) {
     44     result_ = functor_();
     45   }
     46   const ReturnT& result() const { return result_; }
     47 
     48  private:
     49   FunctorT functor_;
     50   ReturnT result_;
     51 };
     52 
     53 // Specialization for rtc::scoped_ptr<ReturnT>.
     54 template <class ReturnT, class FunctorT>
     55 class FunctorMessageHandler<class rtc::scoped_ptr<ReturnT>, FunctorT>
     56     : public MessageHandler {
     57  public:
     58   explicit FunctorMessageHandler(const FunctorT& functor) : functor_(functor) {}
     59   virtual void OnMessage(Message* msg) { result_ = std::move(functor_()); }
     60   rtc::scoped_ptr<ReturnT> result() { return std::move(result_); }
     61 
     62  private:
     63   FunctorT functor_;
     64   rtc::scoped_ptr<ReturnT> result_;
     65 };
     66 
     67 // Specialization for ReturnT of void.
     68 template <class FunctorT>
     69 class FunctorMessageHandler<void, FunctorT> : public MessageHandler {
     70  public:
     71   explicit FunctorMessageHandler(const FunctorT& functor)
     72       : functor_(functor) {}
     73   virtual void OnMessage(Message* msg) {
     74     functor_();
     75   }
     76   void result() const {}
     77 
     78  private:
     79   FunctorT functor_;
     80 };
     81 
     82 } // namespace rtc
     83 
     84 #endif // WEBRTC_BASE_MESSAGEHANDLER_H_
     85