1// Copyright (c) 2012 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 IPC_IPC_SYNC_MESSAGE_H_ 6#define IPC_IPC_SYNC_MESSAGE_H_ 7 8#if defined(OS_WIN) 9#include <windows.h> 10#endif 11#include <string> 12#include "base/basictypes.h" 13#include "base/memory/scoped_ptr.h" 14#include "ipc/ipc_message.h" 15 16namespace base { 17class WaitableEvent; 18} 19 20namespace IPC { 21 22class MessageReplyDeserializer; 23 24class IPC_EXPORT SyncMessage : public Message { 25 public: 26 SyncMessage(int32 routing_id, uint32 type, PriorityValue priority, 27 MessageReplyDeserializer* deserializer); 28 virtual ~SyncMessage(); 29 30 // Call this to get a deserializer for the output parameters. 31 // Note that this can only be called once, and the caller is responsible 32 // for deleting the deserializer when they're done. 33 MessageReplyDeserializer* GetReplyDeserializer(); 34 35 // If this message can cause the receiver to block while waiting for user 36 // input (i.e. by calling MessageBox), then the caller needs to pump window 37 // messages and dispatch asynchronous messages while waiting for the reply. 38 // If this event is passed in, then window messages will start being pumped 39 // when it's set. Note that this behavior will continue even if the event is 40 // later reset. The event must be valid until after the Send call returns. 41 void set_pump_messages_event(base::WaitableEvent* event) { 42 pump_messages_event_ = event; 43 if (event) { 44 header()->flags |= PUMPING_MSGS_BIT; 45 } else { 46 header()->flags &= ~PUMPING_MSGS_BIT; 47 } 48 } 49 50 // Call this if you always want to pump messages. You can call this method 51 // or set_pump_messages_event but not both. 52 void EnableMessagePumping(); 53 54 base::WaitableEvent* pump_messages_event() const { 55 return pump_messages_event_; 56 } 57 58 // Returns true if the message is a reply to the given request id. 59 static bool IsMessageReplyTo(const Message& msg, int request_id); 60 61 // Given a reply message, returns an iterator to the beginning of the data 62 // (i.e. skips over the synchronous specific data). 63 static PickleIterator GetDataIterator(const Message* msg); 64 65 // Given a synchronous message (or its reply), returns its id. 66 static int GetMessageId(const Message& msg); 67 68 // Generates a reply message to the given message. 69 static Message* GenerateReply(const Message* msg); 70 71 private: 72 struct SyncHeader { 73 // unique ID (unique per sender) 74 int message_id; 75 }; 76 77 static bool ReadSyncHeader(const Message& msg, SyncHeader* header); 78 static bool WriteSyncHeader(Message* msg, const SyncHeader& header); 79 80 scoped_ptr<MessageReplyDeserializer> deserializer_; 81 base::WaitableEvent* pump_messages_event_; 82}; 83 84// Used to deserialize parameters from a reply to a synchronous message 85class IPC_EXPORT MessageReplyDeserializer { 86 public: 87 virtual ~MessageReplyDeserializer() {} 88 bool SerializeOutputParameters(const Message& msg); 89 private: 90 // Derived classes need to implement this, using the given iterator (which 91 // is skipped past the header for synchronous messages). 92 virtual bool SerializeOutputParameters(const Message& msg, 93 PickleIterator iter) = 0; 94}; 95 96// When sending a synchronous message, this structure contains an object 97// that knows how to deserialize the response. 98struct PendingSyncMsg { 99 PendingSyncMsg(int id, 100 MessageReplyDeserializer* d, 101 base::WaitableEvent* e) 102 : id(id), deserializer(d), done_event(e), send_result(false) { } 103 int id; 104 MessageReplyDeserializer* deserializer; 105 base::WaitableEvent* done_event; 106 bool send_result; 107}; 108 109} // namespace IPC 110 111#endif // IPC_IPC_SYNC_MESSAGE_H_ 112