1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
// Copyright 2015 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 MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_BINDING_H_
#define MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_BINDING_H_
#include <memory>
#include <string>
#include <utility>
#include "base/bind.h"
#include "base/callback.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread_task_runner_handle.h"
#include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
#include "mojo/public/cpp/bindings/associated_interface_request.h"
#include "mojo/public/cpp/bindings/bindings_export.h"
#include "mojo/public/cpp/bindings/connection_error_callback.h"
#include "mojo/public/cpp/bindings/interface_endpoint_client.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"
#include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
namespace mojo {
class MessageReceiver;
// Base class used to factor out code in AssociatedBinding<T> expansions, in
// particular for Bind().
class MOJO_CPP_BINDINGS_EXPORT AssociatedBindingBase {
public:
AssociatedBindingBase();
~AssociatedBindingBase();
// Adds a message filter to be notified of each incoming message before
// dispatch. If a filter returns |false| from Accept(), the message is not
// dispatched and the pipe is closed. Filters cannot be removed.
void AddFilter(std::unique_ptr<MessageReceiver> filter);
// Closes the associated interface. Puts this object into a state where it can
// be rebound.
void Close();
// Similar to the method above, but also specifies a disconnect reason.
void CloseWithReason(uint32_t custom_reason, const std::string& description);
// Sets an error handler that will be called if a connection error occurs.
//
// This method may only be called after this AssociatedBinding has been bound
// to a message pipe. The error handler will be reset when this
// AssociatedBinding is unbound or closed.
void set_connection_error_handler(const base::Closure& error_handler);
void set_connection_error_with_reason_handler(
const ConnectionErrorWithReasonCallback& error_handler);
// Indicates whether the associated binding has been completed.
bool is_bound() const { return !!endpoint_client_; }
// Sends a message on the underlying message pipe and runs the current
// message loop until its response is received. This can be used in tests to
// verify that no message was sent on a message pipe in response to some
// stimulus.
void FlushForTesting();
protected:
void BindImpl(ScopedInterfaceEndpointHandle handle,
MessageReceiverWithResponderStatus* receiver,
std::unique_ptr<MessageReceiver> payload_validator,
bool expect_sync_requests,
scoped_refptr<base::SingleThreadTaskRunner> runner,
uint32_t interface_version);
std::unique_ptr<InterfaceEndpointClient> endpoint_client_;
};
// Represents the implementation side of an associated interface. It is similar
// to Binding, except that it doesn't own a message pipe handle.
//
// When you bind this class to a request, optionally you can specify a
// base::SingleThreadTaskRunner. This task runner must belong to the same
// thread. It will be used to dispatch incoming method calls and connection
// error notification. It is useful when you attach multiple task runners to a
// single thread for the purposes of task scheduling. Please note that incoming
// synchrounous method calls may not be run from this task runner, when they
// reenter outgoing synchrounous calls on the same thread.
template <typename Interface,
typename ImplRefTraits = RawPtrImplRefTraits<Interface>>
class AssociatedBinding : public AssociatedBindingBase {
public:
using ImplPointerType = typename ImplRefTraits::PointerType;
// Constructs an incomplete associated binding that will use the
// implementation |impl|. It may be completed with a subsequent call to the
// |Bind| method. Does not take ownership of |impl|, which must outlive this
// object.
explicit AssociatedBinding(ImplPointerType impl) { stub_.set_sink(impl); }
// Constructs a completed associated binding of |impl|. The output |ptr_info|
// should be sent by another interface. |impl| must outlive this object.
AssociatedBinding(ImplPointerType impl,
AssociatedInterfacePtrInfo<Interface>* ptr_info,
scoped_refptr<base::SingleThreadTaskRunner> runner =
base::ThreadTaskRunnerHandle::Get())
: AssociatedBinding(std::move(impl)) {
Bind(ptr_info, std::move(runner));
}
// Constructs a completed associated binding of |impl|. |impl| must outlive
// the binding.
AssociatedBinding(ImplPointerType impl,
AssociatedInterfaceRequest<Interface> request,
scoped_refptr<base::SingleThreadTaskRunner> runner =
base::ThreadTaskRunnerHandle::Get())
: AssociatedBinding(std::move(impl)) {
Bind(std::move(request), std::move(runner));
}
~AssociatedBinding() {}
// Creates an associated inteface and sets up this object as the
// implementation side. The output |ptr_info| should be sent by another
// interface.
void Bind(AssociatedInterfacePtrInfo<Interface>* ptr_info,
scoped_refptr<base::SingleThreadTaskRunner> runner =
base::ThreadTaskRunnerHandle::Get()) {
auto request = MakeRequest(ptr_info);
ptr_info->set_version(Interface::Version_);
Bind(std::move(request), std::move(runner));
}
// Sets up this object as the implementation side of an associated interface.
void Bind(AssociatedInterfaceRequest<Interface> request,
scoped_refptr<base::SingleThreadTaskRunner> runner =
base::ThreadTaskRunnerHandle::Get()) {
BindImpl(request.PassHandle(), &stub_,
base::WrapUnique(new typename Interface::RequestValidator_()),
Interface::HasSyncMethods_, std::move(runner),
Interface::Version_);
}
// Unbinds and returns the associated interface request so it can be
// used in another context, such as on another thread or with a different
// implementation. Puts this object into a state where it can be rebound.
AssociatedInterfaceRequest<Interface> Unbind() {
DCHECK(endpoint_client_);
AssociatedInterfaceRequest<Interface> request;
request.Bind(endpoint_client_->PassHandle());
endpoint_client_.reset();
return request;
}
// Returns the interface implementation that was previously specified.
Interface* impl() { return ImplRefTraits::GetRawPointer(&stub_.sink()); }
private:
typename Interface::template Stub_<ImplRefTraits> stub_;
DISALLOW_COPY_AND_ASSIGN(AssociatedBinding);
};
} // namespace mojo
#endif // MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_BINDING_H_
|
