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
|
// Copyright (c) 2011 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 CHROME_FRAME_SYNC_MSG_REPLY_DISPATCHER_H_
#define CHROME_FRAME_SYNC_MSG_REPLY_DISPATCHER_H_
#include <deque>
#include "base/synchronization/lock.h"
#include "ipc/ipc_channel_proxy.h"
// Base class used to allow synchronous IPC messages to be sent and
// received in an asynchronous manner. To use this class add it as a filter to
// your IPC channel using ChannelProxy::AddFilter(). From then on, before
// sending a synchronous message, call SyncMessageReplyDispatcher::Push() with
// a callback and a key. This class will then handle the message response and
// will call the callback when it is received.
//
// This class is intended to be extended by classes implementing
// HandleMessageType with delegation for the messages they expect to receive in
// cases where you care about the return values of synchronous messages.
//
// Sample usage pattern:
// Define a class which inherits from SyncMessageCallContext which specifies
// the output_type tuple and has a Completed member function.
// class SampleContext
// : public SyncMessageReplyDispatcher::SyncMessageCallContext {
// public:
// typedef Tuple1<int> output_type;
// void Completed(int arg) {}
// };
//
// // Add handling for desired message types.
// class SyncMessageReplyDispatcherImpl : public SyncMessageReplyDispatcher {
// virtual bool HandleMessageType(const IPC::Message& msg,
// SyncMessageReplyDispatcher* context) {
// switch (context->message_type()) {
// case AutomationMsg_CreateExternalTab::ID:
// InvokeCallback<CreateExternalTabContext>(msg, context);
// break;
// [HANDLING FOR OTHER EXPECTED MESSAGE TYPES]
// }
// }
//
// // Add the filter
// IPC::SyncChannel channel_;
// channel_.AddFilter(new SyncMessageReplyDispatcherImpl());
//
// sync_->Push(msg, new SampleContext, this);
// channel_->ChannelProxy::Send(msg);
//
class SyncMessageReplyDispatcher : public IPC::ChannelProxy::MessageFilter {
public:
class SyncMessageCallContext {
public:
SyncMessageCallContext()
: id_(0),
message_type_(0),
key_(NULL) {}
virtual ~SyncMessageCallContext() {}
uint32 message_type() const {
return message_type_;
}
private:
int id_;
uint32 message_type_;
void* key_;
friend class SyncMessageReplyDispatcher;
};
SyncMessageReplyDispatcher() {}
void Push(IPC::SyncMessage* msg, SyncMessageCallContext* context,
void* key);
void Cancel(void* key);
protected:
typedef std::deque<SyncMessageCallContext*> PendingSyncMessageQueue;
SyncMessageCallContext* GetContext(const IPC::Message& msg);
virtual bool OnMessageReceived(const IPC::Message& msg);
// Child classes must implement a handler for the message types they are
// interested in handling responses for. If you don't care about the replies
// to any of the sync messages you are handling, then you don't have to
// implement this.
virtual bool HandleMessageType(const IPC::Message& msg,
SyncMessageCallContext* context);
template <typename T>
void InvokeCallback(const IPC::Message& msg,
SyncMessageCallContext* call_context) {
if (!call_context || !call_context->key_) {
NOTREACHED() << "Invalid context parameter";
return;
}
T* context = static_cast<T*>(call_context);
T::output_type tmp; // Acts as "initializer" for output parameters.
IPC::ParamDeserializer<T::output_type> deserializer(tmp);
if (deserializer.MessageReplyDeserializer::SerializeOutputParameters(msg)) {
DispatchToMethod(context, &T::Completed, deserializer.out_);
delete context;
} else {
// TODO(stoyan): How to handle errors?
}
}
PendingSyncMessageQueue message_queue_;
base::Lock message_queue_lock_;
};
#endif // CHROME_FRAME_SYNC_MSG_REPLY_DISPATCHER_H_
|
