mojo/public/cpp/bindings/lib/router.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/public/cpp/bindings/lib/router.h"
   6
   7 #include "mojo/public/cpp/environment/logging.h"
   8
   9 namespace mojo {
  10 namespace internal {
  11
  12 // ----------------------------------------------------------------------------
  13
  14 class ResponderThunk : public MessageReceiver {
  15  public:
  16   explicit ResponderThunk(const SharedData<Router*>& router)
  17       : router_(router) {}
  18   ~ResponderThunk() override {}
  19
  20   // MessageReceiver implementation:
  21   bool Accept(Message* message) override {
  22     MOJO_DCHECK(message->has_flag(kMessageIsResponse));
  23
  24     bool result = false;
  25
  26     Router* router = router_.value();
  27     if (router)
  28       result = router->Accept(message);
  29
  30     return result;
  31   }
  32
  33  private:
  34   SharedData<Router*> router_;
  35 };
  36
  37 // ----------------------------------------------------------------------------
  38
  39 Router::HandleIncomingMessageThunk::HandleIncomingMessageThunk(Router* router)
  40     : router_(router) {
  41 }
  42
  43 Router::HandleIncomingMessageThunk::~HandleIncomingMessageThunk() {
  44 }
  45
  46 bool Router::HandleIncomingMessageThunk::Accept(Message* message) {
  47   return router_->HandleIncomingMessage(message);
  48 }
  49
  50 // ----------------------------------------------------------------------------
  51
  52 Router::Router(ScopedMessagePipeHandle message_pipe,
  53                FilterChain filters,
  54                const MojoAsyncWaiter* waiter)
  55     : thunk_(this),
  56       filters_(filters.Pass()),
  57       connector_(message_pipe.Pass(), waiter),
  58       weak_self_(this),
  59       incoming_receiver_(nullptr),
  60       next_request_id_(0),
  61       testing_mode_(false) {
  62   filters_.SetSink(&thunk_);
  63   connector_.set_incoming_receiver(filters_.GetHead());
  64 }
  65
  66 Router::~Router() {
  67   weak_self_.set_value(nullptr);
  68
  69   for (ResponderMap::const_iterator i = responders_.begin();
  70        i != responders_.end();
  71        ++i) {
  72     delete i->second;
  73   }
  74 }
  75
  76 bool Router::Accept(Message* message) {
  77   MOJO_DCHECK(!message->has_flag(kMessageExpectsResponse));
  78   return connector_.Accept(message);
  79 }
  80
  81 bool Router::AcceptWithResponder(Message* message, MessageReceiver* responder) {
  82   MOJO_DCHECK(message->has_flag(kMessageExpectsResponse));
  83
  84   // Reserve 0 in case we want it to convey special meaning in the future.
  85   uint64_t request_id = next_request_id_++;
  86   if (request_id == 0)
  87     request_id = next_request_id_++;
  88
  89   message->set_request_id(request_id);
  90   if (!connector_.Accept(message))
  91     return false;
  92
  93   // We assume ownership of |responder|.
  94   responders_[request_id] = responder;
  95   return true;
  96 }
  97
  98 void Router::EnableTestingMode() {
  99   testing_mode_ = true;
 100   connector_.set_enforce_errors_from_incoming_receiver(false);
 101 }
 102
 103 bool Router::HandleIncomingMessage(Message* message) {
 104   if (message->has_flag(kMessageExpectsResponse)) {
 105     if (incoming_receiver_) {
 106       MessageReceiver* responder = new ResponderThunk(weak_self_);
 107       bool ok = incoming_receiver_->AcceptWithResponder(message, responder);
 108       if (!ok)
 109         delete responder;
 110       return ok;
 111     }
 112
 113     // If we receive a request expecting a response when the client is not
 114     // listening, then we have no choice but to tear down the pipe.
 115     connector_.CloseMessagePipe();
 116   } else if (message->has_flag(kMessageIsResponse)) {
 117     uint64_t request_id = message->request_id();
 118     ResponderMap::iterator it = responders_.find(request_id);
 119     if (it == responders_.end()) {
 120       MOJO_DCHECK(testing_mode_);
 121       return false;
 122     }
 123     MessageReceiver* responder = it->second;
 124     responders_.erase(it);
 125     bool ok = responder->Accept(message);
 126     delete responder;
 127     return ok;
 128   } else {
 129     if (incoming_receiver_)
 130       return incoming_receiver_->Accept(message);
 131     // OK to drop message on the floor.
 132   }
 133
 134   return false;
 135 }
 136
 137 // ----------------------------------------------------------------------------
 138
 139 }  // namespace internal
 140 }  // namespace mojo