forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
tcp_connected_socket_impl.h
76 lines (59 loc) · 2.62 KB
/
tcp_connected_socket_impl.h
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
// 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_SERVICES_NETWORK_TCP_CONNECTED_SOCKET_H_
#define MOJO_SERVICES_NETWORK_TCP_CONNECTED_SOCKET_H_
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "mojo/common/handle_watcher.h"
#include "mojo/services/network/public/interfaces/tcp_connected_socket.mojom.h"
#include "net/socket/tcp_socket.h"
#include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
namespace mojo {
class MojoToNetPendingBuffer;
class NetToMojoPendingBuffer;
class TCPConnectedSocketImpl : public TCPConnectedSocket, public ErrorHandler {
public:
TCPConnectedSocketImpl(scoped_ptr<net::TCPSocket> socket,
ScopedDataPipeConsumerHandle send_stream,
ScopedDataPipeProducerHandle receive_stream,
InterfaceRequest<TCPConnectedSocket> request);
~TCPConnectedSocketImpl() override;
private:
// ErrorHandler methods:
void OnConnectionError() override;
// "Receiving" in this context means reading from TCPSocket and writing to
// the Mojo receive_stream.
void ReceiveMore();
void OnReceiveStreamReady(MojoResult result);
void DidReceive(bool completed_synchronously, int result);
void ShutdownReceive();
void ListenForReceivePeerClosed();
void OnReceiveDataPipeClosed(MojoResult result);
// "Writing" is reading from the Mojo send_stream and writing to the
// TCPSocket.
void SendMore();
void OnSendStreamReady(MojoResult result);
void DidSend(bool completed_asynchronously, int result);
void ShutdownSend();
void ListenForSendPeerClosed();
void OnSendDataPipeClosed(MojoResult result);
void DeleteIfNeeded();
scoped_ptr<net::TCPSocket> socket_;
// The *stream handles will be null while there is an in-progress transation
// between net and mojo. During this time, the handle will be owned by the
// *PendingBuffer.
// For reading from the network and writing to Mojo pipe.
ScopedDataPipeConsumerHandle send_stream_;
scoped_refptr<NetToMojoPendingBuffer> pending_receive_;
common::HandleWatcher receive_handle_watcher_;
// For reading from the Mojo pipe and writing to the network.
ScopedDataPipeProducerHandle receive_stream_;
scoped_refptr<MojoToNetPendingBuffer> pending_send_;
common::HandleWatcher send_handle_watcher_;
// To bind to the message pipe.
Binding<TCPConnectedSocket> binding_;
base::WeakPtrFactory<TCPConnectedSocketImpl> weak_ptr_factory_;
};
} // namespace mojo
#endif // MOJO_SERVICES_NETWORK_TCP_CONNECTED_SOCKET_H_