mojo/public/cpp/bindings/lib/interface_ptr_internal.h

   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 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_INTERFACE_PTR_INTERNAL_H_
   6 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_INTERFACE_PTR_INTERNAL_H_
   7
   8 #include <algorithm>  // For |std::swap()|.
   9
  10 #include "mojo/public/cpp/bindings/lib/filter_chain.h"
  11 #include "mojo/public/cpp/bindings/lib/message_header_validator.h"
  12 #include "mojo/public/cpp/bindings/lib/router.h"
  13 #include "mojo/public/cpp/environment/logging.h"
  14
  15 struct MojoAsyncWaiter;
  16
  17 namespace mojo {
  18 namespace internal {
  19
  20 template <typename Interface>
  21 class InterfacePtrState {
  22  public:
  23   InterfacePtrState() : proxy_(NULL), router_(NULL), waiter_(NULL) {}
  24
  25   ~InterfacePtrState() {
  26     // Destruction order matters here. We delete |proxy_| first, even though
  27     // |router_| may have a reference to it, so that |~Interface| may have a
  28     // shot at generating new outbound messages (ie, invoking client methods).
  29     delete proxy_;
  30     delete router_;
  31   }
  32
  33   Interface* instance() {
  34     ConfigureProxyIfNecessary();
  35
  36     // This will be NULL if the object is not bound.
  37     return proxy_;
  38   }
  39
  40   void Swap(InterfacePtrState* other) {
  41     std::swap(other->proxy_, proxy_);
  42     std::swap(other->router_, router_);
  43     handle_.swap(other->handle_);
  44     std::swap(other->waiter_, waiter_);
  45   }
  46
  47   void Bind(ScopedMessagePipeHandle handle, const MojoAsyncWaiter* waiter) {
  48     MOJO_DCHECK(!proxy_);
  49     MOJO_DCHECK(!router_);
  50     MOJO_DCHECK(!handle_.is_valid());
  51     MOJO_DCHECK(!waiter_);
  52
  53     handle_ = handle.Pass();
  54     waiter_ = waiter;
  55   }
  56
  57   bool WaitForIncomingMethodCall() {
  58     ConfigureProxyIfNecessary();
  59
  60     MOJO_DCHECK(router_);
  61     return router_->WaitForIncomingMessage();
  62   }
  63
  64   ScopedMessagePipeHandle PassMessagePipe() {
  65     if (router_)
  66       return router_->PassMessagePipe();
  67
  68     waiter_ = NULL;
  69     return handle_.Pass();
  70   }
  71
  72   bool is_bound() const {
  73     return handle_.is_valid() || router_;
  74   }
  75
  76   void set_client(typename Interface::Client* client) {
  77     ConfigureProxyIfNecessary();
  78
  79     MOJO_DCHECK(proxy_);
  80     proxy_->stub.set_sink(client);
  81   }
  82
  83   bool encountered_error() const {
  84     return router_ ? router_->encountered_error() : false;
  85   }
  86
  87   void set_error_handler(ErrorHandler* error_handler) {
  88     ConfigureProxyIfNecessary();
  89
  90     MOJO_DCHECK(router_);
  91     router_->set_error_handler(error_handler);
  92   }
  93
  94   Router* router_for_testing() {
  95     ConfigureProxyIfNecessary();
  96     return router_;
  97   }
  98
  99  private:
 100   class ProxyWithStub : public Interface::Proxy_ {
 101    public:
 102     explicit ProxyWithStub(MessageReceiverWithResponder* receiver)
 103         : Interface::Proxy_(receiver) {
 104     }
 105     typename Interface::Client::Stub_ stub;
 106    private:
 107     MOJO_DISALLOW_COPY_AND_ASSIGN(ProxyWithStub);
 108   };
 109
 110   void ConfigureProxyIfNecessary() {
 111     // The proxy has been configured.
 112     if (proxy_) {
 113       MOJO_DCHECK(router_);
 114       return;
 115     }
 116     // The object hasn't been bound.
 117     if (!waiter_) {
 118       MOJO_DCHECK(!handle_.is_valid());
 119       return;
 120     }
 121
 122     FilterChain filters;
 123     filters.Append<MessageHeaderValidator>();
 124     filters.Append<typename Interface::Client::RequestValidator_>();
 125     filters.Append<typename Interface::ResponseValidator_>();
 126
 127     router_ = new Router(handle_.Pass(), filters.Pass(), waiter_);
 128     waiter_ = NULL;
 129
 130     ProxyWithStub* proxy = new ProxyWithStub(router_);
 131     router_->set_incoming_receiver(&proxy->stub);
 132
 133     proxy_ = proxy;
 134   }
 135
 136   ProxyWithStub* proxy_;
 137   Router* router_;
 138
 139   // |proxy_| and |router_| are not initialized until read/write with the
 140   // message pipe handle is needed. Before that, |handle_| and |waiter_| store
 141   // the arguments of Bind().
 142   ScopedMessagePipeHandle handle_;
 143   const MojoAsyncWaiter* waiter_;
 144
 145   MOJO_DISALLOW_COPY_AND_ASSIGN(InterfacePtrState);
 146 };
 147
 148 }  // namespace internal
 149 }  // namespace mojo
 150
 151 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_INTERFACE_PTR_INTERNAL_H_