Skip to content

GitLab

T
tangled
Commit 633614a6 authored by viettrungluu's avatar viettrungluu Committed by Commit bot
Browse files
Options

Mojo: Factor Channel::EndpointInfo out to ChannelEndpoint. 

Also do a bunch of other small things. See the plan at the top of
channel_endpoint.h.

R=darin@chromium.org

Review URL: https://codereview.chromium.org/541233002

Cr-Commit-Position: refs/heads/master@{#293444}
parent a18a71f8
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 232 additions and 161 deletions
mojo/mojo_base.gyp
View file @ 633614a6
......@@ -121,6 +121,8 @@
'embedder/simple_platform_support.h',
'system/channel.cc',
'system/channel.h',
'system/channel_endpoint.cc',
'system/channel_endpoint.h',
'system/constants.h',
'system/core.cc',
'system/core.h',
......
mojo/system/BUILD.gn
View file @ 633614a6
......@@ -28,6 +28,8 @@ component("system") {
sources = [
"channel.cc",
"channel.h",
"channel_endpoint.cc",
"channel_endpoint.h",
"constants.h",
"core.cc",
"core.h",
......
mojo/system/channel.cc
View file @ 633614a6
This diff is collapsed.
mojo/system/channel.h
View file @ 633614a6
......@@ -17,6 +17,7 @@
#include "base/threading/thread_checker.h"
#include "mojo/embedder/scoped_platform_handle.h"
#include "mojo/public/c/system/types.h"
#include "mojo/system/channel_endpoint.h"
#include "mojo/system/message_in_transit.h"
#include "mojo/system/message_pipe.h"
#include "mojo/system/raw_channel.h"
......@@ -132,91 +133,6 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel
}
private:
// Terminology:
// - "Message pipe endpoint": In the implementation, a |MessagePipe| owns
// two |MessagePipeEndpoint| objects, one for each port. The
// |MessagePipeEndpoint| objects are only accessed via the |MessagePipe|
// (which has the lock), with the additional information of the port
// number. So as far as the channel is concerned, a message pipe endpoint
// is a pointer to a |MessagePipe| together with the port number.
// - The value of |port| in |EndpointInfo| refers to the
// |ProxyMessagePipeEndpoint| (i.e., the endpoint that is logically on
// the other side). Messages received by a channel for a message pipe
// are thus written to the *peer* of this port.
// - "Attached"/"detached": A message pipe endpoint is attached to a channel
// if it has a pointer to it. It must be detached before the channel gives
// up its pointer to it in order to break a reference cycle. (This cycle
// is needed to allow a channel to be shut down cleanly, without shutting
// down everything else first.)
// - "Running" (message pipe endpoint): A message pipe endpoint is running
// if messages written to it (via some |MessagePipeDispatcher|, to which
// some |MojoHandle| is assigned) are being transmitted through the
// channel.
// - Before a message pipe endpoint is run, it will queue messages.
// - When a message pipe endpoint is detached from a channel, it is also
// taken out of the running state. After that point, messages should
// no longer be written to it.
// - "Normal" message pipe endpoint (state): The channel itself does not
// have knowledge of whether a message pipe endpoint has started running
// yet. It will *receive* messages for a message pipe in either state (but
// the message pipe endpoint won't *send* messages to the channel if it
// has not started running).
// - "Zombie" message pipe endpoint (state): A message pipe endpoint is a
// zombie if it is still in |local_id_to_endpoint_info_map_|, but the
// channel is no longer forwarding messages to it (even if it may still be
// receiving messages for it).
// - There are various types of zombies, depending on the reason the
// message pipe endpoint cannot yet be removed.
// - If the remote side is closed, it will send a "remove" control
// message. After the channel receives that message (to which it
// responds with a "remove ack" control message), it knows that it
// shouldn't receive any more messages for that message pipe endpoint
// (local ID), but it must wait for the endpoint to detach. (It can't
// do so without a race, since it can't call into the message pipe
// under |lock_|.) [TODO(vtl): When I add remotely-allocated IDs,
// we'll have to remove the |EndpointInfo| from
// |local_id_to_endpoint_info_map_| -- i.e., remove the local ID,
// since it's no longer valid and may be reused by the remote side --
// and keep the |EndpointInfo| alive in some other way.]
// - If the local side is closed and the message pipe endpoint was
// already running (so there are no queued messages left to send), it
// will detach the endpoint, and send a "remove" control message.
// However, the channel may still receive messages for that endpoint
// until it receives a "remove ack" control message.
// - If the local side is closed but the message pipe endpoint was not
// yet running , the detaching is delayed until after it is run and
// all the queued messages are sent to the channel. On being detached,
// things proceed as in one of the above cases. The endpoint is *not*
// a zombie until it is detached (or a "remove" message is received).
// [TODO(vtl): Maybe we can get rid of this case? It'd only not yet be
// running since under the current scheme it wouldn't have a remote ID
// yet.]
// - Note that even if the local side is closed, it may still receive a
// "remove" message from the other side (if the other side is closed
// simultaneously, and both sides send "remove" messages). In that
// case, it must still remain alive until it receives the "remove
// ack" (and it must ack the "remove" message that it received).
struct EndpointInfo {
enum State {
// Attached, possibly running or not.
STATE_NORMAL,
// "Zombie" states:
// Waiting for |DetachMessagePipeEndpoint()| before removing.
STATE_WAIT_LOCAL_DETACH,
// Waiting for a |kSubtypeChannelRemoveMessagePipeEndpointAck| before
// removing.
STATE_WAIT_REMOTE_REMOVE_ACK,
};
EndpointInfo();
EndpointInfo(scoped_refptr<MessagePipe> message_pipe, unsigned port);
~EndpointInfo();
State state;
scoped_refptr<MessagePipe> message_pipe;
unsigned port;
};
friend class base::RefCountedThreadSafe<Channel>;
virtual ~Channel();
......@@ -257,9 +173,8 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel
// Note: |MessagePipe|s MUST NOT be used under |lock_|. I.e., |lock_| can only
// be acquired after |MessagePipe::lock_|, never before. Thus to call into a
// |MessagePipe|, a reference should be acquired from
// |local_id_to_endpoint_info_map_| under |lock_| (e.g., by copying the
// |EndpointInfo|) and then the lock released.
// |MessagePipe|, a reference to the |MessagePipe| should be acquired from
// |local_id_to_endpoint_map_| under |lock_| and then the lock released.
base::Lock lock_; // Protects the members below.
scoped_ptr<RawChannel> raw_channel_;
......@@ -267,9 +182,9 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel
// Set when |WillShutdownSoon()| is called.
bool is_shutting_down_;
typedef base::hash_map<MessageInTransit::EndpointId, EndpointInfo>
IdToEndpointInfoMap;
IdToEndpointInfoMap local_id_to_endpoint_info_map_;
typedef base::hash_map<MessageInTransit::EndpointId,
scoped_refptr<ChannelEndpoint> > IdToEndpointMap;
IdToEndpointMap local_id_to_endpoint_map_;
// The next local ID to try (when allocating new local IDs). Note: It should
// be checked for existence before use.
MessageInTransit::EndpointId next_local_id_;
......
mojo/system/channel_endpoint.cc 0 → 100644
View file @ 633614a6
// Copyright 2014 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.
#include "mojo/system/channel_endpoint.h"
#include "mojo/system/channel.h"
#include "mojo/system/message_in_transit_queue.h"
namespace mojo {
namespace system {
ChannelEndpoint::ChannelEndpoint(MessagePipe* message_pipe, unsigned port)
: state_(STATE_NORMAL), message_pipe_(message_pipe), port_(port) {
}
ChannelEndpoint::~ChannelEndpoint() {
}
} // namespace system
} // namespace mojo
mojo/system/channel_endpoint.h 0 → 100644
View file @ 633614a6
// Copyright 2014 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_SYSTEM_CHANNEL_ENDPOINT_H_
#define MOJO_SYSTEM_CHANNEL_ENDPOINT_H_
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "mojo/system/message_pipe.h"
#include "mojo/system/system_impl_export.h"
namespace mojo {
namespace system {
class Channel;
// TODO(vtl): The plan:
// - (Done.) Move |Channel::Endpoint| to |ChannelEndpoint|. Make it
// refcounted, and not copyable. Make |Channel| a friend. Make things work.
// - Give |ChannelEndpoint| a lock (which nothing else should be called
// under -- thus can be taken under any other lock, in particular
// |Channel|'s lock and |MessagePipe|'s lock). Stop having |Channel| as a
// friend.
// - Move logic from |ProxyMessagePipeEndpoint| into |ChannelEndpoint|. Right
// now, we have to go through lots of contortions to manipulate state owned
// by |ProxyMessagePipeEndpoint| (in particular, |Channel::Endpoint| doesn't
// know about the remote ID; the local ID is duplicated in two places).
// Hollow out |ProxyMessagePipeEndpoint|, and have it just own a reference
// to |ChannelEndpoint| (hence the refcounting).
// - In essence, |ChannelEndpoint| becomes the thing that knows about
// channel-specific aspects of an endpoint (notably local and remote IDs,
// and knowledge about handshaking), and mediates between the |Channel| and
// the |MessagePipe|.
//
// Things as they are now, before I change everything (TODO(vtl): update this
// comment appropriately):
//
// Terminology:
// - "Message pipe endpoint": In the implementation, a |MessagePipe| owns
// two |MessagePipeEndpoint| objects, one for each port. The
// |MessagePipeEndpoint| objects are only accessed via the |MessagePipe|
// (which has the lock), with the additional information of the port
// number. So as far as the channel is concerned, a message pipe endpoint
// is a pointer to a |MessagePipe| together with the port number.
// - The value of |port| in |EndpointInfo| refers to the
// |ProxyMessagePipeEndpoint| (i.e., the endpoint that is logically on
// the other side). Messages received by a channel for a message pipe
// are thus written to the *peer* of this port.
// - "Attached"/"detached": A message pipe endpoint is attached to a channel
// if it has a pointer to it. It must be detached before the channel gives
// up its pointer to it in order to break a reference cycle. (This cycle
// is needed to allow a channel to be shut down cleanly, without shutting
// down everything else first.)
// - "Running" (message pipe endpoint): A message pipe endpoint is running
// if messages written to it (via some |MessagePipeDispatcher|, to which
// some |MojoHandle| is assigned) are being transmitted through the
// channel.
// - Before a message pipe endpoint is run, it will queue messages.
// - When a message pipe endpoint is detached from a channel, it is also
// taken out of the running state. After that point, messages should
// no longer be written to it.
// - "Normal" message pipe endpoint (state): The channel itself does not
// have knowledge of whether a message pipe endpoint has started running
// yet. It will *receive* messages for a message pipe in either state (but
// the message pipe endpoint won't *send* messages to the channel if it
// has not started running).
// - "Zombie" message pipe endpoint (state): A message pipe endpoint is a
// zombie if it is still in |local_id_to_endpoint_info_map_|, but the
// channel is no longer forwarding messages to it (even if it may still be
// receiving messages for it).
// - There are various types of zombies, depending on the reason the
// message pipe endpoint cannot yet be removed.
// - If the remote side is closed, it will send a "remove" control
// message. After the channel receives that message (to which it
// responds with a "remove ack" control message), it knows that it
// shouldn't receive any more messages for that message pipe endpoint
// (local ID), but it must wait for the endpoint to detach. (It can't
// do so without a race, since it can't call into the message pipe
// under |lock_|.) [TODO(vtl): When I add remotely-allocated IDs,
// we'll have to remove the |EndpointInfo| from
// |local_id_to_endpoint_info_map_| -- i.e., remove the local ID,
// since it's no longer valid and may be reused by the remote side --
// and keep the |EndpointInfo| alive in some other way.]
// - If the local side is closed and the message pipe endpoint was
// already running (so there are no queued messages left to send), it
// will detach the endpoint, and send a "remove" control message.
// However, the channel may still receive messages for that endpoint
// until it receives a "remove ack" control message.
// - If the local side is closed but the message pipe endpoint was not
// yet running , the detaching is delayed until after it is run and
// all the queued messages are sent to the channel. On being detached,
// things proceed as in one of the above cases. The endpoint is *not*
// a zombie until it is detached (or a "remove" message is received).
// [TODO(vtl): Maybe we can get rid of this case? It'd only not yet be
// running since under the current scheme it wouldn't have a remote ID
// yet.]
// - Note that even if the local side is closed, it may still receive a
// "remove" message from the other side (if the other side is closed
// simultaneously, and both sides send "remove" messages). In that
// case, it must still remain alive until it receives the "remove
// ack" (and it must ack the "remove" message that it received).
class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpoint
: public base::RefCountedThreadSafe<ChannelEndpoint> {
public:
ChannelEndpoint(MessagePipe* message_pipe, unsigned port);
private:
enum State {
// Attached, possibly running or not.
STATE_NORMAL,
// "Zombie" states:
// Waiting for |DetachMessagePipeEndpoint()| before removing.
STATE_WAIT_LOCAL_DETACH,
// Waiting for a |kSubtypeChannelRemoveMessagePipeEndpointAck| before
// removing.
STATE_WAIT_REMOTE_REMOVE_ACK,
};
// TODO(vtl): This is totally temporary, until this becomes a proper
// self-contained class. See the plan above.
friend class Channel;
friend class base::RefCountedThreadSafe<ChannelEndpoint>;
~ChannelEndpoint();
State state_;
scoped_refptr<MessagePipe> message_pipe_;
unsigned port_;
DISALLOW_COPY_AND_ASSIGN(ChannelEndpoint);
};
} // namespace system
} // namespace mojo
#endif // MOJO_SYSTEM_CHANNEL_ENDPOINT_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment