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_IMPL_INTERNAL_H_ 6 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_INTERFACE_IMPL_INTERNAL_H_ 7 8 #include "mojo/public/cpp/bindings/error_handler.h" 9 #include "mojo/public/cpp/bindings/interface_ptr.h" 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/environment/environment.h" 13 #include "mojo/public/cpp/environment/logging.h" 14 #include "mojo/public/cpp/system/macros.h" 15 16 namespace mojo { 17 namespace internal { 18 19 template <typename Interface> 20 class InterfaceImplBase : public Interface { 21 public: 22 virtual ~InterfaceImplBase() {} 23 virtual void OnConnectionEstablished() = 0; 24 virtual void OnConnectionError() = 0; 25 }; 26 27 template <typename Interface> 28 class InterfaceImplState : public ErrorHandler { 29 public: 30 typedef typename Interface::Client Client; 31 32 explicit InterfaceImplState(InterfaceImplBase<Interface>* instance) 33 : router_(NULL), 34 proxy_(NULL), 35 instance_bound_to_pipe_(false) 36 #ifndef NDEBUG 37 , 38 deleting_instance_due_to_error_(false) 39 #endif 40 { 41 MOJO_DCHECK(instance); 42 stub_.set_sink(instance); 43 } 44 45 virtual ~InterfaceImplState() { 46 #ifndef NDEBUG 47 MOJO_DCHECK(!instance_bound_to_pipe_ || deleting_instance_due_to_error_); 48 #endif 49 delete proxy_; 50 if (router_) { 51 router_->set_error_handler(NULL); 52 delete router_; 53 } 54 } 55 56 void BindProxy( 57 InterfacePtr<Interface>* ptr, 58 bool instance_bound_to_pipe, 59 const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) { 60 MessagePipe pipe; 61 ptr->Bind(pipe.handle0.Pass(), waiter); 62 Bind(pipe.handle1.Pass(), instance_bound_to_pipe, waiter); 63 } 64 65 void Bind(ScopedMessagePipeHandle handle, 66 bool instance_bound_to_pipe, 67 const MojoAsyncWaiter* waiter) { 68 MOJO_CHECK(!router_); 69 70 FilterChain filters; 71 filters.Append<MessageHeaderValidator>(); 72 filters.Append<typename Interface::RequestValidator_>(); 73 filters.Append<typename Interface::Client::ResponseValidator_>(); 74 75 router_ = new Router(handle.Pass(), filters.Pass(), waiter); 76 router_->set_incoming_receiver(&stub_); 77 router_->set_error_handler(this); 78 79 proxy_ = new typename Client::Proxy_(router_); 80 81 instance_bound_to_pipe_ = instance_bound_to_pipe; 82 83 instance()->OnConnectionEstablished(); 84 } 85 86 bool WaitForIncomingMethodCall() { 87 MOJO_DCHECK(router_); 88 return router_->WaitForIncomingMessage(); 89 } 90 91 Router* router() { return router_; } 92 Client* client() { return proxy_; } 93 94 private: 95 InterfaceImplBase<Interface>* instance() { 96 return static_cast<InterfaceImplBase<Interface>*>(stub_.sink()); 97 } 98 99 virtual void OnConnectionError() MOJO_OVERRIDE { 100 // If the the instance is not bound to the pipe, the instance might choose 101 // to delete itself in the OnConnectionError handler, which would in turn 102 // delete this. Save the error behavior before invoking the error handler 103 // so we can correctly decide what to do. 104 bool bound = instance_bound_to_pipe_; 105 instance()->OnConnectionError(); 106 if (!bound) 107 return; 108 #ifndef NDEBUG 109 deleting_instance_due_to_error_ = true; 110 #endif 111 delete instance(); 112 } 113 114 Router* router_; 115 typename Client::Proxy_* proxy_; 116 typename Interface::Stub_ stub_; 117 bool instance_bound_to_pipe_; 118 #ifndef NDEBUG 119 bool deleting_instance_due_to_error_; 120 #endif 121 122 MOJO_DISALLOW_COPY_AND_ASSIGN(InterfaceImplState); 123 }; 124 125 } // namespace internal 126 } // namespace mojo 127 128 #endif // MOJO_PUBLIC_CPP_BINDINGS_LIB_INTERFACE_IMPL_INTERNAL_H_ 129